@orkestrel/table 0.0.3 → 0.0.5

package/dist/src/core/index.d.cts

@@ -1,20 +1,21 @@
-import { Emitter } from '@orkestrel/emitter';
-import { EmitterErrorHandler } from '@orkestrel/emitter';
-import { EmitterHooks } from '@orkestrel/emitter';
-import { EmitterInterface } from '@orkestrel/emitter';
-import { JSONRecord } from '@orkestrel/contract';
+import type { EmitterErrorHandler } from '@orkestrel/emitter';
+import type { EmitterHooks } from '@orkestrel/emitter';
+import type { EmitterInterface } from '@orkestrel/emitter';
+import type { JSONRecord } from '@orkestrel/contract';
 
 /**
- * Check whether one column admits a filter and all its operands.
+ * Checks whether one column admits a filter and every operand it carries — the gate `filter.set`
+ * and {@link matchesFilter} share.
  *
  * @param column - The column that fixes the accepted operators and cell shapes.
  * @param filter - The filter to inspect.
- * @returns Whether the filter belongs to the column and the column can apply it.
+ * @returns True if the filter belongs to the column and the column can apply it; false otherwise.
  */
 export declare function admitsFilter(column: TableColumn, filter: TableFilter): boolean;
 
 /**
- * Audit a structurally valid schema for domain and budget faults.
+ * Audits a structurally valid schema for domain faults and budget breaches, returning human
+ * diagnostics.
  *
  * @param schema - The table schema to audit.
  * @returns Frozen human-readable diagnostics, or an empty list when the schema is sound.
@@ -22,11 +23,12 @@ export declare function admitsFilter(column: TableColumn, filter: TableFilter):
 export declare function auditTable(schema: TableSchema): readonly string[];
 
 /**
- * Keep the rows whose cell falls between these bounds, both included.
+ * Keeps the rows whose cell falls between `minimum` and `maximum`, both included, compared the
+ * way the column compares.
  *
  * @remarks
- * The bounds compare the way the column compares, so a `text` column holding ISO strings takes a
- * pair of ISO strings and reads as a date range.
+ * A `text` column holding ISO strings therefore takes a pair of ISO strings and reads as a date
+ * range.
  */
 export declare interface BetweenFilter {
     readonly column: string;
@@ -36,13 +38,13 @@ export declare interface BetweenFilter {
 }
 
 /**
- * Compare two cells of one column.
+ * Compares two cells of one column, replacing what its `cell` fixes. Always describes ascending
+ * order; direction is applied afterwards.
  *
  * @remarks
- * It replaces the comparison the column's {@link ColumnCell} fixes, for that column alone, and it
- * receives `undefined` for a row carrying no cell there. Sorting reads the result the way
- * `Array.prototype.sort` does and applies {@link TableDirection} afterwards, so a comparator
- * always describes ascending order.
+ * The replacement covers that column alone, and it receives `undefined` for a row carrying no
+ * cell there. Sorting reads the result the way `Array.prototype.sort` does and applies
+ * {@link TableDirection} to it.
  *
  * @param left - The first row's cell, or `undefined` when it carries none.
  * @param right - The second row's cell, or `undefined` when it carries none.
@@ -56,15 +58,16 @@ export declare interface BetweenFilter {
 export declare type CellComparator = (left: TableCell | undefined, right: TableCell | undefined) => number;
 
 /**
- * Test one column's cell against a filter.
+ * Tests one column's cell against a filter, replacing what its `cell` fixes. Receives every
+ * filter the table holds against that column.
  *
  * @remarks
- * It replaces the test the column's {@link ColumnCell} fixes, for that column alone, and it
- * receives every filter the table holds against that column.
+ * The replacement covers that column alone, and it receives `undefined` for a row carrying no
+ * cell there.
  *
  * @param cell - The row's cell, or `undefined` when it carries none.
  * @param filter - The filter the table is applying.
- * @returns `true` to keep the row.
+ * @returns True if the filter accepts the cell; false otherwise.
  * @example
  * ```ts
  * const loose: CellMatcher = (cell, filter) =>
@@ -73,11 +76,12 @@ export declare type CellComparator = (left: TableCell | undefined, right: TableC
  */
 export declare type CellMatcher = (cell: TableCell | undefined, filter: TableFilter) => boolean;
 
-/** The maximum number of choices one `choice` column may offer. */
+/** Names the maximum number of choices one `choice` column may offer: 1024. */
 export declare const CHOICE_LIMIT = 1024;
 
 /**
- * A column drawn from a declared list, compared by the order that list declares.
+ * Represents a column drawn from a declared list, compared by the order that list declares. It
+ * requires `choices`.
  *
  * @remarks
  * A cell holding a value the list does not offer is refused at admission.
@@ -88,7 +92,7 @@ export declare interface ChoiceColumn extends ColumnBase {
 }
 
 /**
- * Clone one row into an owned frozen snapshot.
+ * Clones one row into an owned frozen snapshot.
  *
  * @param row - The row to own.
  * @returns A frozen copy of the row's cells.
@@ -96,21 +100,23 @@ export declare interface ChoiceColumn extends ColumnBase {
 export declare function cloneRow(row: TableRow): TableRow;
 
 /**
- * Clone a table schema into an owned frozen snapshot.
+ * Clones a whole schema into an owned frozen snapshot, freezing every nested column, choice list,
+ * choice, and `meta`; raises `SCHEMA` for a `meta` it cannot own.
  *
  * @param schema - The schema to own.
  * @returns A frozen schema with every nested column, choice, list, and metadata record owned.
  */
 export declare function cloneSchema(schema: TableSchema): TableSchema;
 
-/** Every column cell, in the order declared by the public contract. */
+/** Lists every column cell, in the order declared by the public contract. */
 export declare const COLUMN_CELLS: readonly ColumnCell[];
 
-/** The maximum number of columns one schema may declare. */
+/** Names the maximum number of columns one schema may declare: 256. */
 export declare const COLUMN_LIMIT = 256;
 
 /**
- * What every column carries, whatever its cells hold.
+ * Describes what every column carries, whatever its cells hold — the name a row's cell uses, the
+ * text a reader sees, whether a host draws the column, and the metadata a host attaches to it.
  *
  * @remarks
  * `key` names the column, and it is the name a row uses for that column's cell. `label` is the
@@ -135,11 +141,12 @@ export declare interface ColumnBase {
 }
 
 /**
- * What a column's cells hold.
+ * Names what a column's cells hold — the discriminant that fixes the column's options, its
+ * comparison, and the filters that apply to it.
  *
  * @remarks
- * The cell is the discriminant of every {@link TableColumn} variant, so choosing it fixes what the
- * cells hold, how the column compares, and which filter operators apply to it.
+ * Every {@link TableColumn} variant is discriminated by it, so narrowing on the member reaches
+ * that variant's own options.
  *
  * A date, a time, and a timestamp are `text` holding a canonically spelled ISO string. Lexical
  * order is chronological only when a column uses one offset, one precision, and normalized
@@ -153,10 +160,10 @@ export declare interface ColumnBase {
 export declare type ColumnCell = 'text' | 'number' | 'flag' | 'choice';
 
 /**
- * One value a `choice` column offers.
+ * Represents one value a `choice` column offers — `value` is stored, `label` is read, and `help`
+ * explains.
  *
  * @remarks
- * `value` is what the cell holds and `label` is what a reader sees. `help` explains the choice.
  * The order a column declares its choices in is the order that column sorts by, which is what
  * lets a status column sort draft before live before archived rather than alphabetically.
  */
@@ -167,7 +174,7 @@ export declare interface ColumnChoice {
 }
 
 /**
- * Compare two cells in ascending order according to one column.
+ * Compares two of one column's cells the way its `cell` fixes, describing ascending order.
  *
  * @param column - The column that fixes the comparison.
  * @param left - The first cell, or absence.
@@ -177,7 +184,8 @@ export declare interface ColumnChoice {
 export declare function compareCells(column: TableColumn, left: TableCell | undefined, right: TableCell | undefined): number;
 
 /**
- * Compute one atomic 0/1/N membership change over known keys.
+ * Computes one atomic 0/1/N membership change over the keys a caller may address — the engine
+ * selection and expansion share.
  *
  * @param known - Every key the caller may change.
  * @param current - The current key set.
@@ -188,7 +196,7 @@ export declare function compareCells(column: TableColumn, left: TableCell | unde
  */
 export declare function computeKeys(known: readonly TableKey[], current: ReadonlySet<TableKey>, input: TableKey | readonly TableKey[] | undefined, include: (included: boolean) => boolean): ReadonlySet<TableKey> | undefined;
 
-/** Keep the rows whose cell holds this text somewhere inside it. */
+/** Keeps the rows whose cell holds this `text` somewhere inside it. */
 export declare interface ContainsFilter {
     readonly column: string;
     readonly operator: 'contains';
@@ -196,63 +204,56 @@ export declare interface ContainsFilter {
 }
 
 /**
- * Open a table against a schema.
+ * Opens a table against a schema. The schema is copied, and the copy is what the table declares.
  *
  * @param schema - The table declaration to own.
  * @param options - Initial rows, lens overrides, pagination, and emitter wiring.
  * @returns A live table interface.
  * @throws A {@link TableError} coded `SCHEMA` when the schema is unusable, `KEY` when a seeded
  *   identity is unusable or repeated, and `CELL` when a seeded cell is invalid.
- * @example
+ * @example Open a table
  * ```ts
- * const table = createTable({ key: 'id', columns: [{ cell: 'text', key: 'id' }] })
- * table.rows.add({ id: '1' })
+ * import { createTable } from '@orkestrel/table'
+ *
+ * const table = createTable(
+ * 	{
+ * 		label: 'People',
+ * 		key: 'id',
+ * 		columns: [
+ * 			{ cell: 'text', key: 'id', label: 'Reference' },
+ * 			{ cell: 'text', key: 'name', label: 'Name' },
+ * 			{ cell: 'number', key: 'age', label: 'Age' },
+ * 		],
+ * 	},
+ * 	{
+ * 		rows: [
+ * 			{ id: '1', name: 'Ada', age: 36 },
+ * 			{ id: '2', name: 'Grace', age: 45 },
+ * 			{ id: '3', name: 'Alan', age: 41 },
+ * 		],
+ * 		limit: 2,
+ * 	},
+ * )
+ *
+ * table.filter.set({ column: 'name', operator: 'contains', text: 'a' })
+ * table.sort.set({ column: 'age', direction: 'descending' })
+ *
+ * table.count // 3 — every name holds a lowercase 'a'
+ * table.pagination.count // 2 — two pages of two
+ * table.view.map((row) => row.name) // ['Grace', 'Alan'] — page one, oldest first
  * ```
  */
 export declare function createTable(schema: TableSchema, options?: TableOptions): TableInterface;
 
-/** Keep the rows whose cell holds exactly this value. */
+/** Keeps the rows whose cell holds exactly this `value`. */
 export declare interface EqualsFilter {
     readonly column: string;
     readonly operator: 'equals';
     readonly value: TableCell;
 }
 
-/** The keys of the rows somebody has opened. */
-export declare class ExpansionManager implements ExpansionManagerInterface {
-    #private;
-    /**
-     * Create an expansion manager over one table's private stores.
-     *
-     * @param emitter - The table's event emitter.
-     * @param gate - The table lifecycle gate.
-     * @param rows - A read of every row key.
-     * @param read - A read of the expanded keys.
-     * @param write - The expanded-key commit boundary.
-     */
-    constructor(emitter: Emitter<TableEventMap>, gate: () => void, rows: () => readonly TableKey[], read: () => ReadonlySet<TableKey>, write: (keys: ReadonlySet<TableKey>) => void);
-    /** The keys of the rows opened right now. */
-    get keys(): ReadonlySet<TableKey>;
-    /** Open every row the table holds. */
-    expand(): void;
-    /** Open one row. */
-    expand(key: TableKey): boolean;
-    /** Open several rows. */
-    expand(keys: readonly TableKey[]): boolean;
-    /** Close every row. */
-    clear(): void;
-    /** Close one row. */
-    clear(key: TableKey): boolean;
-    /** Close several rows. */
-    clear(keys: readonly TableKey[]): boolean;
-    /** Open one row or close it when already open. */
-    toggle(key: TableKey): boolean;
-    /** Turn several rows around independently. */
-    toggle(keys: readonly TableKey[]): boolean;
-}
-
 /**
- * The rows somebody has opened up.
+ * Manages the rows somebody has opened up.
  *
  * @remarks
  * Expansion holds keys exactly as selection does, and what an opened row shows beside it is the
@@ -265,61 +266,65 @@ export declare class ExpansionManager implements ExpansionManagerInterface {
  * ```
  */
 export declare interface ExpansionManagerInterface {
-    /** The keys of the rows opened right now. */
+    /** Holds the keys of the rows opened right now. */
     readonly keys: ReadonlySet<TableKey>;
-    /** Open every row the table holds. */
+    /** Opens every row the table holds, one row, or several. */
     expand(): void;
     /**
-     * Open one row.
+     * Opens one row.
      *
      * @param key - The row's key.
-     * @returns `true` when the key named a row the table holds.
+     * @returns True if the key named a row the table holds; false otherwise.
      */
     expand(key: TableKey): boolean;
     /**
-     * Open several rows.
+     * Opens several rows.
      *
      * @param keys - The rows' keys.
-     * @returns `true` when every key named a row the table holds. Every key is checked before any
-     *   row opens.
+     * @returns True if every key named a row the table holds; false otherwise. Every key is
+     *   checked before any row opens.
      */
     expand(keys: readonly TableKey[]): boolean;
-    /** Close every row. */
+    /**
+     * Closes every row, one row, or several. A known key that was not open still answers `true`.
+     */
     clear(): void;
     /**
-     * Close one row.
+     * Closes one row.
      *
      * @param key - The row's key.
-     * @returns `true` when the key named a row the table holds, whether or not it was open.
+     * @returns True if the key named a row the table holds, whether or not it was
+     *   open; false otherwise.
      */
     clear(key: TableKey): boolean;
     /**
-     * Close several rows.
+     * Closes several rows.
      *
      * @param keys - The rows' keys.
-     * @returns `true` when every key named a row the table holds. Every key is checked before any
-     *   row closes.
+     * @returns True if every key named a row the table holds; false otherwise. Every key is
+     *   checked before any row closes.
      */
     clear(keys: readonly TableKey[]): boolean;
     /**
-     * Open one row, or close it when it is already open.
+     * Opens one row, or closes it when it is already open; over a list, turns each row around on
+     * its own.
      *
      * @param key - The row's key.
-     * @returns `true` when the key named a row the table holds.
+     * @returns True if the key named a row the table holds; false otherwise.
      */
     toggle(key: TableKey): boolean;
     /**
-     * Turn several rows around, each on its own.
+     * Turns several rows around, each on its own.
      *
      * @param keys - The rows' keys.
-     * @returns `true` when every key named a row the table holds. Every key is checked before any
-     *   row turns.
+     * @returns True if every key named a row the table holds; false otherwise. Every key is
+     *   checked before any row turns.
      */
     toggle(keys: readonly TableKey[]): boolean;
 }
 
 /**
- * Find one column by key.
+ * Finds one column by key; `undefined` when the schema declares no such column.
  *
  * @param schema - The schema whose columns to search.
  * @param key - The column key to find.
@@ -328,7 +333,8 @@ export declare interface ExpansionManagerInterface {
 export declare function extractColumn(schema: TableSchema, key: string): TableColumn | undefined;
 
 /**
- * Read one row's declared identity.
+ * Reads one row's declared identity; `undefined` when its key cell is missing, empty, or not a
+ * string.
  *
  * @param schema - The schema that names the identity column.
  * @param row - The row whose identity to read.
@@ -336,38 +342,8 @@ export declare function extractColumn(schema: TableSchema, key: string): TableCo
  */
 export declare function extractKey(schema: TableSchema, row: TableRow): TableKey | undefined;
 
-/** The filters one table applies with and-only composition. */
-export declare class FilterManager implements FilterManagerInterface {
-    #private;
-    /**
-     * Create a filter manager over one table's private filter store.
-     *
-     * @param schema - The table schema.
-     * @param emitter - The table's event emitter.
-     * @param gate - The table lifecycle gate.
-     * @param read - A read of the current filters.
-     * @param write - The filter commit boundary.
-     * @param clamp - The pagination clamp commit after a filter commit.
-     */
-    constructor(schema: TableSchema, emitter: Emitter<TableEventMap>, gate: () => void, read: () => readonly TableFilter[], write: (filters: readonly TableFilter[]) => void, clamp: () => number | undefined);
-    /** Find one column's filter. */
-    filter(column: string): TableFilter | undefined;
-    /** Read every filter as an owned frozen snapshot. */
-    filters(): readonly TableFilter[];
-    /** Filter several columns. */
-    set(filters: readonly TableFilter[]): void;
-    /** Filter one column. */
-    set(filter: TableFilter): void;
-    /** Stop filtering by every column. */
-    remove(): void;
-    /** Stop filtering by one column. */
-    remove(column: string): boolean;
-    /** Stop filtering by several columns. */
-    remove(columns: readonly string[]): boolean;
-}
-
 /**
- * Which rows a table keeps.
+ * Manages which rows a table keeps.
  *
  * @remarks
  * The table holds at most one filter per column and keeps the rows every filter accepts.
@@ -380,20 +356,22 @@ export declare class FilterManager implements FilterManagerInterface {
  */
 export declare interface FilterManagerInterface {
     /**
-     * Find one column's filter.
+     * Finds one column's filter; `undefined` when nothing filters that column.
      *
      * @param column - The column's key.
      * @returns The filter, or `undefined` when nothing filters that column.
      */
     filter(column: string): TableFilter | undefined;
     /**
-     * Every filter the table keeps rows by.
+     * Reads every filter the table keeps rows by, in the order they were set.
      *
-     * @returns The filters, in the order they were set.
+     * @returns The filters the table keeps rows by.
      */
     filters(): readonly TableFilter[];
     /**
-     * Filter several columns.
+     * Filters one column or several. A filter for a column already filtered replaces it; every
+     * other one joins the end. An undeclared column raises `COLUMN`, and a filter the column does
+     * not admit raises `CELL`.
      *
      * @param filters - The filters to set. A filter for a column already filtered replaces that
      *   column's filter; every other one joins the end of the list.
@@ -403,34 +381,37 @@ export declare interface FilterManagerInterface {
      */
     set(filters: readonly TableFilter[]): void;
     /**
-     * Filter one column.
+     * Filters one column.
      *
      * @param filter - The filter to set.
      * @throws A {@link TableError} coded `COLUMN` when the filter names a column the schema does
      *   not declare, and `CELL` when an operand is one the column cannot hold.
      */
     set(filter: TableFilter): void;
-    /** Stop filtering by anything. */
+    /**
+     * Stops filtering everything, one column, or several. An undeclared column returns `false` and
+     * stops nothing.
+     */
     remove(): void;
     /**
-     * Stop filtering one column.
+     * Stops filtering one column.
      *
      * @param column - The column's key.
-     * @returns `true` when the schema declares that column.
+     * @returns True if the schema declares that column; false otherwise.
      */
     remove(column: string): boolean;
     /**
-     * Stop filtering several columns.
+     * Stops filtering several columns.
      *
      * @param columns - The columns' keys.
-     * @returns `true` when the schema declares every one of them. Every key is checked before any
-     *   filter goes.
+     * @returns True if the schema declares every one of them; false otherwise. Every key is
+     *   checked before any filter goes.
      */
     remove(columns: readonly string[]): boolean;
 }
 
 /**
- * How a filter tests a cell.
+ * Names how a filter tests a cell — the operator each filter carries.
  *
  * @remarks
  * `contains` looks for text inside a `text` or `choice` cell. `between` accepts a cell inside a
@@ -443,7 +424,8 @@ export declare interface FilterManagerInterface {
 export declare type FilterOperator = 'contains' | 'between' | 'equals';
 
 /**
- * Keep the rows accepted by every filter.
+ * Keeps the rows every filter accepts, in the order given; a supplied {@link CellMatcher}
+ * replaces the default per column.
  *
  * @param schema - The schema that declares the filtered columns.
  * @param rows - The rows to filter.
@@ -453,136 +435,139 @@ export declare type FilterOperator = 'contains' | 'between' | 'equals';
  */
 export declare function filterRows(schema: TableSchema, rows: readonly TableRow[], filters: readonly TableFilter[], matchers?: Readonly<Record<string, CellMatcher>>): readonly TableRow[];
 
-/** A column of yes-or-no answers, compared false before true. */
+/** Represents a column of yes-or-no answers, compared false before true. */
 export declare interface FlagColumn extends ColumnBase {
     readonly cell: 'flag';
 }
 
 /**
- * Determine whether an unknown value is a declared column cell.
+ * Determines whether an unknown value is a declared column cell.
  *
  * @param input - The value to inspect.
- * @returns Whether the value is one of the four column cells.
+ * @returns True if the value is a declared column cell; false otherwise.
  */
 export declare function isColumnCell(input: unknown): input is ColumnCell;
 
 /**
- * Determine whether an unknown value is one exact column choice record.
+ * Determines whether an unknown value is one exact {@link ColumnChoice} record; an unknown member
+ * refuses it.
  *
  * @param input - The value to inspect.
- * @returns Whether the value is a column choice.
+ * @returns True if the value is a column choice; false otherwise.
  */
 export declare function isColumnChoice(input: unknown): input is ColumnChoice;
 
 /**
- * Determine whether an unknown value has one exact structural table-schema shape.
+ * Determines whether an unknown value has the exact shape of a {@link TableSchema} — the shape
+ * alone, with no domain check.
  *
  * @param input - The value to inspect.
- * @returns Whether the value has the exact structure of a table schema.
+ * @returns True if the value has the exact structure of a table schema; false otherwise.
  */
 export declare function isStructuralTableSchema(input: unknown): input is TableSchema;
 
 /**
- * Determine whether an unknown value has a table cell shape.
+ * Determines whether an unknown value has a table cell shape — a string, a finite number, or a
+ * boolean.
  *
  * @param input - The value to inspect.
- * @returns Whether the value is a string, finite number, or boolean.
+ * @returns True if the value is a string, finite number, or boolean; false otherwise.
  */
 export declare function isTableCell(input: unknown): input is TableCell;
 
 /**
- * Determine whether an unknown value is one exact discriminated table column.
+ * Determines whether an unknown value is one exact discriminated {@link TableColumn}, checked
+ * against its cell's own options.
  *
  * @param input - The value to inspect.
- * @returns Whether the value is a structurally valid table column.
+ * @returns True if the value is a structurally valid table column; false otherwise.
  */
 export declare function isTableColumn(input: unknown): input is TableColumn;
 
 /**
- * Determine whether an unknown value is a table error.
+ * Determines whether a caught value is a table error, so a `catch` branches on `code` without an
+ * assertion.
  *
  * @param input - The value to inspect.
- * @returns Whether the value is a {@link TableError} instance.
+ * @returns True if the value is a {@link TableError} instance; false otherwise.
  */
 export declare function isTableError(input: unknown): input is TableError;
 
 /**
- * Determine whether an unknown value is a record of table cells.
+ * Determines whether an unknown value is a record whose every own key is a string and every value
+ * a {@link TableCell}.
  *
  * @param input - The value to inspect.
- * @returns Whether every own key is a string and every value is a table cell.
+ * @returns True if every own key is a string and every value is a table cell; false otherwise.
  */
 export declare function isTableRow(input: unknown): input is TableRow;
 
 /**
- * Determine whether an unknown value is one semantically sound table schema.
+ * Determines whether an unknown value is a {@link TableSchema} a table can be opened against —
+ * the exact shape, and an audit that finds nothing.
  *
  * @param input - The value to inspect.
- * @returns Whether the value has valid structure, domain relationships, and budgets.
+ * @returns True if the value has valid structure, domain relationships, and
+ *   budgets; false otherwise.
  */
 export declare function isTableSchema(input: unknown): input is TableSchema;
 
 /**
- * Check whether a value has the shape required by one column cell.
+ * Checks whether one column can hold a value — the shape gate every write and every seed passes
+ * through.
  *
  * @param column - The column that owns the cell.
  * @param value - The unknown value to inspect.
- * @returns Whether the column can hold the value.
+ * @returns True if the column can hold the value; false otherwise.
  */
 export declare function matchesCell(column: TableColumn, value: unknown): value is TableCell;
 
 /**
- * Test one cell against a filter according to its column.
+ * Tests one of a column's cells against one filter the way its `cell` fixes.
  *
  * @param column - The column that fixes the accepted operators.
  * @param cell - The cell to test, or absence.
  * @param filter - The filter to apply.
- * @returns Whether the filter accepts the cell.
+ * @returns True if the filter accepts the cell; false otherwise.
  */
 export declare function matchesFilter(column: TableColumn, cell: TableCell | undefined, filter: TableFilter): boolean;
 
-/** The maximum length, in UTF-16 code units, of a schema name or column key. */
+/**
+ * Checks whether two lens lists hold the same terms in the same order, with the supplied test
+ * deciding the operands.
+ *
+ * @param left - The first list.
+ * @param right - The second list.
+ * @param equal - Decide whether two terms naming one column carry the same operands.
+ * @returns True if the lists are the same length and every position names the same column and
+ *   carries the same operands; false otherwise.
+ */
+export declare function matchesTerms<Term extends TableTerm>(left: readonly Term[], right: readonly Term[], equal: (left: Term, right: Term) => boolean): boolean;
+
+/**
+ * Merges lens terms into a column-keyed list, replacing the entry that names the same column —
+ * the `set` write.
+ *
+ * @param current - The list as it stands.
+ * @param requested - The terms to write, in the order they are written.
+ * @returns A frozen list holding one owned entry per column, in the order the columns first
+ *   appeared.
+ */
+export declare function mergeTerms<Term extends TableTerm>(current: readonly Term[], requested: readonly Term[]): readonly Term[];
+
+/** Names the maximum length of a schema name or column key: 128 UTF-16 code units. */
 export declare const NAME_LIMIT = 128;
 
-/** The maximum total number of records, arrays, and leaves one schema retains. */
+/** Names the maximum total number of records, arrays, and leaves one schema retains: 16384. */
 export declare const NODE_LIMIT = 16384;
 
-/** A column of numbers, compared by magnitude. */
+/** Represents a column of numbers, compared by magnitude. */
 export declare interface NumberColumn extends ColumnBase {
     readonly cell: 'number';
 }
 
-/** The page arithmetic over one table's filtered rows. */
-export declare class PaginationManager implements PaginationManagerInterface {
-    #private;
-    /**
-     * Create a pagination manager over one table's private stores.
-     *
-     * @param emitter - The table's event emitter.
-     * @param gate - The table lifecycle gate.
-     * @param rows - A read of the filtered row count.
-     * @param readPage - A read of the current page.
-     * @param writePage - The page commit boundary.
-     * @param readLimit - A read of the current page size.
-     * @param writeLimit - The page-size commit boundary.
-     */
-    constructor(emitter: Emitter<TableEventMap>, gate: () => void, rows: () => number, readPage: () => number, writePage: (page: number) => void, readLimit: () => number | undefined, writeLimit: (limit: number | undefined) => void);
-    /** The page shown, counted from one. */
-    get page(): number;
-    /** The number of rows one page holds. */
-    get limit(): number | undefined;
-    /** The number of filtered rows skipped before this page. */
-    get offset(): number;
-    /** The number of pages filled by the filtered rows. */
-    get count(): number;
-    /** Show another page, clamped to the pages that exist. */
-    move(page: number): void;
-    /** Change the page size while keeping the first row previously shown. */
-    resize(limit?: number): void;
-}
-
 /**
- * Which stretch of the filtered rows the view shows.
+ * Manages which stretch of the filtered rows the view shows.
  *
  * @remarks
  * `page` is the state, counted from one. `offset` and `count` are worked out from it and from the
@@ -599,26 +584,27 @@ export declare class PaginationManager implements PaginationManagerInterface {
  * ```
  */
 export declare interface PaginationManagerInterface {
-    /** The page the view shows, counted from one, and `1` when the table is not paged. */
+    /** Holds the page the view shows, counted from one, and `1` when the table is not paged. */
     readonly page: number;
-    /** How many rows a page holds, or `undefined` when the table is not paged. */
+    /** Holds the number of rows one page shows, or `undefined` when the table is not paged. */
     readonly limit: number | undefined;
-    /** How many rows the view skips before the page it shows, counted from zero. */
+    /** Holds the number of rows the view skips before the page it shows, counted from zero. */
     readonly offset: number;
-    /** How many pages the rows admitted by the filter fill, and `1` when the table is not paged. */
+    /** Counts the pages the rows admitted by the filter fill, and `1` when the table is not paged. */
     readonly count: number;
     /**
-     * Show another page.
+     * Shows another page, counted from one and clamped to the pages that exist.
      *
-     * @param page - The page to show, counted from one and clamped to the pages that exist.
+     * @param page - The page to show, counted from one and clamped to the pages that exist. `NaN`
+     *   shows the first page.
      */
     move(page: number): void;
     /**
-     * Say how many rows a page holds.
+     * Sets how many rows a page holds, keeping the first row the view was showing. Leave the
+     * argument out to stop paging.
      *
      * @remarks
-     * The view keeps showing the first of the rows it was showing, so the page moves to wherever
-     * that row now falls.
+     * The page moves to wherever that first row now falls.
      *
      * @param limit - How many rows a page holds. Leave it out to stop paging, and the view shows
      *   every row the filter admits.
@@ -627,7 +613,8 @@ export declare interface PaginationManagerInterface {
 }
 
 /**
- * Parse unknown wire rows against one table schema.
+ * Parses unknown wire data into owned rows against one table schema, coercing a numeric string
+ * and `'true'` / `'false'`.
  *
  * @param schema - The schema that declares the accepted keys and cell shapes.
  * @param input - The unknown row-list value to parse.
@@ -636,52 +623,25 @@ export declare interface PaginationManagerInterface {
 export declare function parseRows(schema: TableSchema, input: unknown): readonly TableRow[] | undefined;
 
 /**
- * Parse unknown wire data into an owned, semantically sound table schema.
+ * Parses unknown wire data into an owned, structurally valid, semantically sound table schema.
  *
  * @param input - The unknown schema value to parse.
  * @returns An owned table schema, or `undefined` on refusal.
  */
 export declare function parseTable(input: unknown): TableSchema | undefined;
 
-/** The rows one table holds in its own order. */
-export declare class RowManager implements RowManagerInterface {
-    #private;
-    /**
-     * Create a row manager over one table's private row store.
-     *
-     * @param schema - The table schema.
-     * @param emitter - The table's event emitter.
-     * @param gate - The table lifecycle gate.
-     * @param read - A read of the current rows.
-     * @param write - The row commit boundary.
-     * @param settle - Commit dependent state, then order row and dependent announcements.
-     * @param rows - Rows to seed without announcements.
-     */
-    constructor(schema: TableSchema, emitter: Emitter<TableEventMap>, gate: () => void, read: () => readonly TableRow[], write: (rows: readonly TableRow[]) => void, settle: (removed: readonly TableKey[], announce: () => void) => void, rows?: readonly TableRow[]);
-    /** Find one row by key as an owned frozen snapshot. */
-    row(key: TableKey): TableRow | undefined;
-    /** Read every row as owned frozen snapshots in table order. */
-    rows(): readonly TableRow[];
-    /** Append several rows. */
-    add(rows: readonly TableRow[]): void;
-    /** Append one row. */
-    add(row: TableRow): void;
-    /** Merge several rows into the rows their keys name. */
-    update(rows: readonly TableRow[]): boolean;
-    /** Merge one row into the row its key names. */
-    update(row: TableRow): boolean;
-    /** Move one row to a clamped index in table order. */
-    move(key: TableKey, index: number): boolean;
-    /** Remove every row. */
-    remove(): void;
-    /** Remove one row. */
-    remove(key: TableKey): boolean;
-    /** Remove several rows. */
-    remove(keys: readonly TableKey[]): boolean;
-}
+/**
+ * Removes every lens term naming one of the given columns — the drop `sort.remove` and
+ * `filter.remove` share.
+ *
+ * @param current - The list as it stands.
+ * @param columns - The column keys to drop.
+ * @returns A frozen list holding the entries no named column matched, in their original order.
+ */
+export declare function removeTerms<Term extends TableTerm>(current: readonly Term[], columns: readonly string[]): readonly Term[];
 
 /**
- * The rows a table holds, in the order it holds them.
+ * Manages the rows a table holds, in the order it holds them.
  *
  * @remarks
  * This order is the table's own, and it is what the view shows when no sort term separates two
@@ -695,20 +655,21 @@ export declare class RowManager implements RowManagerInterface {
  */
 export declare interface RowManagerInterface {
     /**
-     * Find one row by key.
+     * Finds one row by key; `undefined` when the table holds no such key.
      *
      * @param key - The row's key.
      * @returns The row, or `undefined` when the table holds no such key.
      */
     row(key: TableKey): TableRow | undefined;
     /**
-     * Every row the table holds, in its own order.
+     * Reads every row the table holds, in its own order — unfiltered, unsorted, and unpaged.
      *
-     * @returns The rows, unfiltered, unsorted, and unpaged.
+     * @returns The rows, in the order the table holds them.
      */
     rows(): readonly TableRow[];
     /**
-     * Take in several rows, appending them in the order given.
+     * Takes in one row or several, appending them in the order given. Every row is checked before
+     * any is admitted.
      *
      * @param rows - The rows to admit.
      * @throws A {@link TableError} coded `KEY` when a row's key is missing, unusable, already
@@ -717,7 +678,7 @@ export declare interface RowManagerInterface {
      */
     add(rows: readonly TableRow[]): void;
     /**
-     * Take in one row, appending it.
+     * Takes in one row, appending it.
      *
      * @param row - The row to admit.
      * @throws A {@link TableError} coded `KEY` when the row's key is missing, unusable, or already
@@ -725,93 +686,61 @@ export declare interface RowManagerInterface {
      */
     add(row: TableRow): void;
     /**
-     * Write over several rows, each found by the key it carries.
+     * Writes over one row or several, each found by the key it carries. The cells given replace;
+     * the cells left out stay.
      *
      * @param rows - The rows to write, each carrying the key of the row it writes over.
-     * @returns `true` when every key named a row the table holds.
+     * @returns True if every key named a row the table holds; false otherwise.
      * @throws A {@link TableError} coded `CELL` when a cell is one its column cannot hold. Every
      *   row is checked before any is written, so one refusal writes none of them.
      */
     update(rows: readonly TableRow[]): boolean;
     /**
-     * Write over one row, found by the key it carries.
+     * Writes over one row, found by the key it carries.
      *
      * @remarks
      * The cells given replace the cells held; the cells left out stay as they are. A row's key
      * therefore cannot move, because a different key names a different row.
      *
      * @param row - The cells to write, carrying the key of the row they belong to.
-     * @returns `true` when the key named a row the table holds.
+     * @returns True if the key named a row the table holds; false otherwise.
      * @throws A {@link TableError} coded `CELL` when a cell is one its column cannot hold.
      */
     update(row: TableRow): boolean;
     /**
-     * Move one row to another place in the table's own order.
+     * Moves one row to another place in the table's own order, counted from zero and clamped to the
+     * rows that exist.
      *
      * @param key - The row's key.
-     * @param index - Where to put it, counted from zero and clamped to the rows that exist.
-     * @returns `true` when the key named a row the table holds.
+     * @param index - Where to put it, counted from zero and clamped to the rows that exist. `NaN`
+     *   puts the row first.
+     * @returns True if the key named a row the table holds; false otherwise.
      */
     move(key: TableKey, index: number): boolean;
     /**
-     * Take out every row.
-     *
-     * @remarks
-     * Selection and expansion drop the keys they held, because those rows are gone.
+     * Takes out every row, one row, or several. Selection and expansion drop the keys of the rows
+     * that went.
      */
     remove(): void;
     /**
-     * Take out one row.
+     * Takes out one row.
      *
      * @param key - The row's key.
-     * @returns `true` when the key named a row the table holds.
+     * @returns True if the key named a row the table holds; false otherwise.
      */
     remove(key: TableKey): boolean;
     /**
-     * Take out several rows.
+     * Takes out several rows.
      *
      * @param keys - The rows' keys.
-     * @returns `true` when every key named a row the table holds. Every key is checked before any
-     *   row goes, so one unknown key leaves the whole call undone.
+     * @returns True if every key named a row the table holds; false otherwise. Every key is
+     *   checked before any row goes, so one unknown key leaves the whole call undone.
      */
     remove(keys: readonly TableKey[]): boolean;
 }
 
-/** The keys of the rows somebody has picked. */
-export declare class SelectionManager implements SelectionManagerInterface {
-    #private;
-    /**
-     * Create a selection manager over one table's private stores.
-     *
-     * @param emitter - The table's event emitter.
-     * @param gate - The table lifecycle gate.
-     * @param rows - A read of every row key.
-     * @param read - A read of the selected keys.
-     * @param write - The selected-key commit boundary.
-     */
-    constructor(emitter: Emitter<TableEventMap>, gate: () => void, rows: () => readonly TableKey[], read: () => ReadonlySet<TableKey>, write: (keys: ReadonlySet<TableKey>) => void);
-    /** The keys of the rows picked right now. */
-    get keys(): ReadonlySet<TableKey>;
-    /** Pick every row the table holds. */
-    select(): void;
-    /** Pick one row. */
-    select(key: TableKey): boolean;
-    /** Pick several rows. */
-    select(keys: readonly TableKey[]): boolean;
-    /** Drop every pick. */
-    clear(): void;
-    /** Drop one pick. */
-    clear(key: TableKey): boolean;
-    /** Drop several picks. */
-    clear(keys: readonly TableKey[]): boolean;
-    /** Pick one row or drop it when already picked. */
-    toggle(key: TableKey): boolean;
-    /** Turn several rows around independently. */
-    toggle(keys: readonly TableKey[]): boolean;
-}
-
 /**
- * The rows somebody has picked.
+ * Manages the rows somebody has picked.
  *
  * @remarks
  * Selection holds keys, never rows or positions, so a pick survives a sort, a filter, and a page
@@ -824,67 +753,71 @@ export declare class SelectionManager implements SelectionManagerInterface {
  * ```
  */
 export declare interface SelectionManagerInterface {
-    /** The keys of the rows picked right now. */
+    /** Holds the keys of the rows picked right now. */
     readonly keys: ReadonlySet<TableKey>;
     /**
-     * Pick every row the table holds.
+     * Picks every row the table holds, one row, or several. Every row, not every visible one.
      *
      * @remarks
-     * Every row, not every visible one. A host picking one page hands that page's keys over
-     * instead.
+     * A host picking one page hands that page's keys over instead.
      */
     select(): void;
     /**
-     * Pick one row.
+     * Picks one row.
      *
      * @param key - The row's key.
-     * @returns `true` when the key named a row the table holds.
+     * @returns True if the key named a row the table holds; false otherwise.
      */
     select(key: TableKey): boolean;
     /**
-     * Pick several rows.
+     * Picks several rows.
      *
      * @param keys - The rows' keys.
-     * @returns `true` when every key named a row the table holds. Every key is checked before any
-     *   row is picked.
+     * @returns True if every key named a row the table holds; false otherwise. Every key is
+     *   checked before any row is picked.
      */
     select(keys: readonly TableKey[]): boolean;
-    /** Drop every pick. */
+    /**
+     * Drops every pick, one pick, or several. A known key that was not picked still answers `true`.
+     */
     clear(): void;
     /**
-     * Drop one pick.
+     * Drops one pick.
      *
      * @param key - The row's key.
-     * @returns `true` when the key named a row the table holds, whether or not it was picked.
+     * @returns True if the key named a row the table holds, whether or not it was
+     *   picked; false otherwise.
      */
     clear(key: TableKey): boolean;
     /**
-     * Drop several picks.
+     * Drops several picks.
      *
      * @param keys - The rows' keys.
-     * @returns `true` when every key named a row the table holds. Every key is checked before any
-     *   pick is dropped.
+     * @returns True if every key named a row the table holds; false otherwise. Every key is
+     *   checked before any pick is dropped.
      */
     clear(keys: readonly TableKey[]): boolean;
     /**
-     * Pick one row, or drop it when it is already picked.
+     * Picks one row, or drops it when it is already picked; over a list, turns each row around on
+     * its own.
      *
      * @param key - The row's key.
-     * @returns `true` when the key named a row the table holds.
+     * @returns True if the key named a row the table holds; false otherwise.
      */
     toggle(key: TableKey): boolean;
     /**
-     * Turn several rows around, each on its own.
+     * Turns several rows around, each on its own.
      *
      * @param keys - The rows' keys.
-     * @returns `true` when every key named a row the table holds. Every key is checked before any
-     *   row turns.
+     * @returns True if every key named a row the table holds; false otherwise. Every key is
+     *   checked before any row turns.
      */
     toggle(keys: readonly TableKey[]): boolean;
 }
 
 /**
- * Project rows into schema-column-ordered JSON.
+ * Projects rows into JSON with each row's cells in the schema's column order, dropping every
+ * absent cell.
  *
  * @param schema - The schema that fixes cell order.
  * @param rows - The rows to project.
@@ -893,7 +826,8 @@ export declare interface SelectionManagerInterface {
 export declare function serializeRows(schema: TableSchema, rows: readonly TableRow[]): readonly JSONRecord[];
 
 /**
- * Project a schema into declaration-ordered JSON.
+ * Projects a schema into JSON in declaration order, dropping every absent member; raises `SCHEMA`
+ * for a `meta` it cannot own.
  *
  * @param schema - The schema to project.
  * @returns A deeply owned JSON record with absent members omitted.
@@ -901,37 +835,8 @@ export declare function serializeRows(schema: TableSchema, rows: readonly TableR
  */
 export declare function serializeTable(schema: TableSchema): JSONRecord;
 
-/** The ordered sort terms of one table. */
-export declare class SortManager implements SortManagerInterface {
-    #private;
-    /**
-     * Create a sort manager over one table's private term store.
-     *
-     * @param schema - The table schema.
-     * @param emitter - The table's event emitter.
-     * @param gate - The table lifecycle gate.
-     * @param read - A read of the current terms.
-     * @param write - The term commit boundary.
-     */
-    constructor(schema: TableSchema, emitter: Emitter<TableEventMap>, gate: () => void, read: () => readonly TableOrder[], write: (orders: readonly TableOrder[]) => void);
-    /** Find one column's sort term. */
-    order(column: string): TableOrder | undefined;
-    /** Read every sort term as an owned frozen snapshot. */
-    orders(): readonly TableOrder[];
-    /** Sort by several columns. */
-    set(orders: readonly TableOrder[]): void;
-    /** Sort by one column. */
-    set(order: TableOrder): void;
-    /** Stop sorting by every column. */
-    remove(): void;
-    /** Stop sorting by one column. */
-    remove(column: string): boolean;
-    /** Stop sorting by several columns. */
-    remove(columns: readonly string[]): boolean;
-}
-
 /**
- * The order a table reads its rows in.
+ * Manages the order a table reads its rows in.
  *
  * @remarks
  * The table holds one term per column and applies them in the order they were set. Which
@@ -946,20 +851,21 @@ export declare class SortManager implements SortManagerInterface {
  */
 export declare interface SortManagerInterface {
     /**
-     * Find one column's term.
+     * Finds one column's term; `undefined` when nothing sorts that column.
      *
      * @param column - The column's key.
      * @returns The term, or `undefined` when nothing sorts that column.
      */
     order(column: string): TableOrder | undefined;
     /**
-     * Every term the table sorts by.
+     * Reads every term the table sorts by, first to last, in the order they decide.
      *
-     * @returns The terms, first to last, in the order they decide.
+     * @returns The terms the table sorts by.
      */
     orders(): readonly TableOrder[];
     /**
-     * Sort by several columns.
+     * Sorts by one column or several. A term for a column already sorted replaces its direction in
+     * place; every other term joins the end. An undeclared column raises `COLUMN`.
      *
      * @param orders - The terms to set. A term for a column already sorted replaces that column's
      *   direction in place; every other term joins the end of the list.
@@ -968,34 +874,38 @@ export declare interface SortManagerInterface {
      */
     set(orders: readonly TableOrder[]): void;
     /**
-     * Sort by one column.
+     * Sorts by one column.
      *
      * @param order - The term to set.
      * @throws A {@link TableError} coded `COLUMN` when the term names a column the schema does not
      *   declare.
      */
     set(order: TableOrder): void;
-    /** Stop sorting by anything. */
+    /**
+     * Stops sorting by everything, by one column, or by several. An undeclared column returns
+     * `false` and stops nothing.
+     */
     remove(): void;
     /**
-     * Stop sorting by one column.
+     * Stops sorting by one column.
      *
      * @param column - The column's key.
-     * @returns `true` when the schema declares that column.
+     * @returns True if the schema declares that column; false otherwise.
      */
     remove(column: string): boolean;
     /**
-     * Stop sorting by several columns.
+     * Stops sorting by several columns.
      *
      * @param columns - The columns' keys.
-     * @returns `true` when the schema declares every one of them. Every key is checked before any
-     *   term goes.
+     * @returns True if the schema declares every one of them; false otherwise. Every key is
+     *   checked before any term goes.
      */
     remove(columns: readonly string[]): boolean;
 }
 
 /**
- * Order rows stably by a sequence of terms.
+ * Orders rows by the terms given, stably; a supplied {@link CellComparator} replaces the default
+ * per column.
  *
  * @param schema - The schema that declares the sorted columns.
  * @param rows - The rows to order.
@@ -1005,14 +915,17 @@ export declare interface SortManagerInterface {
  */
 export declare function sortRows(schema: TableSchema, rows: readonly TableRow[], orders: readonly TableOrder[], comparators?: Readonly<Record<string, CellComparator>>): readonly TableRow[];
 
-/** The maximum length, in UTF-16 code units, of any single retained string. */
+/** Names the maximum length of any single retained string: 65536 UTF-16 code units. */
 export declare const STRING_LIMIT = 65536;
 
-/** A schema, its rows, and the lens through which they are read. */
+/**
+ * Holds a schema, its rows, and the lens through which they are read, implementing
+ * {@link TableInterface} exactly.
+ */
 export declare class Table implements TableInterface {
     #private;
     /**
-     * Open a table against a schema.
+     * Opens a table against a schema.
      *
      * @param schema - The table declaration to own.
      * @param options - Initial rows, lens overrides, pagination, and emitter wiring.
@@ -1020,36 +933,36 @@ export declare class Table implements TableInterface {
      *   identity is unusable or repeated, and `CELL` when a seeded cell is invalid.
      */
     constructor(schema: TableSchema, options?: TableOptions);
-    /** The table's event emitter. */
+    /** Holds the table's event emitter. */
     get emitter(): EmitterInterface<TableEventMap>;
-    /** The owned frozen schema. */
+    /** Holds the owned frozen schema. */
     get schema(): TableSchema;
-    /** The rows the table holds. */
+    /** Manages the rows the table holds. */
     get rows(): RowManagerInterface;
-    /** The ordered sort terms. */
+    /** Manages the ordered sort terms. */
     get sort(): SortManagerInterface;
-    /** The filters applied with and-only composition. */
+    /** Manages the filters applied with and-only composition. */
     get filter(): FilterManagerInterface;
-    /** The selected row keys. */
+    /** Manages the selected row keys. */
     get selection(): SelectionManagerInterface;
-    /** The expanded row keys. */
+    /** Manages the expanded row keys. */
     get expansion(): ExpansionManagerInterface;
-    /** The page arithmetic. */
+    /** Manages the page arithmetic. */
     get pagination(): PaginationManagerInterface;
-    /** The filtered, sorted, and paged rows as owned frozen snapshots. */
+    /** Returns the filtered, sorted, and paged rows as owned frozen snapshots. */
     get view(): readonly TableRow[];
-    /** The number of rows admitted by the filters. */
+    /** Returns the number of rows admitted by the filters. */
     get count(): number;
-    /** Whether the table has been torn down. */
+    /** Reports whether the table has been torn down. */
     get destroyed(): boolean;
-    /** Reset every moving axis to its opening state. */
+    /** Resets every moving axis to its opening state. */
     clear(): void;
-    /** Tear the table down while leaving every getter readable. */
+    /** Tears the table down while leaving every getter readable. */
     destroy(): void;
 }
 
 /**
- * Every value a cell can hold.
+ * Represents every value a cell can hold — a `string`, a `number`, or a `boolean`.
  *
  * @remarks
  * The variant follows the column: `text` and `choice` hold a `string`, `number` holds a `number`,
@@ -1059,11 +972,10 @@ export declare class Table implements TableInterface {
 export declare type TableCell = string | number | boolean;
 
 /**
- * Any column a schema can declare.
+ * Represents any column a schema can declare — the union discriminated on `cell`.
  *
  * @remarks
- * The union discriminates on `cell`, so narrowing on that member reaches each variant's own
- * members.
+ * Narrowing on `cell` reaches each variant's own members.
  *
  * @example
  * ```ts
@@ -1075,22 +987,24 @@ export declare type TableCell = string | number | boolean;
 export declare type TableColumn = TextColumn | NumberColumn | FlagColumn | ChoiceColumn;
 
 /**
- * Which way a column sorts.
+ * Names which way a column sorts. A column nobody has sorted carries no term at all.
  *
  * @remarks
- * A column nobody has sorted has no {@link TableOrder} at all, so there is no third member
- * standing for unsorted.
+ * No member of this union stands for unsorted; that state is the missing {@link TableOrder}.
  */
 export declare type TableDirection = 'ascending' | 'descending';
 
-/** An error raised by the table domain. */
+/**
+ * Represents an error raised by the table domain — a machine-readable `code` and optional
+ * structured `context`.
+ */
 export declare class TableError extends Error {
-    /** The machine-readable reason for this failure. */
+    /** Holds the machine-readable reason for this failure. */
     readonly code: TableErrorCode;
-    /** Structured values that locate or explain this failure. */
+    /** Holds structured values that locate or explain this failure. */
     readonly context?: JSONRecord;
     /**
-     * Create a table error.
+     * Creates a table error.
      *
      * @param code - The machine-readable reason.
      * @param message - The human-readable failure text.
@@ -1100,7 +1014,7 @@ export declare class TableError extends Error {
 }
 
 /**
- * The machine-readable code a table error carries.
+ * Names the reason a {@link TableError} carries — the machine-readable code a `catch` branches on.
  *
  * @remarks
  * `SCHEMA` rejects a malformed schema, including a `key` naming no declared column. `COLUMN`
@@ -1111,7 +1025,7 @@ export declare class TableError extends Error {
 export declare type TableErrorCode = 'SCHEMA' | 'COLUMN' | 'KEY' | 'CELL' | 'DESTROYED';
 
 /**
- * Everything a table announces.
+ * Lists everything a table announces, mapping each event to the payload its listeners receive.
  *
  * @remarks
  * Every event fires after the state it reports is committed, and only when something actually
@@ -1141,11 +1055,11 @@ export declare type TableEventMap = {
 };
 
 /**
- * Any filter a table can hold.
+ * Represents any filter a table can hold — the union discriminated on `operator`.
  *
  * @remarks
- * The union discriminates on `operator`, so each operator carries only the operands it uses and a
- * `between` missing a bound cannot be written down.
+ * Each operator carries only the operands it uses, so a `between` missing a bound cannot be
+ * written down.
  *
  * A table holds at most one filter per column and keeps every row all of them accept. There is no
  * either-or composition in this version.
@@ -1158,15 +1072,15 @@ export declare type TableEventMap = {
 export declare type TableFilter = ContainsFilter | BetweenFilter | EqualsFilter;
 
 /**
- * A table: what it declares, the rows it holds, and the lens it reads them through.
+ * Represents a table: what it declares, the rows it holds, and the lens it reads them through.
  *
  * @remarks
  * The table owns values, not pixels. It renders nothing, reads no document, and names no host
  * type, so one table serves a browser, a terminal, a report, and an export equally.
  *
- * Six managers hold everything that moves, one per axis: `rows`, `sort`, `filter`, `selection`,
- * `expansion`, and `pagination`. Nothing else is stored. `view` and `count` are worked out when
- * they are read, so no second copy of the answer can go stale.
+ * One manager holds each axis that moves: `rows`, `sort`, `filter`, `selection`, `expansion`, and
+ * `pagination`. Nothing else is stored. `view` and `count` are worked out when they are read, so no
+ * second copy of the answer can go stale.
  *
  * A write validates all of itself before any of it lands, and announces itself once it has.
  *
@@ -1178,59 +1092,60 @@ export declare type TableFilter = ContainsFilter | BetweenFilter | EqualsFilter;
  * ```
  */
 export declare interface TableInterface {
-    /** The table's event emitter. */
+    /** Holds the table's event emitter. */
     readonly emitter: EmitterInterface<TableEventMap>;
-    /** What this table declares. */
+    /** Holds what this table declares. */
     readonly schema: TableSchema;
-    /** The rows the table holds. */
+    /** Manages the rows the table holds. */
     readonly rows: RowManagerInterface;
-    /** The order the table reads them in. */
+    /** Manages the order the table reads them in. */
     readonly sort: SortManagerInterface;
-    /** Which of them the table keeps. */
+    /** Manages which of them the table keeps. */
     readonly filter: FilterManagerInterface;
-    /** The ones somebody has picked. */
+    /** Manages the ones somebody has picked. */
     readonly selection: SelectionManagerInterface;
-    /** The ones somebody has opened up. */
+    /** Manages the ones somebody has opened up. */
     readonly expansion: ExpansionManagerInterface;
-    /** Which stretch of them the view shows. */
+    /** Manages which stretch of them the view shows. */
     readonly pagination: PaginationManagerInterface;
     /**
-     * The rows to draw right now: filtered, then sorted, then paged.
+     * Returns the rows to draw right now: filtered, then sorted, then paged.
      *
      * @remarks
      * It is worked out on every read and never stored, so it is right the instant anything moves.
      */
     readonly view: readonly TableRow[];
-    /** How many rows the filter admits, before the page narrows them. */
+    /** Counts the rows the filter admits, before the page narrows them. */
     readonly count: number;
-    /** Whether the table has been torn down. */
+    /** Reports whether the table has been torn down. */
     readonly destroyed: boolean;
     /**
-     * Put the table back the way it opened, holding nothing.
+     * Puts the table back the way it opened, holding nothing. Rows, sort, filter, selection,
+     * expansion, and the page all reset.
      *
      * @remarks
-     * Every row goes, and sort, filter, selection, expansion, and the page all reset. The table
-     * emits `clear` and nothing else, so a reset of ten thousand rows is one announcement.
+     * The table emits `clear` and nothing else, so a reset of ten thousand rows is one
+     * announcement.
      */
     clear(): void;
     /**
-     * Tear the table down.
+     * Tears the table down. Idempotent; afterwards every write raises `DESTROYED` and every getter
+     * still answers.
      *
      * @remarks
-     * Calling it twice does what calling it once did. Afterwards every write throws a
-     * {@link TableError} coded `DESTROYED`, while every getter still answers what the table last
-     * held, so a host can read its way out of teardown without catching anything.
+     * The write throws a {@link TableError} carrying that code, and what a getter answers is what
+     * the table last held, so a host can read its way out of teardown without catching anything.
      */
     destroy(): void;
 }
 
 /**
- * A row's identity.
+ * Represents a row's identity — a `string`, carried in the cell the schema's `key` names.
  *
  * @remarks
- * Every row carries its own identity in the cell named by {@link TableSchema.key}, as a non-empty
- * string. A column's own identifier is a plain `string`; this names a row. Selection and expansion
- * hold these keys and nothing else, so a row keeps its selection through a re-sort.
+ * The identity must be non-empty. A column's own identifier is a plain `string`; this names a row.
+ * Selection and expansion hold these keys and nothing else, so a row keeps its selection through a
+ * re-sort.
  *
  * @example
  * ```ts
@@ -1240,9 +1155,10 @@ export declare interface TableInterface {
 export declare type TableKey = string;
 
 /**
- * How to open a table.
+ * Describes how to open a table — the listeners wired at construction and where a throw from one
+ * goes, the rows seeded into it, the per-column comparison and test replacements, and the page
+ * size.
  *
- * @param options - The table's settings.
  * @remarks
  * `on` wires listeners at construction and `error` receives any throw from one of them.
  *
@@ -1275,11 +1191,12 @@ export declare interface TableOptions {
 }
 
 /**
- * One column's place in the sort.
+ * Represents one column's place in the sort — the `column` and its `direction`. The list is read
+ * left to right.
  *
  * @remarks
- * The order list is read left to right: the first term decides, and each later term breaks the
- * tie the terms before it left. Rows no term separates keep the order the table holds them in.
+ * The first term decides, and each later term breaks the tie the terms before it left. Rows no
+ * term separates keep the order the table holds them in.
  *
  * @example
  * ```ts
@@ -1292,12 +1209,11 @@ export declare interface TableOrder {
 }
 
 /**
- * One row, keyed by column.
+ * Represents one row, keyed by column. A column nobody has filled has no key here.
  *
  * @remarks
- * A row declares a cell for the columns it carries and omits the rest. It carries no key the
- * schema does not declare, and the table clones and freezes it at admission, so nothing a caller
- * holds afterwards can move a stored row.
+ * A row carries no key the schema does not declare, and the table clones and freezes it at
+ * admission, so nothing a caller holds afterwards can move a stored row.
  *
  * @example
  * ```ts
@@ -1307,7 +1223,8 @@ export declare interface TableOrder {
 export declare type TableRow = Readonly<Record<string, TableCell>>;
 
 /**
- * Everything a table declares about itself.
+ * Holds everything a table declares about itself — how the table is described, which column
+ * carries row identity, and the columns it declares, in the order it declares them.
  *
  * @remarks
  * The schema is data. It carries no function, so all of it crosses a wire and nothing is dropped
@@ -1342,10 +1259,28 @@ export declare interface TableSchema {
     readonly columns: readonly TableColumn[];
 }
 
-/** The maximum total length, in UTF-16 code units, of every string one schema retains. */
+/**
+ * Represents one entry of a lens list — the `column` it names. A sort term and a filter each hold
+ * one, which is why the two share a list engine.
+ *
+ * @remarks
+ * A table holds at most one sort term and at most one filter per column, so `column` is what
+ * places an entry in either list. {@link mergeTerms}, {@link removeTerms}, and
+ * {@link matchesTerms} work over this shape alone, so each list keeps its own operands.
+ */
+export declare interface TableTerm {
+    readonly column: string;
+}
+
+/**
+ * Names the maximum total length of every string one schema retains: 1048576 UTF-16 code units.
+ */
 export declare const TEXT_LIMIT = 1048576;
 
-/** A column of text, compared lexically. */
+/**
+ * Represents a column of text, compared lexically. Carries a date, a time, and a timestamp as ISO
+ * strings.
+ */
 export declare interface TextColumn extends ColumnBase {
     readonly cell: 'text';
 }