From f884dadb0234905c8b4a56db7624eea9c9312d8a Mon Sep 17 00:00:00 2001
From: sundarshahi <shahithakurisundar@gmail.com>
Date: Fri, 30 Oct 2026 00:52:41 +0545
Subject: [PATCH 1/4] fix(table-core): add header.getIsPinned() for group
 headers split across pinned regions

A group column split across pinned regions renders one header per region,
but header.column.getIsPinned() reports a single region for all of them, so
the group header on the end side read 'start'. header.getIsPinned() reads
the region shared by the header's own leaf columns (false when mixed).

The column-pinning-split example now uses it for its pin buttons.

Fixes #4906
---
 .changeset/header-get-is-pinned.md            |  5 ++
 .../react/column-pinning-split/src/main.tsx   | 18 +++---
 .../column-pinning/columnPinningFeature.ts    |  9 +++
 .../columnPinningFeature.types.ts             | 10 ++++
 .../columnPinningFeature.utils.ts             | 33 ++++++++++
 packages/table-core/src/types/Header.ts       |  2 +
 .../columnPinningFeature.utils.test.ts        | 60 +++++++++++++++++++
 7 files changed, 128 insertions(+), 9 deletions(-)
 create mode 100644 .changeset/header-get-is-pinned.md

diff --git a/.changeset/header-get-is-pinned.md b/.changeset/header-get-is-pinned.md
new file mode 100644
index 0000000000..2d08d9968e
--- /dev/null
+++ b/.changeset/header-get-is-pinned.md
@@ -0,0 +1,5 @@
+---
+'@tanstack/table-core': minor
+---
+
+Add `header.getIsPinned()`, which reads the pinned region of a header's own leaf columns. A group column split across pinned regions renders one header per region, and `header.column.getIsPinned()` reported the same region for all of them (#4906).
diff --git a/examples/react/column-pinning-split/src/main.tsx b/examples/react/column-pinning-split/src/main.tsx
index 747de17796..70a6b33651 100644
--- a/examples/react/column-pinning-split/src/main.tsx
+++ b/examples/react/column-pinning-split/src/main.tsx
@@ -164,7 +164,7 @@ function App() {
                     </div>
                     {!header.isPlaceholder && header.column.getCanPin() && (
                       <div className="pin-actions">
-                        {header.column.getIsPinned() !== 'start' ? (
+                        {header.getIsPinned() !== 'start' ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -174,7 +174,7 @@ function App() {
                             {'<='}
                           </button>
                         ) : null}
-                        {header.column.getIsPinned() ? (
+                        {header.getIsPinned() ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -184,7 +184,7 @@ function App() {
                             X
                           </button>
                         ) : null}
-                        {header.column.getIsPinned() !== 'end' ? (
+                        {header.getIsPinned() !== 'end' ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -233,7 +233,7 @@ function App() {
                     </div>
                     {!header.isPlaceholder && header.column.getCanPin() && (
                       <div className="pin-actions">
-                        {header.column.getIsPinned() !== 'start' ? (
+                        {header.getIsPinned() !== 'start' ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -243,7 +243,7 @@ function App() {
                             {'<='}
                           </button>
                         ) : null}
-                        {header.column.getIsPinned() ? (
+                        {header.getIsPinned() ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -253,7 +253,7 @@ function App() {
                             X
                           </button>
                         ) : null}
-                        {header.column.getIsPinned() !== 'end' ? (
+                        {header.getIsPinned() !== 'end' ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -302,7 +302,7 @@ function App() {
                     </div>
                     {!header.isPlaceholder && header.column.getCanPin() && (
                       <div className="pin-actions">
-                        {header.column.getIsPinned() !== 'start' ? (
+                        {header.getIsPinned() !== 'start' ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -312,7 +312,7 @@ function App() {
                             {'<='}
                           </button>
                         ) : null}
-                        {header.column.getIsPinned() ? (
+                        {header.getIsPinned() ? (
                           <button
                             className="pin-button"
                             onClick={() => {
@@ -322,7 +322,7 @@ function App() {
                             X
                           </button>
                         ) : null}
-                        {header.column.getIsPinned() !== 'end' ? (
+                        {header.getIsPinned() !== 'end' ? (
                           <button
                             className="pin-button"
                             onClick={() => {
diff --git a/packages/table-core/src/features/column-pinning/columnPinningFeature.ts b/packages/table-core/src/features/column-pinning/columnPinningFeature.ts
index bb2fb5bce4..7131145b7e 100644
--- a/packages/table-core/src/features/column-pinning/columnPinningFeature.ts
+++ b/packages/table-core/src/features/column-pinning/columnPinningFeature.ts
@@ -11,6 +11,7 @@ import {
   column_getPinnedIndex,
   column_pin,
   getDefaultColumnPinningState,
+  header_getIsPinned,
   row_getCenterVisibleCells,
   row_getEndVisibleCells,
   row_getStartVisibleCells,
@@ -83,6 +84,14 @@ export const columnPinningFeature: TableFeature = {
     })
   },
 
+  assignHeaderPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnPinningFeature', prototype, table, {
+      header_getIsPinned: {
+        fn: (header) => header_getIsPinned(header),
+      },
+    })
+  },
+
   assignRowPrototype: (prototype, table) => {
     assignPrototypeAPIs('columnPinningFeature', prototype, table, {
       row_getCenterVisibleCells: {
diff --git a/packages/table-core/src/features/column-pinning/columnPinningFeature.types.ts b/packages/table-core/src/features/column-pinning/columnPinningFeature.types.ts
index 15e3bdce7b..b2a24a1e07 100644
--- a/packages/table-core/src/features/column-pinning/columnPinningFeature.types.ts
+++ b/packages/table-core/src/features/column-pinning/columnPinningFeature.types.ts
@@ -77,6 +77,16 @@ export interface Column_ColumnPinning {
   pin: (position: ColumnPinningPosition) => void
 }
 
+export interface Header_ColumnPinning {
+  /**
+   * Reads the logical pinned position shared by this header's own leaf
+   * columns: `'start'`, `'end'`, or `false` when unpinned or mixed. Unlike
+   * `header.column.getIsPinned()`, a group header split across regions
+   * reports the region it is rendered in.
+   */
+  getIsPinned: () => ColumnPinningPosition
+}
+
 export interface Row_ColumnPinning<
   in out TFeatures extends TableFeatures,
   in out TData extends RowData,
diff --git a/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts b/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts
index 51d1ed23a8..c23f2d2a0a 100644
--- a/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts
+++ b/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts
@@ -189,6 +189,39 @@ export function column_getPinnedIndex<
     : 0
 }
 
+// Header APIs
+
+/**
+ * Reads the pinned region of this header's own leaf columns.
+ *
+ * A group column split across regions renders one header per region, so its
+ * column reports a single position. The header only spans its own leaves:
+ * returns their shared position, or `false` when they are unpinned or mixed.
+ *
+ * @example
+ * ```ts
+ * const position = header_getIsPinned(header)
+ * ```
+ */
+export function header_getIsPinned<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+>(header: Header<TFeatures, TData, TValue>): ColumnPinningPosition {
+  const leafHeaders = header.getLeafHeaders()
+  if (!leafHeaders.length) {
+    return false
+  }
+
+  const position = column_getIsPinned(leafHeaders[0]!.column)
+  for (let i = 1; i < leafHeaders.length; i++) {
+    if (column_getIsPinned(leafHeaders[i]!.column) !== position) {
+      return false
+    }
+  }
+  return position
+}
+
 // Row APIs
 
 /**
diff --git a/packages/table-core/src/types/Header.ts b/packages/table-core/src/types/Header.ts
index 2a85f694ee..31a3a56794 100644
--- a/packages/table-core/src/types/Header.ts
+++ b/packages/table-core/src/types/Header.ts
@@ -3,6 +3,7 @@ import type { CellData, RowData } from './type-utils'
 import type { ExtractFeatureMapTypes, TableFeatures } from './TableFeatures'
 import type { Header_Header } from '../core/headers/coreHeadersFeature.types'
 import type { Header_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types'
+import type { Header_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types'
 
 export interface Header_Core<
   in out TFeatures extends TableFeatures,
@@ -11,6 +12,7 @@ export interface Header_Core<
 > extends Header_Header<TFeatures, TData, TValue> {}
 
 export interface Header_FeatureMap {
+  columnPinningFeature: Header_ColumnPinning
   columnSizingFeature: Header_ColumnSizing
   columnResizingFeature: Header_ColumnResizing
 }
diff --git a/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts b/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts
index 59bebfb324..de474f7ef5 100644
--- a/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts
+++ b/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts
@@ -12,6 +12,7 @@ import {
   column_getPinnedIndex,
   column_pin,
   getDefaultColumnPinningState,
+  header_getIsPinned,
   row_getCenterVisibleCells,
   row_getStartVisibleCells,
   row_getEndVisibleCells,
@@ -281,6 +282,65 @@ describe('column_getIsPinned', () => {
   })
 })
 
+describe('header_getIsPinned', () => {
+  function makeSplitGroupTable() {
+    const columns: Array<ColumnDef<typeof features, Person, any>> = [
+      {
+        id: 'identity',
+        columns: [
+          { accessorKey: 'firstName', id: 'firstName' },
+          { accessorKey: 'age', id: 'age' },
+          { accessorKey: 'lastName', id: 'lastName' },
+        ],
+      },
+    ]
+    return constructTable<typeof features, Person>({
+      features,
+      columns,
+      data: generateTestData(1),
+      initialState: {
+        columnPinning: {
+          start: ['firstName'],
+          end: ['lastName'],
+        },
+      },
+    })
+  }
+
+  it('should report the region each split group header is rendered in', () => {
+    const table = makeSplitGroupTable()
+    const startGroup = table_getStartHeaderGroups(table)[0]!.headers[0]!
+    const centerGroup = table_getCenterHeaderGroups(table)[0]!.headers[0]!
+    const endGroup = table_getEndHeaderGroups(table)[0]!.headers[0]!
+
+    // the shared group column can only report one region
+    expect(column_getIsPinned(endGroup.column)).toBe('start')
+
+    expect(header_getIsPinned(startGroup)).toBe('start')
+    expect(header_getIsPinned(centerGroup)).toBe(false)
+    expect(header_getIsPinned(endGroup)).toBe('end')
+    expect(endGroup.getIsPinned()).toBe('end')
+  })
+
+  it('should return false when a header spans leaves from different regions', () => {
+    const table = makeSplitGroupTable()
+    const groupHeader = table.getHeaderGroups()[0]!.headers[0]!
+
+    expect(groupHeader.getLeafHeaders()).toHaveLength(3)
+    expect(header_getIsPinned(groupHeader)).toBe(false)
+  })
+
+  it('should match the column for leaf headers', () => {
+    const table = makeSplitGroupTable()
+    const leaf = (id: string) =>
+      table.getLeafHeaders().find((header) => header.column.id === id)!
+
+    expect(header_getIsPinned(leaf('firstName'))).toBe('start')
+    expect(header_getIsPinned(leaf('age'))).toBe(false)
+    expect(header_getIsPinned(leaf('lastName'))).toBe('end')
+  })
+})
+
 describe('table_setColumnPinning', () => {
   it('should call onColumnPinningChange with updater', () => {
     const onColumnPinningChange = vi.fn()

From b3b81b4cd70c3eee4f857fed7cdb4d5467343631 Mon Sep 17 00:00:00 2001
From: sundarshahi <shahithakurisundar@gmail.com>
Date: Fri, 30 Oct 2026 09:02:03 +0545
Subject: [PATCH 2/4] fix(table-core): read only leaf headers in
 header.getIsPinned()

getLeafHeaders() also returns the header itself and any intermediate group
headers. Their shared group column reports every region its leaves are
pinned to, so a split group header in the end region read false instead of
'end'. Skip headers that have sub-headers.

Add unit tests for a group split start/end with no center leaves and for
nested group headers, an e2e test for the column-pinning-split group pin
buttons, and header.getIsPinned to the column pinning guides.
---
 docs/framework/alpine/guide/column-pinning.md |  1 +
 .../framework/angular/guide/column-pinning.md |  1 +
 docs/framework/ember/guide/column-pinning.md  |  1 +
 docs/framework/lit/guide/column-pinning.md    |  1 +
 docs/framework/octane/guide/column-pinning.md |  1 +
 docs/framework/preact/guide/column-pinning.md |  1 +
 docs/framework/react/guide/column-pinning.md  |  1 +
 docs/framework/solid/guide/column-pinning.md  |  1 +
 docs/framework/svelte/guide/column-pinning.md |  1 +
 docs/framework/vue/guide/column-pinning.md    |  1 +
 .../tests/e2e/smoke.spec.ts                   | 30 ++++++++
 .../columnPinningFeature.utils.ts             | 27 ++++---
 .../columnPinningFeature.utils.test.ts        | 73 ++++++++++++++++++-
 13 files changed, 130 insertions(+), 10 deletions(-)

diff --git a/docs/framework/alpine/guide/column-pinning.md b/docs/framework/alpine/guide/column-pinning.md
index e82ae63317..1a3f849580 100644
--- a/docs/framework/alpine/guide/column-pinning.md
+++ b/docs/framework/alpine/guide/column-pinning.md
@@ -140,6 +140,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/angular/guide/column-pinning.md b/docs/framework/angular/guide/column-pinning.md
index 8f9a6af3e3..115cecc5fd 100644
--- a/docs/framework/angular/guide/column-pinning.md
+++ b/docs/framework/angular/guide/column-pinning.md
@@ -139,6 +139,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/ember/guide/column-pinning.md b/docs/framework/ember/guide/column-pinning.md
index 75313e4660..81436a25ea 100644
--- a/docs/framework/ember/guide/column-pinning.md
+++ b/docs/framework/ember/guide/column-pinning.md
@@ -139,6 +139,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/lit/guide/column-pinning.md b/docs/framework/lit/guide/column-pinning.md
index 6afb6eda89..f8f9e184c4 100644
--- a/docs/framework/lit/guide/column-pinning.md
+++ b/docs/framework/lit/guide/column-pinning.md
@@ -147,6 +147,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/octane/guide/column-pinning.md b/docs/framework/octane/guide/column-pinning.md
index a947903be3..ef84d38fa1 100644
--- a/docs/framework/octane/guide/column-pinning.md
+++ b/docs/framework/octane/guide/column-pinning.md
@@ -129,6 +129,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/preact/guide/column-pinning.md b/docs/framework/preact/guide/column-pinning.md
index 6a57f46fb0..1746925291 100644
--- a/docs/framework/preact/guide/column-pinning.md
+++ b/docs/framework/preact/guide/column-pinning.md
@@ -129,6 +129,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/react/guide/column-pinning.md b/docs/framework/react/guide/column-pinning.md
index 740c9a8d35..7a4047f953 100644
--- a/docs/framework/react/guide/column-pinning.md
+++ b/docs/framework/react/guide/column-pinning.md
@@ -129,6 +129,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/solid/guide/column-pinning.md b/docs/framework/solid/guide/column-pinning.md
index 79d0a75b81..620c1380e4 100644
--- a/docs/framework/solid/guide/column-pinning.md
+++ b/docs/framework/solid/guide/column-pinning.md
@@ -135,6 +135,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/svelte/guide/column-pinning.md b/docs/framework/svelte/guide/column-pinning.md
index 3926d47955..bd7387b8d5 100644
--- a/docs/framework/svelte/guide/column-pinning.md
+++ b/docs/framework/svelte/guide/column-pinning.md
@@ -136,6 +136,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/docs/framework/vue/guide/column-pinning.md b/docs/framework/vue/guide/column-pinning.md
index 8113e557ca..767b695d78 100644
--- a/docs/framework/vue/guide/column-pinning.md
+++ b/docs/framework/vue/guide/column-pinning.md
@@ -136,6 +136,7 @@ There are a handful of useful Column API methods to help you implement column pi
 - `column.getCanPin`: Use to determine if a column can be pinned.
 - `column.pin`: Use to pin a column to the start or end. Or use to unpin a column.
 - `column.getIsPinned`: Use to determine where a column is pinned.
+- `header.getIsPinned`: Use to determine where a header is pinned. A group header split across pinned regions reports the region it is rendered in, which `header.column.getIsPinned` cannot.
 - `column.getPinnedIndex`: Use to read the column's index within its pinned column group.
 - `column.getStart`: Use to provide the correct `start` CSS value for a pinned column.
 - `column.getAfter`: Use to provide the correct `end` CSS value for a pinned column.
diff --git a/examples/react/column-pinning-split/tests/e2e/smoke.spec.ts b/examples/react/column-pinning-split/tests/e2e/smoke.spec.ts
index c101c0ca57..935eb83643 100644
--- a/examples/react/column-pinning-split/tests/e2e/smoke.spec.ts
+++ b/examples/react/column-pinning-split/tests/e2e/smoke.spec.ts
@@ -195,6 +195,36 @@ test('returns a column to the centre table when unpinned', async ({ page }) => {
   expect(errors).toEqual([])
 })
 
+test('offers pin buttons for the region a split group header is in', async ({
+  page,
+}) => {
+  const errors = await openExample(page)
+
+  await pinButton(page, CENTER_TABLE, 'firstName', '<=').click()
+  await expect.poll(() => leafCount(page, START_TABLE)).toBe(1)
+  await pinButton(page, CENTER_TABLE, 'Last Name', '=>').click()
+  await expect.poll(() => leafCount(page, END_TABLE)).toBe(1)
+
+  // The "Name" group is split, so the start and end tables each render a
+  // "Name" header for the same group column. Each must act on its own region.
+  const groupPinButton = (tableIndex: number, label: '<=' | 'X' | '=>') =>
+    tableAt(page, tableIndex)
+      .locator('thead tr')
+      .first()
+      .locator('th')
+      .filter({ hasText: 'Name' })
+      .getByRole('button', { name: label, exact: true })
+
+  await expect(groupPinButton(START_TABLE, '<=')).toHaveCount(0)
+  await expect(groupPinButton(START_TABLE, 'X')).toHaveCount(1)
+  await expect(groupPinButton(START_TABLE, '=>')).toHaveCount(1)
+  await expect(groupPinButton(END_TABLE, '<=')).toHaveCount(1)
+  await expect(groupPinButton(END_TABLE, 'X')).toHaveCount(1)
+  await expect(groupPinButton(END_TABLE, '=>')).toHaveCount(0)
+
+  expect(errors).toEqual([])
+})
+
 test('keeps every table showing the same rows', async ({ page }) => {
   const errors = await openExample(page)
 
diff --git a/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts b/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts
index c23f2d2a0a..666b2bfa46 100644
--- a/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts
+++ b/packages/table-core/src/features/column-pinning/columnPinningFeature.utils.ts
@@ -195,8 +195,9 @@ export function column_getPinnedIndex<
  * Reads the pinned region of this header's own leaf columns.
  *
  * A group column split across regions renders one header per region, so its
- * column reports a single position. The header only spans its own leaves:
- * returns their shared position, or `false` when they are unpinned or mixed.
+ * column reports a single position. Each header reads only the leaf columns
+ * it renders: returns their shared position, or `false` when they are
+ * unpinned or mixed.
  *
  * @example
  * ```ts
@@ -209,17 +210,25 @@ export function header_getIsPinned<
   TValue extends CellData = CellData,
 >(header: Header<TFeatures, TData, TValue>): ColumnPinningPosition {
   const leafHeaders = header.getLeafHeaders()
-  if (!leafHeaders.length) {
-    return false
-  }
+  let position: ColumnPinningPosition | undefined
+
+  for (let i = 0; i < leafHeaders.length; i++) {
+    const leafHeader = leafHeaders[i]!
+    // getLeafHeaders() also returns the group headers themselves, whose
+    // shared column would report every region its leaves are pinned to
+    if (leafHeader.subHeaders.length) {
+      continue
+    }
 
-  const position = column_getIsPinned(leafHeaders[0]!.column)
-  for (let i = 1; i < leafHeaders.length; i++) {
-    if (column_getIsPinned(leafHeaders[i]!.column) !== position) {
+    const leafPosition = column_getIsPinned(leafHeader.column)
+    if (position === undefined) {
+      position = leafPosition
+    } else if (leafPosition !== position) {
       return false
     }
   }
-  return position
+
+  return position ?? false
 }
 
 // Row APIs
diff --git a/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts b/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts
index de474f7ef5..a64184ff95 100644
--- a/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts
+++ b/packages/table-core/tests/unit/features/column-pinning/columnPinningFeature.utils.test.ts
@@ -326,10 +326,81 @@ describe('header_getIsPinned', () => {
     const table = makeSplitGroupTable()
     const groupHeader = table.getHeaderGroups()[0]!.headers[0]!
 
-    expect(groupHeader.getLeafHeaders()).toHaveLength(3)
+    expect(groupHeader.subHeaders).toHaveLength(3)
     expect(header_getIsPinned(groupHeader)).toBe(false)
   })
 
+  it('should report the region of a group split start/end with no center leaves', () => {
+    const columns: Array<ColumnDef<typeof features, Person, any>> = [
+      {
+        id: 'name',
+        columns: [
+          { accessorKey: 'firstName', id: 'firstName' },
+          { accessorKey: 'lastName', id: 'lastName' },
+        ],
+      },
+      { accessorKey: 'age', id: 'age' },
+    ]
+    const table = constructTable<typeof features, Person>({
+      features,
+      columns,
+      data: generateTestData(1),
+      initialState: {
+        columnPinning: {
+          start: ['firstName'],
+          end: ['lastName'],
+        },
+      },
+    })
+    const startGroup = table_getStartHeaderGroups(table)[0]!.headers[0]!
+    const endGroup = table_getEndHeaderGroups(table)[0]!.headers[0]!
+
+    expect(startGroup.column.id).toBe('name')
+    expect(endGroup.column.id).toBe('name')
+    expect(header_getIsPinned(startGroup)).toBe('start')
+    expect(header_getIsPinned(endGroup)).toBe('end')
+  })
+
+  it('should read only leaf columns through nested group headers', () => {
+    const columns: Array<ColumnDef<typeof features, Person, any>> = [
+      {
+        id: 'outer',
+        columns: [
+          {
+            id: 'inner',
+            columns: [
+              { accessorKey: 'firstName', id: 'firstName' },
+              { accessorKey: 'lastName', id: 'lastName' },
+            ],
+          },
+          { accessorKey: 'age', id: 'age' },
+        ],
+      },
+    ]
+    const table = constructTable<typeof features, Person>({
+      features,
+      columns,
+      data: generateTestData(1),
+      initialState: {
+        columnPinning: {
+          start: ['firstName'],
+          end: ['lastName', 'age'],
+        },
+      },
+    })
+    const endGroups = table_getEndHeaderGroups(table)
+    const endOuter = endGroups[0]!.headers[0]!
+    const endInner = endGroups[1]!.headers[0]!
+
+    expect(endOuter.column.id).toBe('outer')
+    expect(endInner.column.id).toBe('inner')
+    expect(header_getIsPinned(endOuter)).toBe('end')
+    expect(header_getIsPinned(endInner)).toBe('end')
+    expect(
+      header_getIsPinned(table_getStartHeaderGroups(table)[0]!.headers[0]!),
+    ).toBe('start')
+  })
+
   it('should match the column for leaf headers', () => {
     const table = makeSplitGroupTable()
     const leaf = (id: string) =>

From 024e30bb87a5b1507e7505da214bc445ea4007fb Mon Sep 17 00:00:00 2001
From: sundarshahi <shahithakurisundar@gmail.com>
Date: Fri, 30 Oct 2026 09:14:34 +0545
Subject: [PATCH 3/4] docs: read header pin state in the Alpine and Ember
 column pinning guides

Their pin-button snippets read header.column.getIsPinned(), which shows the
wrong buttons on a group header split across pinned regions.
---
 docs/framework/alpine/guide/column-pinning.md |  6 ++---
 docs/framework/ember/guide/column-pinning.md  | 26 ++++++++++++-------
 2 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/docs/framework/alpine/guide/column-pinning.md b/docs/framework/alpine/guide/column-pinning.md
index 1a3f849580..d780e55a05 100644
--- a/docs/framework/alpine/guide/column-pinning.md
+++ b/docs/framework/alpine/guide/column-pinning.md
@@ -215,19 +215,19 @@ Because Alpine does not initialize directives inside content set with `x-html`,
   <template x-if="!header.isPlaceholder && header.column.getCanPin()">
     <div class="pin-actions">
       <button
-        x-show="header.column.getIsPinned() !== 'start'"
+        x-show="header.getIsPinned() !== 'start'"
         @click="header.column.pin('start')"
       >
         &lt;=
       </button>
       <button
-        x-show="header.column.getIsPinned()"
+        x-show="header.getIsPinned()"
         @click="header.column.pin(false)"
       >
         X
       </button>
       <button
-        x-show="header.column.getIsPinned() !== 'end'"
+        x-show="header.getIsPinned() !== 'end'"
         @click="header.column.pin('end')"
       >
         =&gt;
diff --git a/docs/framework/ember/guide/column-pinning.md b/docs/framework/ember/guide/column-pinning.md
index 81436a25ea..7b0ae0fa6b 100644
--- a/docs/framework/ember/guide/column-pinning.md
+++ b/docs/framework/ember/guide/column-pinning.md
@@ -203,20 +203,26 @@ Use `table.getIsSomeColumnsPinned()` to check if any columns are pinned, or pass
 Because Ember templates extract method references without binding them, wrap these Column and Table method calls in small module-scope helper functions (or getters), then call the helpers from your markup:
 
 ```ts
-import { type Column, type ColumnPinningPosition } from '@tanstack/ember-table'
+import {
+  type Column,
+  type ColumnPinningPosition,
+  type Header,
+} from '@tanstack/ember-table'
 
 const getCanPin = (column: Column<typeof features, Person>): boolean =>
   column.getCanPin()
 
+// Read pin state from the header, so a group split across pinned regions
+// reports the region this header is rendered in
 const getIsPinned = (
-  column: Column<typeof features, Person>,
-): ColumnPinningPosition => column.getIsPinned()
+  header: Header<typeof features, Person>,
+): ColumnPinningPosition => header.getIsPinned()
 
-const isPinnedStart = (column: Column<typeof features, Person>): boolean =>
-  column.getIsPinned() === 'start'
+const isPinnedStart = (header: Header<typeof features, Person>): boolean =>
+  header.getIsPinned() === 'start'
 
-const isPinnedEnd = (column: Column<typeof features, Person>): boolean =>
-  column.getIsPinned() === 'end'
+const isPinnedEnd = (header: Header<typeof features, Person>): boolean =>
+  header.getIsPinned() === 'end'
 
 const pin = (
   column: Column<typeof features, Person>,
@@ -229,19 +235,19 @@ const pin = (
 ```hbs
 {{#if (getCanPin header.column)}}
   <div class='pin-actions'>
-    {{#unless (isPinnedStart header.column)}}
+    {{#unless (isPinnedStart header)}}
       <button
         class='pin-button'
         {{on 'click' (pin header.column 'start')}}
       >◀</button>
     {{/unless}}
-    {{#if (getIsPinned header.column)}}
+    {{#if (getIsPinned header)}}
       <button
         class='pin-button'
         {{on 'click' (pin header.column false)}}
       >✕</button>
     {{/if}}
-    {{#unless (isPinnedEnd header.column)}}
+    {{#unless (isPinnedEnd header)}}
       <button
         class='pin-button'
         {{on 'click' (pin header.column 'end')}}

From b8b7a8d76c49b978983ac20b62907893a67a4fb1 Mon Sep 17 00:00:00 2001
From: sundarshahi <shahithakurisundar@gmail.com>
Date: Fri, 30 Oct 2026 09:15:08 +0545
Subject: [PATCH 4/4] docs: format the Alpine column pinning guide

---
 docs/framework/alpine/guide/column-pinning.md | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/docs/framework/alpine/guide/column-pinning.md b/docs/framework/alpine/guide/column-pinning.md
index d780e55a05..633839eeb7 100644
--- a/docs/framework/alpine/guide/column-pinning.md
+++ b/docs/framework/alpine/guide/column-pinning.md
@@ -220,10 +220,7 @@ Because Alpine does not initialize directives inside content set with `x-html`,
       >
         &lt;=
       </button>
-      <button
-        x-show="header.getIsPinned()"
-        @click="header.column.pin(false)"
-      >
+      <button x-show="header.getIsPinned()" @click="header.column.pin(false)">
         X
       </button>
       <button