@orkestrel/table 0.0.2 → 0.0.4

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

@@ -1,20 +1,19 @@
-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';
 
 /**
- * Check whether one column admits a filter and all its operands.
+ * Checks whether one column admits a filter and all its operands.
  *
  * @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 and budget faults.
  *
  * @param schema - The table schema to audit.
  * @returns Frozen human-readable diagnostics, or an empty list when the schema is sound.
@@ -22,7 +21,7 @@ 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 these bounds, both included.
  *
  * @remarks
  * The bounds compare the way the column compares, so a `text` column holding ISO strings takes a
@@ -36,7 +35,7 @@ export declare interface BetweenFilter {
 }
 
 /**
- * Compare two cells of one column.
+ * Compares two cells of one column.
  *
  * @remarks
  * It replaces the comparison the column's {@link ColumnCell} fixes, for that column alone, and it
@@ -56,7 +55,7 @@ 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.
  *
  * @remarks
  * It replaces the test the column's {@link ColumnCell} fixes, for that column alone, and it
@@ -64,7 +63,7 @@ export declare type CellComparator = (left: TableCell | undefined, right: TableC
  *
  * @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 +72,11 @@ 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. */
 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.
  *
  * @remarks
  * A cell holding a value the list does not offer is refused at admission.
@@ -88,7 +87,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 +95,21 @@ export declare interface ChoiceColumn extends ColumnBase {
 export declare function cloneRow(row: TableRow): TableRow;
 
 /**
- * Clone a table schema into an owned frozen snapshot.
+ * Clones a table schema into an owned frozen snapshot.
  *
  * @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. */
 export declare const COLUMN_LIMIT = 256;
 
 /**
- * What every column carries, whatever its cells hold.
+ * Describes what every column carries, whatever its cells hold.
  *
  * @remarks
  * `key` names the column, and it is the name a row uses for that column's cell. `label` is the
@@ -135,7 +134,7 @@ export declare interface ColumnBase {
 }
 
 /**
- * What a column's cells hold.
+ * Names what a column's cells hold.
  *
  * @remarks
  * The cell is the discriminant of every {@link TableColumn} variant, so choosing it fixes what the
@@ -153,7 +152,7 @@ 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.
  *
  * @remarks
  * `value` is what the cell holds and `label` is what a reader sees. `help` explains the choice.
@@ -167,7 +166,7 @@ export declare interface ColumnChoice {
 }
 
 /**
- * Compare two cells in ascending order according to one column.
+ * Compares two cells in ascending order according to one column.
  *
  * @param column - The column that fixes the comparison.
  * @param left - The first cell, or absence.
@@ -177,7 +176,7 @@ 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 known keys.
  *
  * @param known - Every key the caller may change.
  * @param current - The current key set.
@@ -188,7 +187,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,7 +195,7 @@ export declare interface ContainsFilter {
 }
 
 /**
- * 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.
@@ -211,48 +210,15 @@ export declare interface ContainsFilter {
  */
 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 +231,62 @@ 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. */
     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. */
     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.
      *
      * @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.
  *
  * @param schema - The schema whose columns to search.
  * @param key - The column key to find.
@@ -328,7 +295,7 @@ 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.
  *
  * @param schema - The schema that names the identity column.
  * @param row - The row whose identity to read.
@@ -336,38 +303,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 +317,20 @@ export declare class FilterManager implements FilterManagerInterface {
  */
 export declare interface FilterManagerInterface {
     /**
-     * Find one column's filter.
+     * Finds one column's filter.
      *
      * @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.
      *
      * @returns The filters, in the order they were set.
      */
     filters(): readonly TableFilter[];
     /**
-     * Filter several columns.
+     * Filters several columns.
      *
      * @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 +340,34 @@ 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 by anything. */
     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.
  *
  * @remarks
  * `contains` looks for text inside a `text` or `choice` cell. `between` accepts a cell inside a
@@ -443,7 +380,7 @@ export declare interface FilterManagerInterface {
 export declare type FilterOperator = 'contains' | 'between' | 'equals';
 
 /**
- * Keep the rows accepted by every filter.
+ * Keeps the rows accepted by every filter.
  *
  * @param schema - The schema that declares the filtered columns.
  * @param rows - The rows to filter.
@@ -453,136 +390,129 @@ 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 column choice record.
  *
  * @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 one exact structural table-schema shape.
  *
  * @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.
  *
  * @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 table column.
  *
  * @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 an unknown value is a table error.
  *
  * @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 of table cells.
  *
  * @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 one semantically sound table schema.
  *
  * @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 a value has the shape required by one column cell.
  *
  * @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 cell against a filter according to its column.
  *
  * @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.
+ *
+ * @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.
+ *
+ * @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, in UTF-16 code units, of a schema name or column key. */
 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. */
 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,22 +529,23 @@ 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.
      *
-     * @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.
      *
      * @remarks
      * The view keeps showing the first of the rows it was showing, so the page moves to wherever
@@ -627,7 +558,7 @@ export declare interface PaginationManagerInterface {
 }
 
 /**
- * Parse unknown wire rows against one table schema.
+ * Parses unknown wire rows against one table schema.
  *
  * @param schema - The schema that declares the accepted keys and cell shapes.
  * @param input - The unknown row-list value to parse.
@@ -636,52 +567,24 @@ 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, 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.
+ *
+ * @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 +598,20 @@ export declare class RowManager implements RowManagerInterface {
  */
 export declare interface RowManagerInterface {
     /**
-     * Find one row by key.
+     * Finds one row by 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.
      *
      * @returns The rows, unfiltered, unsorted, and unpaged.
      */
     rows(): readonly TableRow[];
     /**
-     * Take in several rows, appending them in the order given.
+     * Takes in several rows, appending them in the order given.
      *
      * @param rows - The rows to admit.
      * @throws A {@link TableError} coded `KEY` when a row's key is missing, unusable, already
@@ -717,7 +620,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 +628,61 @@ export declare interface RowManagerInterface {
      */
     add(row: TableRow): void;
     /**
-     * Write over several rows, each found by the key it carries.
+     * Writes over several rows, each found by the key it carries.
      *
      * @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.
      *
      * @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.
+     * Takes out every row.
      *
      * @remarks
      * Selection and expansion drop the keys they held, because those rows are gone.
      */
     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,10 +695,10 @@ 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.
      *
      * @remarks
      * Every row, not every visible one. A host picking one page hands that page's keys over
@@ -835,56 +706,57 @@ export declare interface SelectionManagerInterface {
      */
     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. */
     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.
      *
      * @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 schema-column-ordered JSON.
  *
  * @param schema - The schema that fixes cell order.
  * @param rows - The rows to project.
@@ -893,7 +765,7 @@ 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 declaration-ordered JSON.
  *
  * @param schema - The schema to project.
  * @returns A deeply owned JSON record with absent members omitted.
@@ -901,37 +773,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 +789,20 @@ export declare class SortManager implements SortManagerInterface {
  */
 export declare interface SortManagerInterface {
     /**
-     * Find one column's term.
+     * Finds one column's term.
      *
      * @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.
      *
      * @returns The terms, first to last, in the order they decide.
      */
     orders(): readonly TableOrder[];
     /**
-     * Sort by several columns.
+     * Sorts by several columns.
      *
      * @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 +811,34 @@ 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 anything. */
     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 stably by a sequence of terms.
  *
  * @param schema - The schema that declares the sorted columns.
  * @param rows - The rows to order.
@@ -1005,14 +848,14 @@ 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, in UTF-16 code units, of any single retained string. */
 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. */
 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 +863,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.
  *
  * @remarks
  * The variant follows the column: `text` and `choice` hold a `string`, `number` holds a `number`,
@@ -1059,7 +902,7 @@ 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.
  *
  * @remarks
  * The union discriminates on `cell`, so narrowing on that member reaches each variant's own
@@ -1075,7 +918,7 @@ 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.
  *
  * @remarks
  * A column nobody has sorted has no {@link TableOrder} at all, so there is no third member
@@ -1083,14 +926,14 @@ export declare type TableColumn = TextColumn | NumberColumn | FlagColumn | Choic
  */
 export declare type TableDirection = 'ascending' | 'descending';
 
-/** An error raised by the table domain. */
+/** Represents an error raised by the table domain. */
 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 +943,7 @@ export declare class TableError extends Error {
 }
 
 /**
- * The machine-readable code a table error carries.
+ * Names the machine-readable code a table error carries.
  *
  * @remarks
  * `SCHEMA` rejects a malformed schema, including a `key` naming no declared column. `COLUMN`
@@ -1111,7 +954,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.
  *
  * @remarks
  * Every event fires after the state it reports is committed, and only when something actually
@@ -1141,7 +984,7 @@ export declare type TableEventMap = {
 };
 
 /**
- * Any filter a table can hold.
+ * Represents any filter a table can hold.
  *
  * @remarks
  * The union discriminates on `operator`, so each operator carries only the operands it uses and a
@@ -1158,15 +1001,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,35 +1021,35 @@ 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.
      *
      * @remarks
      * Every row goes, and sort, filter, selection, expansion, and the page all reset. The table
@@ -1214,7 +1057,7 @@ export declare interface TableInterface {
      */
     clear(): void;
     /**
-     * Tear the table down.
+     * Tears the table down.
      *
      * @remarks
      * Calling it twice does what calling it once did. Afterwards every write throws a
@@ -1225,7 +1068,7 @@ export declare interface TableInterface {
 }
 
 /**
- * A row's identity.
+ * Represents a row's identity.
  *
  * @remarks
  * Every row carries its own identity in the cell named by {@link TableSchema.key}, as a non-empty
@@ -1240,9 +1083,8 @@ export declare interface TableInterface {
 export declare type TableKey = string;
 
 /**
- * How to open a table.
+ * Describes how to open a table.
  *
- * @param options - The table's settings.
  * @remarks
  * `on` wires listeners at construction and `error` receives any throw from one of them.
  *
@@ -1275,7 +1117,7 @@ export declare interface TableOptions {
 }
 
 /**
- * One column's place in the sort.
+ * Represents one column's place in the sort.
  *
  * @remarks
  * The order list is read left to right: the first term decides, and each later term breaks the
@@ -1292,7 +1134,7 @@ export declare interface TableOrder {
 }
 
 /**
- * One row, keyed by column.
+ * Represents one row, keyed by column.
  *
  * @remarks
  * A row declares a cell for the columns it carries and omits the rest. It carries no key the
@@ -1307,7 +1149,7 @@ 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.
  *
  * @remarks
  * The schema is data. It carries no function, so all of it crosses a wire and nothing is dropped
@@ -1342,10 +1184,23 @@ 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, held against one declared column.
+ *
+ * @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, which is how sorting and filtering share one
+ * list engine while keeping their own operands.
+ */
+export declare interface TableTerm {
+    readonly column: string;
+}
+
+/** Names the maximum total length, in UTF-16 code units, of every string one schema retains. */
 export declare const TEXT_LIMIT = 1048576;
 
-/** A column of text, compared lexically. */
+/** Represents a column of text, compared lexically. */
 export declare interface TextColumn extends ColumnBase {
     readonly cell: 'text';
 }