diff --git a/docs-app/src/templates/1-get-started/typescript-and-glint.gjs.md b/docs-app/src/templates/1-get-started/typescript-and-glint.gjs.md
index 667c4045..6cfc7897 100644
--- a/docs-app/src/templates/1-get-started/typescript-and-glint.gjs.md
+++ b/docs-app/src/templates/1-get-started/typescript-and-glint.gjs.md
@@ -71,6 +71,11 @@ class Demo {
 }
 ```
 
+### Column meta, table meta, and cell args
+
+These types are inferred too.
+To check them, or to declare them yourself, see [Typing meta and cells](/docs/get-started/typing-meta-and-cells).
+
 ## In Templates
 
 [Glint][docs-glint] can be a great choice to help ensure that your code is as bug-free as possible.
diff --git a/docs-app/src/templates/1-get-started/typing-meta-and-cells.gjs.md b/docs-app/src/templates/1-get-started/typing-meta-and-cells.gjs.md
new file mode 100644
index 00000000..f086ec36
--- /dev/null
+++ b/docs-app/src/templates/1-get-started/typing-meta-and-cells.gjs.md
@@ -0,0 +1,248 @@
+---
+title: Typing meta and cells
+---
+
+# Typing meta and cells
+
+`headlessTable` infers the types of a table from its config.
+Most tables need no type annotations.
+This page shows what is inferred, how to check it, and how to replace it with a type you declare.
+
+| What                | Where you read it      | Inferred from                     |
+| ------------------- | ---------------------- | --------------------------------- |
+| Row data            | `row.data`             | `data`                            |
+| Column meta         | `column.meta`          | the `meta` of each column         |
+| Table meta          | `table.config.meta`    | the `meta` of the config          |
+| Extra args of cells | `<column.Cell @... />` | the args of each `Cell` component |
+
+## Column meta
+
+A column's `meta` holds information that is not tied to a row, for example the alignment of the column.
+
+```ts
+class Report {
+  table = headlessTable(this, {
+    columns: () => [
+      { key: "name", meta: { align: "left" } },
+      { key: "age", meta: { align: "right", exportWidth: 12 } },
+      { key: "email" },
+    ],
+    data: () => this.people,
+  });
+}
+```
+
+The metas of all columns merge into one type:
+
+```ts
+table.columns[0].meta;
+// { align?: 'left' | 'right'; exportWidth?: 12 } | undefined
+```
+
+Values keep their literal types: `'left'`, not `string`, and `12`, not `number`.
+If no column has a `meta`, `column.meta` is `unknown`, and reading a key from it is a type error.
+
+### Check each column against a shape
+
+Use `satisfies` to check one column in place.
+The inferred type stays as it is.
+
+```ts
+interface Alignment {
+  align?: "left" | "right";
+}
+
+columns: () => [{ key: "name", meta: { align: "left" } satisfies Alignment }],
+```
+
+### Declare the type yourself
+
+Give the column list a type.
+The table then uses that type, and every column is checked against it.
+
+```ts
+import type { ColumnConfig } from "@universal-ember/table";
+
+class Report {
+  columns: ColumnConfig<Person, Alignment>[] = [
+    { key: "name", meta: { align: "left" } },
+    { key: "age", meta: { align: "right" } },
+  ];
+
+  table = headlessTable(this, {
+    columns: () => this.columns,
+    data: () => this.people,
+  });
+}
+
+// table.columns[0].meta: Alignment | undefined
+```
+
+## Table meta
+
+The config's `meta` is for information about the whole table.
+Its type is inferred, and the keys that the library itself uses (`TableMeta`) stay available.
+
+```ts
+table = headlessTable(this, {
+  columns: () => [
+    /* ... */
+  ],
+  data: () => this.people,
+  meta: {
+    currency: "EUR",
+    updateCell: (person: Person, key: string, value: unknown) => {
+      /* ... */
+    },
+  },
+});
+
+table.config.meta?.currency; // string | undefined
+table.config.meta?.totalRowCount; // number | undefined, from TableMeta
+```
+
+A function in `meta` needs types on its parameters, because TypeScript cannot infer them there.
+
+The table meta is also available in `value`, `options`, and `Cell`, through `column.table.config.meta`.
+
+## Extra args of cells
+
+A `Cell` component always gets `@row` and `@column`.
+It can take more args, which you pass where you render it:
+
+```gts
+import type { TOC } from "@ember/component/template-only";
+import type { CellContext } from "@universal-ember/table";
+
+const GroupedCell: TOC<{
+  Args: CellContext<Person> & { groupBy: "day" | "week" };
+}> = <template>{{@row.data.name}} by {{@groupBy}}</template>;
+
+class Report {
+  table = headlessTable(this, {
+    columns: () => [
+      { key: "name", Cell: GroupedCell },
+      { key: "age", Cell: AgeCell },
+    ],
+    data: () => this.people,
+  });
+}
+```
+
+```gts
+{{#each table.rows as |row|}}
+  {{#each table.columns as |column|}}
+    {{#if column.Cell}}
+      <column.Cell @row={{row}} @column={{column}} @groupBy={{this.groupBy}} />
+    {{/if}}
+  {{/each}}
+{{/each}}
+```
+
+The table collects the extra args of all its Cells.
+Glint then reports a missing `@groupBy`, or a value that is not `"day"` or `"week"`.
+If two Cells take different args, the table needs both of them.
+
+### Declare the args yourself
+
+Give the column list a type with the args as the fourth type argument.
+Use this when the Cells come from elsewhere, or when you want one place that names all args.
+
+```ts
+interface ReportCellArgs {
+  groupBy: "day" | "week";
+  onUpdate: (value: string) => void;
+}
+
+columns: ColumnConfig<Person, unknown, unknown, ReportCellArgs>[] = [
+  { key: "name", Cell: GroupedCell },
+  { key: "age", Cell: UpdateCell },
+];
+```
+
+The type arguments of `ColumnConfig` are, in order:
+
+1. the row data
+2. the column meta
+3. the table meta
+4. the extra args of cells
+
+Use `unknown` for the ones that you do not declare.
+
+## Writing a Cell component
+
+`CellContext` has the same order: row data, column meta, table meta.
+Ask for the parts that the Cell reads.
+
+```gts
+const AlignedCell: TOC<{
+  Args: CellContext<Person, Alignment, { currency: string }>;
+}> = <template>
+  <span class={{@column.meta.align}}>
+    {{@row.data.age}}
+    {{@column.table.config.meta.currency}}
+  </span>
+</template>;
+```
+
+TypeScript reports a column whose meta does not match `Alignment`, and a table whose meta has no `currency`.
+The table meta is also on `@row.table.config.meta`.
+
+Each column decides which Cell fits it.
+A Cell is checked against the `meta` of its own column, not against the meta of the other columns:
+
+```ts
+columns: () => [
+  { key: "name", meta: { align: "left" }, Cell: AlignedCell },
+  { key: "age", meta: { width: 80 }, Cell: WidthCell },
+  // error: this column has no `align`
+  { key: "email", Cell: AlignedCell },
+],
+```
+
+### Options
+
+A column's `options` returns what its Cell gets as `@options`:
+
+```gts
+const UnitCell: TOC<{
+  Args: CellContext<Person> & { options: { unit: string } };
+}> = <template>{{@row.data.age}} {{@options.unit}}</template>;
+
+columns: () => [
+  { key: "age", Cell: UnitCell, options: () => ({ unit: "years" }) },
+],
+```
+
+```gts
+<column.Cell
+  @row={{row}}
+  @column={{column}}
+  @options={{column.getOptionsForRow row}}
+/>
+```
+
+`column.getOptionsForRow` has the type of the `@options` that the Cells ask for, and the `defaultValue`.
+
+## Code that takes any table
+
+A function that accepts `Column<Person>` or `Table<Person>` accepts columns and tables with any meta and any cell args.
+The plugin helpers, for example `sort` and `isVisible`, are typed this way.
+
+To read a meta, ask for it:
+
+```ts
+function exportWidthOf(column: Column<Person, { exportWidth?: number }>) {
+  return column.meta?.exportWidth;
+}
+```
+
+## Limits
+
+- In `value` and `options`, `column.meta` is `unknown`, because TypeScript cannot give it the inferred type there.
+  Use the value from the column config itself.
+- An inline `<template>` Cell has no types for its args.
+  To use `@row` or other args in it, move it into a constant with a `TOC` type, as in the examples above.
+- A function inside a `meta` needs types on its parameters.
+- TypeScript does not check that a column's `options` returns the `@options` its Cell asks for.
+  The return type of `options` is only known after the Cell types are fixed.
diff --git a/table/src/-private/-type-tests/cell-args.test.ts b/table/src/-private/-type-tests/cell-args.test.ts
new file mode 100644
index 00000000..31e9c5c7
--- /dev/null
+++ b/table/src/-private/-type-tests/cell-args.test.ts
@@ -0,0 +1,239 @@
+import { expectTypeOf } from 'expect-type';
+
+import { headlessTable } from '../../index.ts';
+import {
+  ColumnReordering,
+  moveLeft,
+} from '../../plugins/column-reordering/index.ts';
+import {
+  ColumnVisibility,
+  hide,
+  isVisible,
+} from '../../plugins/column-visibility/index.ts';
+import { DataSorting, sort } from '../../plugins/data-sorting/index.ts';
+import { meta } from '../../plugins/index.ts';
+
+import type { CellContext, Column, ColumnConfig, Table } from '../../index.ts';
+import type { ComponentLike } from '@glint/template';
+
+interface Person {
+  name: string;
+  age: number;
+}
+declare const people: Person[];
+
+type GroupedCellArgs = CellContext<Person> & {
+  groupBy: 'day' | 'week';
+  onUpdate: (value: string) => void;
+};
+
+declare const GroupedCell: ComponentLike<GroupedCellArgs>;
+declare const GroupByCell: ComponentLike<
+  CellContext<Person> & { groupBy: 'day' | 'week' }
+>;
+declare const UpdateCell: ComponentLike<
+  CellContext<Person> & { onUpdate: (value: string) => void }
+>;
+declare const PlainCell: ComponentLike<CellContext<Person>>;
+
+type CellArgsOf<Cell> =
+  NonNullable<Cell> extends ComponentLike<infer Args> ? Args : never;
+
+/////////////////////////////////////////////
+// The args of the Cells are inferred, besides `@row` and `@column`
+const grouped = headlessTable(
+  {},
+  {
+    columns: () => [{ key: 'name', Cell: GroupedCell }],
+    data: () => people,
+  },
+);
+
+type GroupedArgs = CellArgsOf<(typeof grouped.columns)[0]['Cell']>;
+
+expectTypeOf<GroupedArgs['groupBy']>().toEqualTypeOf<'day' | 'week'>();
+expectTypeOf<GroupedArgs['onUpdate']>().toEqualTypeOf<
+  (value: string) => void
+>();
+expectTypeOf<GroupedArgs['row']>().toEqualTypeOf<(typeof grouped.rows)[0]>();
+
+/////////////////////////////////////////////
+// Cells that take fewer args fit next to it
+const mixed = headlessTable(
+  {},
+  {
+    columns: () => [
+      { key: 'name', Cell: PlainCell },
+      { key: 'age', Cell: GroupByCell },
+      { key: 'both', Cell: GroupedCell },
+    ],
+    data: () => people,
+  },
+);
+
+type MixedArgs = CellArgsOf<(typeof mixed.columns)[0]['Cell']>;
+
+expectTypeOf<MixedArgs['groupBy']>().toEqualTypeOf<'day' | 'week'>();
+expectTypeOf<MixedArgs['onUpdate']>().toEqualTypeOf<(value: string) => void>();
+
+/////////////////////////////////////////////
+// Cells whose extra args do not overlap add up
+const separate = headlessTable(
+  {},
+  {
+    columns: () => [
+      { key: 'name', Cell: GroupByCell },
+      { key: 'age', Cell: UpdateCell },
+    ],
+    data: () => people,
+  },
+);
+
+type SeparateArgs = CellArgsOf<(typeof separate.columns)[0]['Cell']>;
+
+expectTypeOf<SeparateArgs['groupBy']>().toEqualTypeOf<'day' | 'week'>();
+expectTypeOf<SeparateArgs['onUpdate']>().toEqualTypeOf<
+  (value: string) => void
+>();
+
+/////////////////////////////////////////////
+// A declared type replaces the inferred one
+
+interface ReportCellArgs {
+  groupBy: 'day' | 'week';
+  onUpdate: (value: string) => void;
+}
+
+const declared: ColumnConfig<Person, unknown, unknown, ReportCellArgs>[] = [
+  { key: 'name', Cell: GroupByCell },
+  { key: 'age', Cell: UpdateCell },
+  { key: 'plain', Cell: PlainCell },
+];
+
+const fromDeclared = headlessTable(
+  {},
+  {
+    columns: () => declared,
+    data: () => people,
+  },
+);
+
+type DeclaredArgs = CellArgsOf<(typeof fromDeclared.columns)[0]['Cell']>;
+
+expectTypeOf<DeclaredArgs['groupBy']>().toEqualTypeOf<'day' | 'week'>();
+expectTypeOf<DeclaredArgs['onUpdate']>().toEqualTypeOf<
+  (value: string) => void
+>();
+
+declare const NumberGroupCell: ComponentLike<
+  CellContext<Person> & { groupBy: number }
+>;
+
+const wrongArgs: ColumnConfig<Person, unknown, unknown, ReportCellArgs>[] = [
+  {
+    key: 'name',
+    // @ts-expect-error `groupBy` is not a number
+    Cell: NumberGroupCell,
+  },
+];
+
+/////////////////////////////////////////////
+// The row type of a Cell is still checked
+declare const OtherRowCell: ComponentLike<
+  CellContext<{ other: number }> & { groupBy: 'day' | 'week' }
+>;
+
+headlessTable(
+  {},
+  {
+    // @ts-expect-error the Cell is for other rows
+    columns: () => [{ key: 'name', Cell: OtherRowCell }],
+    data: () => people,
+  },
+);
+
+/////////////////////////////////////////////
+// Without Cells that take args, nothing changes
+const plain = headlessTable(
+  {},
+  {
+    columns: () => [{ key: 'name', Cell: PlainCell }, { key: 'age' }],
+    data: () => people,
+  },
+);
+
+expectTypeOf<CellArgsOf<(typeof plain.columns)[0]['Cell']>>().toEqualTypeOf<
+  CellContext<Person, unknown, unknown>
+>();
+
+/////////////////////////////////////////////
+// A column whose Cell takes args fits code that knows nothing about them
+function takesAnyColumn(column: Column<Person>) {
+  return column.key;
+}
+function takesAnyTable(table: Table<Person>) {
+  return table.columns.length;
+}
+takesAnyColumn(grouped.columns[0]!);
+takesAnyColumn(plain.columns[0]!);
+takesAnyTable(grouped);
+
+// The plugin helpers take it too
+const withPlugins = headlessTable(
+  {},
+  {
+    columns: () => [{ key: 'name', Cell: GroupedCell }],
+    data: () => people,
+    meta: { currency: 'EUR' },
+    plugins: [ColumnVisibility, DataSorting, ColumnReordering],
+  },
+);
+const groupedColumn = withPlugins.columns[0]!;
+
+expectTypeOf(isVisible(groupedColumn)).toEqualTypeOf<boolean>();
+hide(groupedColumn);
+sort(groupedColumn);
+moveLeft(groupedColumn);
+meta.forColumn(groupedColumn, ColumnVisibility);
+
+/////////////////////////////////////////////
+// The table of a row has the types of the table, like the table of a column
+expectTypeOf(
+  withPlugins.rows[0]!.table.config.meta!.currency,
+).toEqualTypeOf<string>();
+
+declare const CurrencyCell: ComponentLike<
+  CellContext<Person, unknown, { currency: string }>
+>;
+type CurrencyArgs = CellArgsOf<typeof CurrencyCell>;
+expectTypeOf<
+  NonNullable<CurrencyArgs['row']['table']['config']['meta']>['currency']
+>().toEqualTypeOf<string>();
+
+void wrongArgs;
+
+/////////////////////////////////////////////
+// `getOptionsForRow` has the `@options` that the Cells ask for
+interface Unit {
+  unit: string;
+}
+declare const UnitCell: ComponentLike<CellContext<Person> & { options: Unit }>;
+
+const withOptions = headlessTable(
+  {},
+  {
+    columns: () => [
+      { key: 'age', Cell: UnitCell, options: () => ({ unit: 'years' }) },
+      { key: 'name', Cell: PlainCell },
+    ],
+    data: () => people,
+  },
+);
+declare const optionsRow: (typeof withOptions.rows)[number];
+const options = withOptions.columns[0]!.getOptionsForRow(optionsRow);
+
+expectTypeOf(options.unit).toEqualTypeOf<string>();
+expectTypeOf(options.defaultValue).toEqualTypeOf<string>();
+expectTypeOf(plain.columns[0]!.getOptionsForRow(optionsRow)).toEqualTypeOf<{
+  defaultValue: string;
+}>();
diff --git a/table/src/-private/-type-tests/column-controls-cell.test.ts b/table/src/-private/-type-tests/column-controls-cell.test.ts
new file mode 100644
index 00000000..1082de78
--- /dev/null
+++ b/table/src/-private/-type-tests/column-controls-cell.test.ts
@@ -0,0 +1,75 @@
+import { headlessTable } from '../../index.ts';
+
+import type { CellContext, ColumnConfig } from '../../index.ts';
+import type { ComponentLike } from '@glint/template';
+
+interface Person {
+  name: string;
+  age: number;
+}
+declare const people: Person[];
+
+/////////////////////////////////////////////
+// Each column decides which Cell fits it, through its own meta.
+// A Cell is checked against the meta of its column, not of the table.
+interface Alignment {
+  align: 'left' | 'right';
+}
+interface Width {
+  width: number;
+}
+
+declare const AlignedCell: ComponentLike<CellContext<Person, Alignment>>;
+declare const WidthCell: ComponentLike<CellContext<Person, Width>>;
+
+headlessTable(
+  {},
+  {
+    columns: () => [
+      { key: 'name', meta: { align: 'left' }, Cell: AlignedCell },
+      { key: 'age', meta: { width: 80 }, Cell: WidthCell },
+    ],
+    data: () => people,
+  },
+);
+
+headlessTable(
+  {},
+  {
+    columns: () => [
+      {
+        key: 'name',
+        meta: { align: 'left' },
+        // @ts-expect-error this column's meta has no `width`
+        Cell: WidthCell,
+      },
+      { key: 'age', meta: { width: 80 }, Cell: WidthCell },
+    ],
+    data: () => people,
+  },
+);
+
+headlessTable(
+  {},
+  {
+    columns: () => [
+      {
+        key: 'name',
+        // @ts-expect-error a column without meta does not fit a Cell that reads one
+        Cell: AlignedCell,
+      },
+      { key: 'age', meta: { align: 'right' }, Cell: AlignedCell },
+    ],
+    data: () => people,
+  },
+);
+
+/////////////////////////////////////////////
+// A declared column type decides for every column in the list
+const aligned: ColumnConfig<Person, Alignment>[] = [
+  { key: 'name', meta: { align: 'left' }, Cell: AlignedCell },
+  // @ts-expect-error the list's meta has no `width`
+  { key: 'age', meta: { align: 'right' }, Cell: WidthCell },
+];
+
+void aligned;
diff --git a/table/src/-private/-type-tests/inferred-meta.test.ts b/table/src/-private/-type-tests/inferred-meta.test.ts
new file mode 100644
index 00000000..da34983e
--- /dev/null
+++ b/table/src/-private/-type-tests/inferred-meta.test.ts
@@ -0,0 +1,233 @@
+import { expectTypeOf } from 'expect-type';
+
+import { headlessTable } from '../../index.ts';
+import {
+  ColumnVisibility,
+  isVisible,
+} from '../../plugins/column-visibility/index.ts';
+import { DataSorting, sort } from '../../plugins/data-sorting/index.ts';
+import { columns, meta } from '../../plugins/index.ts';
+
+import type { CellContext, Column, ColumnConfig, Table } from '../../index.ts';
+import type { ComponentLike } from '@glint/template';
+
+interface Person {
+  name: string;
+  age: number;
+}
+declare const people: Person[];
+
+/////////////////////////////////////////////
+// Column meta and table meta are inferred from the config
+const report = headlessTable(
+  {},
+  {
+    columns: () => [
+      { key: 'name', meta: { align: 'left' } },
+      { key: 'age', meta: { align: 'right', exportWidth: 12 } },
+      { key: 'plain' },
+    ],
+    data: () => people,
+    meta: {
+      updateCell: (data: Person, key: string, value: unknown) => {
+        data[key as keyof Person] = value as never;
+      },
+    },
+    plugins: [ColumnVisibility, DataSorting],
+  },
+);
+
+// the row type is still inferred
+expectTypeOf(report.rows[0]!.data).toEqualTypeOf<Person>();
+
+// each column's meta merges into one type
+expectTypeOf(report.columns[0]!.meta).toEqualTypeOf<
+  { align?: 'left' | 'right'; exportWidth?: 12 } | undefined
+>();
+
+// the table meta keeps the keys of TableMeta
+expectTypeOf(report.config.meta!.updateCell)
+  .parameter(0)
+  .toEqualTypeOf<Person>();
+expectTypeOf(report.config.meta!.totalRowCount).toEqualTypeOf<
+  number | undefined
+>();
+expectTypeOf(report.columns[0]!.table.config.meta!.updateCell).toBeFunction();
+
+// helpers that return columns keep the type
+expectTypeOf(columns.for(report)[0]!.meta?.align).toEqualTypeOf<
+  'left' | 'right' | undefined
+>();
+expectTypeOf(columns.next(report.columns[0]!)!.meta?.align).toEqualTypeOf<
+  'left' | 'right' | undefined
+>();
+
+// plugin helpers take the typed table and column
+expectTypeOf(isVisible(report.columns[0]!)).toEqualTypeOf<boolean>();
+sort(report.columns[0]!);
+meta.forColumn(report.columns[0]!, ColumnVisibility);
+
+// code that knows nothing about meta accepts the table and its columns
+function takesAnyColumn(column: Column<Person>) {
+  return column.key;
+}
+function takesAnyTable(table: Table<Person>) {
+  return table.columns.length;
+}
+takesAnyColumn(report.columns[0]!);
+takesAnyTable(report);
+
+// shared code can ask for the meta it needs
+function exportWidthOf(column: Column<Person, { exportWidth?: number }>) {
+  return column.meta?.exportWidth;
+}
+exportWidthOf(report.columns[0]!);
+
+/////////////////////////////////////////////
+// Without meta, reading meta is an error
+const plain = headlessTable(
+  {},
+  {
+    columns: () => [{ key: 'name' }],
+    data: () => people,
+  },
+);
+
+expectTypeOf(plain.columns[0]!.meta).toEqualTypeOf<unknown>();
+// @ts-expect-error nothing sets a column meta
+expectTypeOf(plain.columns[0]!.meta?.align);
+
+/////////////////////////////////////////////
+// Callbacks do not stop the inference, and see the row and the table meta
+const withCallbacks = headlessTable(
+  {},
+  {
+    columns: () => [
+      {
+        key: 'age',
+        meta: { align: 'right' },
+        value: ({ column, row }) => {
+          expectTypeOf(row.data).toEqualTypeOf<Person>();
+          expectTypeOf(column.table.config.meta!.unit).toEqualTypeOf<string>();
+
+          return row.data.age;
+        },
+        options: ({ column }) => ({
+          unit: column.table.config.meta!.unit,
+        }),
+      },
+    ],
+    data: () => people,
+    meta: { unit: 'years' },
+  },
+);
+
+expectTypeOf(withCallbacks.columns[0]!.meta?.align).toEqualTypeOf<
+  'right' | undefined
+>();
+
+/////////////////////////////////////////////
+// A declared meta type checks every column, and is kept as it is
+interface ReportColumnMeta {
+  align?: 'left' | 'right';
+  exportWidth?: number;
+}
+
+const typedList: ColumnConfig<Person, ReportColumnMeta>[] = [
+  { key: 'name', meta: { align: 'left' } },
+];
+const fromList = headlessTable(
+  {},
+  {
+    columns: () => typedList,
+    data: () => people,
+  },
+);
+
+expectTypeOf(fromList.columns[0]!.meta).toEqualTypeOf<
+  ReportColumnMeta | undefined
+>();
+
+const badList: ColumnConfig<Person, ReportColumnMeta>[] = [
+  // @ts-expect-error not one of the declared alignments
+  { key: 'name', meta: { align: 'middle' } },
+];
+
+// `satisfies` checks a column in place, and the literal type is still inferred
+const checked = headlessTable(
+  {},
+  {
+    columns: () => [
+      { key: 'name', meta: { align: 'left' } satisfies ReportColumnMeta },
+    ],
+    data: () => people,
+  },
+);
+expectTypeOf(checked.columns[0]!.meta?.align).toEqualTypeOf<
+  'left' | undefined
+>();
+
+/////////////////////////////////////////////
+// Extra args for cells come through the table meta
+interface DateRangeMeta {
+  dateRange: [Date, Date];
+}
+
+declare const DateCell: ComponentLike<
+  CellContext<Person, unknown, DateRangeMeta>
+>;
+
+const ranged = headlessTable(
+  {},
+  {
+    columns: () => [{ key: 'name', Cell: DateCell }],
+    data: () => people,
+    meta: { dateRange: [new Date(), new Date()] as [Date, Date] },
+  },
+);
+
+expectTypeOf(ranged.columns[0]!.table.config.meta!.dateRange).toEqualTypeOf<
+  [Date, Date]
+>();
+
+// A Cell that reads column meta fits columns whose meta matches
+declare const AlignedCell: ComponentLike<
+  CellContext<Person, { align?: 'left' | 'right' }>
+>;
+
+headlessTable(
+  {},
+  {
+    columns: () => [
+      { key: 'name', meta: { align: 'left' }, Cell: AlignedCell },
+      { key: 'age', Cell: AlignedCell, meta: { align: 'right' } },
+    ],
+    data: () => people,
+  },
+);
+
+headlessTable(
+  {},
+  {
+    columns: () => [
+      {
+        key: 'name',
+        meta: { align: 'middle' },
+        // @ts-expect-error not one of the alignments the Cell handles
+        Cell: AlignedCell,
+      },
+    ],
+    data: () => people,
+  },
+);
+
+headlessTable(
+  {},
+  {
+    // @ts-expect-error this table's meta has no `dateRange`
+    columns: () => [{ key: 'name', Cell: DateCell }],
+    data: () => people,
+  },
+);
+
+void badList;
diff --git a/table/src/-private/column.ts b/table/src/-private/column.ts
index b28810c9..92c98843 100644
--- a/table/src/-private/column.ts
+++ b/table/src/-private/column.ts
@@ -5,6 +5,7 @@ import type { Row } from './row';
 import type { Table } from './table';
 import type { ComponentLike, ContentValue } from '@glint/template';
 import type { CellContext, ColumnConfig } from './interfaces';
+import type { CellOptionsOf } from './meta.ts';
 
 const DEFAULT_VALUE = '--';
 const DEFAULT_VALUE_KEY = 'defaultValue';
@@ -12,9 +13,25 @@ const DEFAULT_OPTIONS = {
   [DEFAULT_VALUE_KEY]: DEFAULT_VALUE,
 };
 
-export class Column<T = unknown> {
-  get Cell(): ComponentLike<CellContext<T>> | undefined {
-    return this.config.Cell;
+/**
+ * `ColumnMeta` is the type of `meta`, and `Meta` the type of `table.config.meta`.
+ * `CellArgs` are the args of `Cell` besides `@row` and `@column`.
+ *
+ * `config` and `Cell` do not carry the column meta,
+ * so that a column fits wherever a column with a wider meta is expected.
+ */
+export class Column<
+  T = unknown,
+  ColumnMeta = unknown,
+  Meta = unknown,
+  CellArgs = any,
+> {
+  get Cell():
+    | ComponentLike<CellContext<T, unknown, any> & CellArgs>
+    | undefined {
+    return this.config.Cell as
+      | ComponentLike<CellContext<T, unknown, any> & CellArgs>
+      | undefined;
   }
 
   get key(): string {
@@ -25,15 +42,19 @@ export class Column<T = unknown> {
     return this.config.name;
   }
 
+  get meta(): ColumnMeta | undefined {
+    return this.config.meta as ColumnMeta | undefined;
+  }
+
   constructor(
-    public table: Table<T>,
-    public config: ColumnConfig<T>,
+    public table: Table<T, ColumnMeta, Meta, CellArgs>,
+    public config: ColumnConfig<T, unknown, Meta>,
   ) {}
 
   @action
   getValueForRow(row: Row<T>): ContentValue {
     if (this.config.value) {
-      return this.config.value({ column: this, row });
+      return this.config.value(this.#contextFor(row));
     }
 
     // Cast here, because ember get's types do not support nested keys
@@ -55,10 +76,17 @@ export class Column<T = unknown> {
     return this.getOptionsForRow(row)[DEFAULT_VALUE_KEY];
   }
 
+  /**
+   * What to pass a Cell as `@options`:
+   * the default value, and what the column's `options` returns.
+   *
+   * The type also has the `@options` the table's Cells ask for.
+   * The column's `options` must return them: this is not checked.
+   */
   @action
-  getOptionsForRow(row: Row<T>): {
-    defaultValue: string;
-  } {
+  getOptionsForRow(
+    row: Row<T>,
+  ): { defaultValue: string } & CellOptionsOf<CellArgs> {
     const configuredDefault = this.table.config.defaultCellValue;
     const defaults = {
       [DEFAULT_VALUE_KEY]:
@@ -67,7 +95,12 @@ export class Column<T = unknown> {
 
     return {
       ...defaults,
-      ...this.config.options?.({ column: this, row }),
-    };
+      ...this.config.options?.(this.#contextFor(row)),
+    } as { defaultValue: string } & CellOptionsOf<CellArgs>;
+  }
+
+  #contextFor(row: Row<T>): CellContext<T, unknown, Meta> {
+    // The row is a row of this column's table, so its table has this table's types.
+    return { column: this, row } as CellContext<T, unknown, Meta>;
   }
 }
diff --git a/table/src/-private/interfaces/column.ts b/table/src/-private/interfaces/column.ts
index 7b893d0a..0fee553e 100644
--- a/table/src/-private/interfaces/column.ts
+++ b/table/src/-private/interfaces/column.ts
@@ -1,13 +1,25 @@
 import type { BasePlugin, Plugin } from '../../plugins';
 import type { Column } from '../column';
 import type { Row } from '../row';
+import type { Table } from '../table';
 import type { ColumnOptionsFor, SignatureFrom } from './plugins';
 import type { Constructor } from '../private-types';
 import type { ComponentLike, ContentValue } from '@glint/template';
 
-export interface CellContext<T> {
-  column: Column<T>;
-  row: Row<T>;
+declare const rowType: unique symbol;
+
+/**
+ * What `value`, `options`, and a `Cell` receive.
+ *
+ * `ColumnMeta` is the `meta` of the column,
+ * and `Meta` is the `meta` of the table config.
+ */
+export interface CellContext<T, out ColumnMeta = unknown, out Meta = unknown> {
+  column: Column<T, ColumnMeta, Meta, any>;
+  /**
+   * The row, whose `table` has the meta types of this table.
+   */
+  row: Row<T> & { table: Table<T, ColumnMeta, Meta, any> };
 }
 
 type ColumnPluginOption<P = Plugin> = P extends BasePlugin
@@ -21,7 +33,16 @@ export type CellOptions = {
   defaultValue?: string;
 } & Record<string, unknown>;
 
-export interface ColumnConfig<T = unknown> {
+/**
+ * `CellArgs` are the args a `Cell` takes besides `@row` and `@column`,
+ * passed where the cell is rendered.
+ */
+export interface ColumnConfig<
+  T = unknown,
+  ColumnMeta = unknown,
+  Meta = unknown,
+  CellArgs = unknown,
+> {
   /**
    * the `key` is required for preferences storage, as well as
    * managing uniqueness of the columns in an easy-to-understand way.
@@ -36,25 +57,41 @@ export interface ColumnConfig<T = unknown> {
 
   /**
    * Optionally provide a function to determine the value of a row at this column
+   *
+   * `column.meta` is `unknown` here, and in `options`.
+   * Typed with the column meta, it would be `any`:
+   * TypeScript takes the type from the plain column list in `HeadlessTableConfig`,
+   * where the column meta is `any`.
    */
-  value?: (context: CellContext<T>) => ContentValue;
+  value?: (context: CellContext<T, unknown, NoInfer<Meta>>) => ContentValue;
 
   /**
    * Recommended property to use for custom components for each cell per column.
    * Out-of-the-box, this property isn't used, but the provided type may be
    * a convenience for consumers of the headless table
    */
-  Cell?: ComponentLike<CellContext<T>>;
+  Cell?: ComponentLike<
+    CellContext<T, NoInfer<ColumnMeta>, NoInfer<Meta>> & CellArgs
+  >;
 
   /**
    * The name or title of the column, shown in the column heading / th
    */
   name?: string;
 
+  /**
+   * Information about the column that is not tied to a row,
+   * for example the alignment of its cells.
+   *
+   * Read it back as `column.meta`.
+   * Its type is inferred from what the columns config provides.
+   */
+  meta?: ColumnMeta;
+
   /**
    * Bag of extra properties to pass to Cell via `@options`, if desired
    */
-  options?: (context: CellContext<T>) => CellOptions;
+  options?: (context: CellContext<T, unknown, NoInfer<Meta>>) => CellOptions;
 
   /**
    * Each plugin may provide column options, and provides similar syntax to how
@@ -68,6 +105,14 @@ export interface ColumnConfig<T = unknown> {
    * ```
    */
   pluginOptions?: ColumnPluginOption[];
+
+  /**
+   * Type-only, never set.
+   *
+   * Without a direct mention of `T`, a list typed `ColumnConfig[]`
+   * gives `headlessTable` a row type that depends on the order TypeScript checks the program in.
+   */
+  readonly [rowType]?: T;
 }
 
 export type ColumnKey<T> = NonNullable<ColumnConfig<T>['key']>;
diff --git a/table/src/-private/interfaces/table.ts b/table/src/-private/interfaces/table.ts
index b22aa327..70f6b0da 100644
--- a/table/src/-private/interfaces/table.ts
+++ b/table/src/-private/interfaces/table.ts
@@ -1,5 +1,6 @@
 import type { Plugins } from '../../plugins/-private/utils';
 import type { ColumnConfig } from './column';
+import type { CellArgsOf } from '../meta.ts';
 import type { Pagination } from './pagination';
 import type { PreferencesAdapter } from './preferences';
 import type { Selection } from './selection';
@@ -9,13 +10,16 @@ export interface TableMeta {
   totalRowsSelectedCount?: number;
 }
 
-export interface TableConfig<DataType> {
+/**
+ * `Meta` is the type of this config's own `meta`.
+ */
+export interface TableConfig<DataType, Meta = unknown> {
   /**
    * Configuration describing how the table will crawl through `data`
    * and render it. Within this `columns` config, there will also be opportunities
    * to set the behavior of columns when rendered
    */
-  columns: () => ColumnConfig<DataType>[];
+  columns: () => ColumnConfig<DataType, unknown, Meta>[];
   /**
    * The data to render, as described via the `columns` option.
    *
@@ -87,7 +91,11 @@ export interface TableConfig<DataType> {
   onRowSelectionChange?: (selection: DataType | undefined) => void;
 
   // Uncategorized
-  meta?: TableMeta;
+  /**
+   * Information about the table, for plugins, columns, and cells.
+   * Its type is inferred, and read back as `table.config.meta`.
+   */
+  meta?: TableMeta & Meta;
   pagination?: Pagination;
 
   /**
@@ -137,3 +145,43 @@ export interface TableConfig<DataType> {
       }
     | (() => { key: string; adapter?: PreferencesAdapter });
 }
+
+/**
+ * The config that `headlessTable` takes.
+ *
+ * `ColumnMetas` holds the `meta` of each column, in order,
+ * so that each column's `meta` is inferred.
+ *
+ * `Columns` is the column list as written.
+ * The extra args of its Cells are read from it,
+ * and every Cell is checked against all of them.
+ *
+ * `TableConfig` stays a plain interface,
+ * for code that annotates a config or reads `table.config`.
+ *
+ * The plain list next to the mapped one lets TypeScript infer `DataType`
+ * from the columns too, which the mapped list alone does not.
+ * Its column meta is `any`, so that Cells that read a meta fit it.
+ * The mapped list checks each column's meta.
+ */
+export type HeadlessTableConfig<
+  DataType,
+  ColumnMetas extends unknown[] = unknown[],
+  Meta = unknown,
+  Columns extends readonly unknown[] = readonly unknown[],
+> = Omit<TableConfig<DataType, Meta>, 'columns'> & {
+  /**
+   * Configuration describing how the table will crawl through `data`
+   * and render it. Within this `columns` config, there will also be opportunities
+   * to set the behavior of columns when rendered
+   */
+  columns: () => {
+    [K in keyof ColumnMetas]: ColumnConfig<
+      DataType,
+      ColumnMetas[K],
+      Meta,
+      NoInfer<CellArgsOf<Columns>>
+    >;
+  } & Columns &
+    readonly ColumnConfig<DataType, any, Meta, any>[];
+};
diff --git a/table/src/-private/js-helper.ts b/table/src/-private/js-helper.ts
index de3fffc6..ac66473d 100644
--- a/table/src/-private/js-helper.ts
+++ b/table/src/-private/js-helper.ts
@@ -2,7 +2,8 @@ import { assert } from '@ember/debug';
 
 import { Table } from './table.ts';
 
-import type { TableConfig } from './interfaces';
+import type { HeadlessTableConfig, TableConfig } from './interfaces';
+import type { CellArgsOf, ColumnMetaOf } from './meta.ts';
 
 /**
  * Represents a UI-less version of a table
@@ -24,15 +25,21 @@ import type { TableConfig } from './interfaces';
  * ```
  *
  */
-export function headlessTable<T = unknown>(
+export function headlessTable<
+  T = unknown,
+  const ColumnMetas extends unknown[] = unknown[],
+  Meta = unknown,
+  Columns extends readonly unknown[] = readonly unknown[],
+>(
   parent: object,
-  options: TableConfig<T>,
-): Table<T> {
+  options: HeadlessTableConfig<T, ColumnMetas, Meta, Columns>,
+): Table<T, ColumnMetaOf<ColumnMetas>, Meta, CellArgsOf<Columns>> {
   assert(
     `headlessTable requires a parent object as the first argument, usually \`this\`. ` +
       `The single-argument form was removed, because the table is no longer a Resource.`,
     options,
   );
 
-  return new Table<T>(parent, options);
+  // The meta types only shape what the table returns, so they come from the return type.
+  return new Table(parent, options as TableConfig<T, Meta>);
 }
diff --git a/table/src/-private/meta.ts b/table/src/-private/meta.ts
new file mode 100644
index 00000000..0c43e160
--- /dev/null
+++ b/table/src/-private/meta.ts
@@ -0,0 +1,111 @@
+import type { TemplateOnlyComponent } from '@ember/component/template-only';
+import type {
+  Invoke,
+  UnwrapNamedArgs,
+} from '@glint/template/-private/integration';
+import type { ComponentSignatureArgs } from '@glint/template/-private/signature';
+
+/**
+ * The metas of columns that set one.
+ * A column without `meta` infers `unknown`, and would swallow the union.
+ */
+type ProvidedMetas<Metas extends unknown[]> = {
+  [K in keyof Metas]: unknown extends Metas[K] ? never : Metas[K];
+}[number];
+
+type KeysOf<U> = U extends unknown ? keyof U : never;
+
+type ValueAt<U, K extends PropertyKey> = U extends unknown
+  ? K extends keyof U
+    ? U[K]
+    : never
+  : never;
+
+/**
+ * The type of `column.meta`, from the `meta` of each column in a config.
+ *
+ * A list written in place is a tuple, and its metas merge into one object:
+ *
+ *   [{ meta: { align: 'left' } }, { meta: { align: 'right', width: 2 } }]
+ *   → { align?: 'left' | 'right'; width?: 2 }
+ *
+ * A list with a declared type keeps that type:
+ *
+ *   ColumnConfig<Person, ReportMeta>[] → ReportMeta
+ */
+export type ColumnMetaOf<Metas extends unknown[]> =
+  number extends Metas['length']
+    ? Metas[number]
+    : [ProvidedMetas<Metas>] extends [never]
+      ? unknown
+      : {
+          -readonly [K in KeysOf<ProvidedMetas<Metas>>]?: ValueAt<
+            ProvidedMetas<Metas>,
+            K
+          >;
+        };
+
+/**
+ * The Cells of columns that set one.
+ */
+type ProvidedCells<Columns extends readonly unknown[]> =
+  Columns[number] extends infer Column
+    ? Column extends { Cell?: infer Cell }
+      ? NonNullable<Cell>
+      : never
+    : never;
+
+/**
+ * The named args of a component:
+ *
+ * - a template-only component: from its signature
+ * - a class component: from the `[Invoke]` Glint gives it, else from `args`
+ * - a `ComponentLike`: from `[Invoke]`
+ */
+type NamedArgsOf<Cell> =
+  Cell extends TemplateOnlyComponent<infer Signature>
+    ? ComponentSignatureArgs<Signature>['Named']
+    : Cell extends abstract new (...args: any) => infer Instance
+      ? Instance extends { [Invoke]: (...args: infer Params) => any }
+        ? Params extends [...unknown[], infer Named]
+          ? UnwrapNamedArgs<Named>
+          : Params extends [(infer Named)?]
+            ? UnwrapNamedArgs<NonNullable<Named>>
+            : never
+        : Instance extends { args: infer Args }
+          ? Args
+          : never
+      : never;
+
+type ExtraArgsOf<Cell> = Cell extends unknown
+  ? Omit<NamedArgsOf<Cell>, 'row' | 'column'>
+  : never;
+
+type UnionToIntersection<U> = (
+  U extends unknown ? (union: U) => void : never
+) extends (intersection: infer I) => void
+  ? I
+  : never;
+
+/**
+ * The args of `column.Cell` besides `@row` and `@column`:
+ * every arg that any Cell of the config takes.
+ *
+ *   [{ Cell: GroupByCell }, { Cell: UpdateCell }]
+ *   → { groupBy: ... } & { onUpdate: ... }
+ */
+export type CellArgsOf<Columns extends readonly unknown[]> = [
+  ProvidedCells<Columns>,
+] extends [never]
+  ? unknown
+  : UnionToIntersection<ExtraArgsOf<ProvidedCells<Columns>>>;
+
+/**
+ * The `@options` the Cells of a table ask for, from their args.
+ * Without such a Cell, nothing is added to the default value.
+ */
+export type CellOptionsOf<CellArgs> = CellArgs extends {
+  options?: infer Options;
+}
+  ? Options
+  : unknown;
diff --git a/table/src/-private/table.ts b/table/src/-private/table.ts
index 8ae789e9..58e90eef 100644
--- a/table/src/-private/table.ts
+++ b/table/src/-private/table.ts
@@ -51,7 +51,12 @@ const attachContainer = (element: Element, table: Table) => {
  * Symbol-keyed fields live on this interface,
  * because `isolatedDeclarations` cannot emit computed class members.
  */
-export interface Table<DataType = unknown> {
+export interface Table<
+  DataType = unknown,
+  ColumnMeta = unknown,
+  Meta = unknown,
+  CellArgs = any,
+> {
   /**
    * @private
    */
@@ -70,8 +75,20 @@ export interface Table<DataType = unknown> {
   [ROW_META_KEY]: WeakMap<Row, Map<Class<unknown>, any>>;
 }
 
+/**
+ * `ColumnMeta` is the type of `column.meta`,
+ * and `Meta` the type of `table.config.meta`, apart from the keys of `TableMeta`.
+ * `CellArgs` are the args of `column.Cell` besides `@row` and `@column`.
+ *
+ * `headlessTable` infers all three from the config.
+ */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-export class Table<DataType = unknown> {
+export class Table<
+  DataType = unknown,
+  ColumnMeta = unknown,
+  Meta = unknown,
+  CellArgs = any,
+> {
   /**
    * @private
    *
@@ -95,9 +112,9 @@ export class Table<DataType = unknown> {
   scrollContainerElement?: HTMLElement;
 
   #parent: object;
-  #config: TableConfig<DataType>;
+  #config: TableConfig<DataType, Meta>;
 
-  constructor(parent: object, config: TableConfig<DataType>) {
+  constructor(parent: object, config: TableConfig<DataType, Meta>) {
     this.#parent = parent;
     this.#config = config;
     this[TABLE_KEY] = guidFor(this);
@@ -142,7 +159,7 @@ export class Table<DataType = unknown> {
    *
    * used by other private APIs
    */
-  get config(): TableConfig<DataType> {
+  get config(): TableConfig<DataType, Meta> {
     return this.#config;
   }
 
@@ -277,7 +294,10 @@ export class Table<DataType = unknown> {
     return result as unknown as Instance | undefined;
   }
 
-  rows: MappedArray<DataType[], Row<DataType>> = map(this, {
+  rows: MappedArray<
+    DataType[],
+    Row<DataType> & { table: Table<DataType, ColumnMeta, Meta, CellArgs> }
+  > = map(this, {
     data: () => {
       const dataFn = this.#config.data;
 
@@ -285,10 +305,17 @@ export class Table<DataType = unknown> {
 
       return dataFn() ?? [];
     },
-    map: (datum) => new Row(this, datum),
+    // A row's table is this table, so it has this table's types.
+    map: (datum) =>
+      new Row(this, datum) as Row<DataType> & {
+        table: Table<DataType, ColumnMeta, Meta, CellArgs>;
+      },
   });
 
-  columns: MappedArray<ColumnConfig<DataType>[], Column<DataType>> = map(this, {
+  columns: MappedArray<
+    ColumnConfig<DataType, unknown, Meta>[],
+    Column<DataType, ColumnMeta, Meta, CellArgs>
+  > = map(this, {
     data: () => {
       const configFn = this.#config.columns;
 
@@ -320,7 +347,7 @@ export class Table<DataType = unknown> {
       return result;
     },
     map: (config) => {
-      return new Column<DataType>(this, {
+      return new Column<DataType, ColumnMeta, Meta, CellArgs>(this, {
         ...DEFAULT_COLUMN_CONFIG,
         ...config,
       });
diff --git a/table/src/index.ts b/table/src/index.ts
index e4182017..af8b79bf 100644
--- a/table/src/index.ts
+++ b/table/src/index.ts
@@ -12,8 +12,10 @@ export { deserializeSorts, serializeSorts } from './utils.ts';
  *******************************/
 export type { Column } from './-private/column.ts';
 export type {
+  CellContext,
   ColumnConfig,
   ColumnKey,
+  HeadlessTableConfig,
   Pagination,
   PreferencesAdapter,
   TablePreferencesData as PreferencesData,
diff --git a/table/src/plugins/-private/base.ts b/table/src/plugins/-private/base.ts
index d0c66948..e0dec7ad 100644
--- a/table/src/plugins/-private/base.ts
+++ b/table/src/plugins/-private/base.ts
@@ -309,7 +309,25 @@ export const preferences = {
  * This works recursively up the plugin tree up until a plugin has no requirements, and then
  * all columns from the table are returned.
  */
-function columnsFor<DataType = any>(
+function columnsFor<
+  DataType = any,
+  ColumnMeta = unknown,
+  Meta = unknown,
+  CellArgs = unknown,
+>(
+  table: Table<DataType, ColumnMeta, Meta, CellArgs>,
+  requester?: Plugin<any>,
+): Column<DataType, ColumnMeta, Meta, CellArgs>[] {
+  // Plugins hold columns of this same table, so they have its meta.
+  return resolveColumns(table, requester) as Column<
+    DataType,
+    ColumnMeta,
+    Meta,
+    CellArgs
+  >[];
+}
+
+function resolveColumns<DataType = any>(
   table: Table<DataType>,
   requester?: Plugin<any>,
 ): Column<DataType>[] {
@@ -432,10 +450,15 @@ export const columns = {
    * If a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  next: <Data = unknown>(
-    current: Column<Data>,
+  next: <
+    Data = unknown,
+    ColumnMeta = unknown,
+    Meta = unknown,
+    CellArgs = unknown,
+  >(
+    current: Column<Data, ColumnMeta, Meta, CellArgs>,
     requester?: Plugin<any>,
-  ): Column<Data> | undefined => {
+  ): Column<Data, ColumnMeta, Meta, CellArgs> | undefined => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
@@ -464,10 +487,15 @@ export const columns = {
    * If a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  previous: <Data = unknown>(
-    current: Column<Data>,
+  previous: <
+    Data = unknown,
+    ColumnMeta = unknown,
+    Meta = unknown,
+    CellArgs = unknown,
+  >(
+    current: Column<Data, ColumnMeta, Meta, CellArgs>,
     requester?: Plugin<any>,
-  ): Column<Data> | undefined => {
+  ): Column<Data, ColumnMeta, Meta, CellArgs> | undefined => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
@@ -494,10 +522,15 @@ export const columns = {
    * if a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  before: <Data = unknown>(
-    current: Column<Data>,
+  before: <
+    Data = unknown,
+    ColumnMeta = unknown,
+    Meta = unknown,
+    CellArgs = unknown,
+  >(
+    current: Column<Data, ColumnMeta, Meta, CellArgs>,
     requester?: Plugin<any>,
-  ): Column<Data>[] => {
+  ): Column<Data, ColumnMeta, Meta, CellArgs>[] => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
@@ -513,10 +546,15 @@ export const columns = {
    * if a plugin class is provided, the hierarchy of column list modifications
    * will be respected.
    */
-  after: <Data = unknown>(
-    current: Column<Data>,
+  after: <
+    Data = unknown,
+    ColumnMeta = unknown,
+    Meta = unknown,
+    CellArgs = unknown,
+  >(
+    current: Column<Data, ColumnMeta, Meta, CellArgs>,
     requester?: Plugin<any>,
-  ): Column<Data>[] => {
+  ): Column<Data, ColumnMeta, Meta, CellArgs>[] => {
     const columns = requester
       ? columnsFor(current.table, requester)
       : columnsFor(current.table);
diff --git a/table/src/plugins/column-reordering/helpers.ts b/table/src/plugins/column-reordering/helpers.ts
index cfc5d1b9..da9d675c 100644
--- a/table/src/plugins/column-reordering/helpers.ts
+++ b/table/src/plugins/column-reordering/helpers.ts
@@ -88,9 +88,14 @@ export const canMoveRight = <DataType = unknown>(
  * // Use the ordered columns for rendering or other operations
  * ```
  */
-export const orderedColumnsFor = <DataType = unknown>(
-  table: Table<DataType>,
-): Column<DataType>[] => {
+export const orderedColumnsFor = <
+  DataType = unknown,
+  ColumnMeta = unknown,
+  Meta = unknown,
+  CellArgs = unknown,
+>(
+  table: Table<DataType, ColumnMeta, Meta, CellArgs>,
+): Column<DataType, ColumnMeta, Meta, CellArgs>[] => {
   // Note: The meta.forTable API doesn't preserve the DataType generic from the table parameter.
   // This is a limitation of the current plugin meta system architecture.
   // We use a type assertion here because we know the columns come from the same table.
@@ -98,5 +103,10 @@ export const orderedColumnsFor = <DataType = unknown>(
     table,
     ColumnReordering,
   ) as TableMeta<DataType>;
-  return tableMeta.columnOrder.orderedColumns;
+  return tableMeta.columnOrder.orderedColumns as Column<
+    DataType,
+    ColumnMeta,
+    Meta,
+    CellArgs
+  >[];
 };
diff --git a/test-app/tests/integration/cells-test.gts b/test-app/tests/integration/cells-test.gts
new file mode 100644
index 00000000..332683ad
--- /dev/null
+++ b/test-app/tests/integration/cells-test.gts
@@ -0,0 +1,135 @@
+import { setOwner } from "@ember/owner";
+import { render } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import { setupRenderingTest } from "ember-qunit";
+
+import { headlessTable } from "@universal-ember/table";
+
+import type { TOC } from "@ember/component/template-only";
+import type { CellContext } from "@universal-ember/table";
+
+interface Person {
+  name: string;
+  age: number;
+}
+
+const people: Person[] = [
+  { name: "Ada", age: 36 },
+  { name: "Grace", age: 45 },
+];
+
+const GroupedCell: TOC<{
+  Args: CellContext<Person> & { groupBy: "day" | "week" };
+}> = <template>
+  <span class="grouped">{{@row.data.name}} by {{@groupBy}}</span>
+</template>;
+
+const AgeCell: TOC<{ Args: CellContext<Person> }> = <template>
+  <span class="age">{{@row.data.age}}</span>
+</template>;
+
+const UnitCell: TOC<{
+  Args: CellContext<Person> & { options: { unit: string } };
+}> = <template>
+  <span class="unit">{{@row.data.age}} {{@options.unit}}</span>
+</template>;
+
+class OptionsContext {
+  table = headlessTable(this, {
+    columns: () => [
+      { key: "age", Cell: UnitCell, options: () => ({ unit: "years" }) },
+    ],
+    data: () => people,
+  });
+}
+
+class Context {
+  table = headlessTable(this, {
+    columns: () => [
+      { key: "name", Cell: GroupedCell },
+      { key: "age", Cell: AgeCell },
+      {
+        key: "inline",
+        Cell: <template>
+          <span class="inline">inline</span>
+        </template>,
+      },
+    ],
+    data: () => people,
+  });
+}
+
+module("Cells", function (hooks) {
+  setupRenderingTest(hooks);
+
+  test("each Cell is rendered with the args of the table", async function (assert) {
+    const ctx = new Context();
+
+    setOwner(ctx, this.owner);
+
+    const table = ctx.table;
+
+    await render(
+      <template>
+        {{#each table.rows as |row|}}
+          {{#each table.columns as |column|}}
+            {{#if column.Cell}}
+              <column.Cell @row={{row}} @column={{column}} @groupBy="week" />
+            {{/if}}
+          {{/each}}
+        {{/each}}
+      </template>,
+    );
+
+    assert.dom(".grouped").exists({ count: 2 });
+    assert.dom(".grouped").hasText("Ada by week");
+    assert.dom(".age").exists({ count: 2 });
+    assert.dom(".inline").exists({ count: 2 });
+  });
+
+  test("a Cell gets the options of its column", async function (assert) {
+    const ctx = new OptionsContext();
+
+    setOwner(ctx, this.owner);
+
+    const table = ctx.table;
+
+    await render(
+      <template>
+        {{#each table.rows as |row|}}
+          {{#each table.columns as |column|}}
+            {{#if column.Cell}}
+              <column.Cell
+                @row={{row}}
+                @column={{column}}
+                @options={{column.getOptionsForRow row}}
+              />
+            {{/if}}
+          {{/each}}
+        {{/each}}
+      </template>,
+    );
+
+    assert.dom(".unit").exists({ count: 2 });
+    assert.dom(".unit").hasText("36 years");
+  });
+});
+
+/**
+ * Never rendered: these templates only exist for the type checks.
+ */
+const TypeChecks: TOC<{ Args: { table: Context["table"] } }> = <template>
+  {{#each @table.rows as |row|}}
+    {{#each @table.columns as |column|}}
+      {{#if column.Cell}}
+        {{! @glint-expect-error the table's Cells need @groupBy }}
+        <column.Cell @row={{row}} @column={{column}} />
+
+        {{! @glint-expect-error not one of the groupings }}
+        <column.Cell @row={{row}} @column={{column}} @groupBy="year" />
+      {{/if}}
+    {{/each}}
+  {{/each}}
+</template>;
+
+void TypeChecks;