@lavalogic/scoria 0.37.44 → 0.37.46

package/dist/Components/Table/Types/Columns/Definitions/ColumnDef.svelte.d.ts

@@ -12,15 +12,16 @@ import type { ValidationFn } from './ValidationFn.js';
  * generics mirror those of `ColumnDef` itself:
  *
  * - `T`: the row shape.
- * - `FilterFnType` (contravariant): the value the column's `filterFn`
- *   receives at filter-evaluation time (e.g. `BoolFilterValueType` for
- *   `CheckboxDef`).
- * - `OptionsType` (covariant): the value produced by `getOptions` for
- *   select-style filtering.
+ * - `FilterFnType`: the value the column's `filterFn` receives at
+ *   filter-evaluation time (e.g. `BoolFilterValueType` for `CheckboxDef`).
+ *   This same type also parameterises `getOptions` for select-style
+ *   filtering - the audit found every factory call site passed the same
+ *   type to both the filter-fn slot and the select-options slot (or one
+ *   was just `unknown`), so they were collapsed into a single generic.
  * - `TValue`: the declared row-value type; defaults to `unknown` so
  *   non-accessor columns do not need to thread it.
  */
-export interface ColumnDefProps<T extends object, in FilterFnType, out OptionsType, TValue = unknown> {
+export interface ColumnDefProps<T extends object, in FilterFnType, TValue = unknown> {
     /** Stable column identifier. Two-arm union: either a `string & keyof T`
      *  literal (accessor-backed column) or a {@link SyntheticColumnId} brand
      *  (pseudo column with no row binding, e.g. row-selection / expand /
@@ -80,8 +81,18 @@ export interface ColumnDefProps<T extends object, in FilterFnType, out OptionsTy
     /** Determines which filter input is rendered in the filter panel. */
     filterValueType?: FilterValueType;
     /** Required when `filterValueType === 'Select'`. Returns the option set
-     *  rendered in the filter dropdown. */
-    getOptions?: () => Array<SelectOption<OptionsType>> | Promise<Array<SelectOption<OptionsType>>>;
+     *  rendered in the filter dropdown.
+     *
+     *  Returns `SelectOption<unknown>` at the base layer so the base
+     *  `ColumnDef<T, FilterFnType>` does not use `FilterFnType` in a
+     *  covariant position (which, paired with the contravariant
+     *  `filterFn` slot, would make the generic invariant and break
+     *  `Array<ColumnDef<T>>` collection-typed call sites that mix
+     *  subclasses with different `FilterFnType` bindings). `SelectDef`
+     *  and `QueryDef` redeclare this with a narrower
+     *  `SelectOption<FilterValueType>` return type via the `declare`
+     *  keyword. */
+    getOptions?: () => Array<SelectOption<unknown>> | Promise<Array<SelectOption<unknown>>>;
     /** Reads the cell value from a row. For `AccessorDef` subclasses this is
      *  required at the subclass layer. */
     accessorFn?: AccessorFn<T, TValue>;
@@ -105,17 +116,23 @@ export interface ColumnDefProps<T extends object, in FilterFnType, out OptionsTy
     reactiveDependencies?: (row: T) => ReadonlyArray<unknown>;
 }
 /**
- * `ColumnDef<T, FilterFnType, OptionsType, TValue>` is the abstract base
- * for every Table column kind. Owns identification, layout (`minSize`,
- * `width`, `resizable`), gating flags (`allowFiltering`, `allowSorting`,
+ * `ColumnDef<T, FilterFnType, TValue>` is the abstract base for every
+ * Table column kind. Owns identification, layout (`minSize`, `width`,
+ * `resizable`), gating flags (`allowFiltering`, `allowSorting`,
  * `defaultHidden`, `isEditable`), data accessors (`accessorFn`,
  * `getDisplayValue`), and filtering / sorting hooks (`filterFn`,
  * `filterValueType`, `getOptions`, `getSortingFn`).
  *
+ * The `FilterFnType` generic doubles as the select-options value type
+ * (`getOptions` returns `SelectOption<FilterFnType>[]`). The earlier
+ * four-generic shape kept the two slots separate, but every factory
+ * call site set them to the same type (or set one to `unknown`); the
+ * audit collapsed them.
+ *
  * The `TValue` generic captures the declared row-value type for
  * data-backed columns (e.g. `boolean` for `CheckboxDef`,
  * `number | string | null` for `NumberInputDef`). Defaulting to `unknown`
- * keeps every existing call site that uses three or fewer generic
+ * keeps every existing call site that uses two or fewer generic
  * arguments unchanged.
  *
  * @remarks
@@ -126,8 +143,8 @@ export interface ColumnDefProps<T extends object, in FilterFnType, out OptionsTy
  * derived state; flattening to plain `readonly` fields is a per-Def
  * optimisation tracked in the perf report.
  */
-export declare abstract class ColumnDef<T extends object, in FilterFnType = never, out OptionsType = unknown, TValue = unknown> {
-    protected constructor(props: ColumnDefProps<T, FilterFnType, OptionsType, TValue>);
+export declare abstract class ColumnDef<T extends object, in FilterFnType = never, TValue = unknown> {
+    protected constructor(props: ColumnDefProps<T, FilterFnType, TValue>);
     /** Stable column identifier. */
     readonly id: ColumnId<T>;
     /** When true, callers may log per-render debug info. */
@@ -138,6 +155,18 @@ export declare abstract class ColumnDef<T extends object, in FilterFnType = neve
     set index(v: MemoryColumnIndex);
     /** Discriminator literal narrowed by each subclass. */
     abstract readonly columnType: ColumnType;
+    /**
+     * Public-API kind discriminator (`'text'`, `'number'`, `'display'`, ...).
+     * Assigned by `ColumnFactory.makeSpec` immediately after construction
+     * so the registry-driven filter wiring in
+     * `TableContext.setupDefaultColumnDefs` can drive its lookup without an
+     * `instanceof` cascade.
+     *
+     * `undefined` only when a `ColumnDef` is constructed outside the
+     * factory (storybook stubs, tests); the cascade fallback in
+     * `setupDefaultColumnDefs` covers that case.
+     */
+    kind: import('../../Public/ColumnSpec.js').ColumnKind | undefined;
     /** Whether the column is hidden by default. */
     readonly defaultHidden: boolean;
     /** Whether the column may be sorted. */
@@ -227,8 +256,12 @@ export declare abstract class ColumnDef<T extends object, in FilterFnType = neve
     readonly resizable: boolean;
     /** Header content; string or Snippet. */
     readonly header: string | Snippet;
-    /** Options provider for select-style filter inputs. */
-    readonly getOptions?: () => Array<SelectOption<OptionsType>> | Promise<Array<SelectOption<OptionsType>>>;
+    /** Options provider for select-style filter inputs. Typed as
+     *  `SelectOption<unknown>` at the base; `SelectDef` and `QueryDef`
+     *  redeclare with a narrower `SelectOption<FilterValueType>` return
+     *  type. See the field doc on `ColumnDefProps.getOptions` for why
+     *  this is decoupled from `FilterFnType` at the base layer. */
+    readonly getOptions?: () => Array<SelectOption<unknown>> | Promise<Array<SelectOption<unknown>>>;
     /** Optional grouping label for this column's filter row in the
      *  advanced filter panel. Columns sharing the same `filterGroup`
      *  string render under a single collapsible section in

package/dist/Components/Table/Types/Columns/Definitions/ColumnDef.svelte.js

@@ -1,16 +1,22 @@
 import { ColumnType } from '../ColumnType.js';
 /**
- * `ColumnDef<T, FilterFnType, OptionsType, TValue>` is the abstract base
- * for every Table column kind. Owns identification, layout (`minSize`,
- * `width`, `resizable`), gating flags (`allowFiltering`, `allowSorting`,
+ * `ColumnDef<T, FilterFnType, TValue>` is the abstract base for every
+ * Table column kind. Owns identification, layout (`minSize`, `width`,
+ * `resizable`), gating flags (`allowFiltering`, `allowSorting`,
  * `defaultHidden`, `isEditable`), data accessors (`accessorFn`,
  * `getDisplayValue`), and filtering / sorting hooks (`filterFn`,
  * `filterValueType`, `getOptions`, `getSortingFn`).
  *
+ * The `FilterFnType` generic doubles as the select-options value type
+ * (`getOptions` returns `SelectOption<FilterFnType>[]`). The earlier
+ * four-generic shape kept the two slots separate, but every factory
+ * call site set them to the same type (or set one to `unknown`); the
+ * audit collapsed them.
+ *
  * The `TValue` generic captures the declared row-value type for
  * data-backed columns (e.g. `boolean` for `CheckboxDef`,
  * `number | string | null` for `NumberInputDef`). Defaulting to `unknown`
- * keeps every existing call site that uses three or fewer generic
+ * keeps every existing call site that uses two or fewer generic
  * arguments unchanged.
  *
  * @remarks
@@ -81,6 +87,18 @@ export class ColumnDef {
     set index(v) {
         this._index = v;
     }
+    /**
+     * Public-API kind discriminator (`'text'`, `'number'`, `'display'`, ...).
+     * Assigned by `ColumnFactory.makeSpec` immediately after construction
+     * so the registry-driven filter wiring in
+     * `TableContext.setupDefaultColumnDefs` can drive its lookup without an
+     * `instanceof` cascade.
+     *
+     * `undefined` only when a `ColumnDef` is constructed outside the
+     * factory (storybook stubs, tests); the cascade fallback in
+     * `setupDefaultColumnDefs` covers that case.
+     */
+    kind = undefined;
     /** Whether the column is hidden by default. */
     defaultHidden;
     /** Whether the column may be sorted. */
@@ -220,7 +238,11 @@ export class ColumnDef {
     resizable;
     /** Header content; string or Snippet. */
     header;
-    /** Options provider for select-style filter inputs. */
+    /** Options provider for select-style filter inputs. Typed as
+     *  `SelectOption<unknown>` at the base; `SelectDef` and `QueryDef`
+     *  redeclare with a narrower `SelectOption<FilterValueType>` return
+     *  type. See the field doc on `ColumnDefProps.getOptions` for why
+     *  this is decoupled from `FilterFnType` at the base layer. */
     getOptions;
     /** Optional grouping label for this column's filter row in the
      *  advanced filter panel. Columns sharing the same `filterGroup`

package/dist/Components/Table/Types/Columns/Definitions/Display/AbstractDisplayDef.svelte.d.ts

@@ -12,15 +12,15 @@ import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
  * `Component<DisplayModalProps<T>>` with `any` filling the events / slots
  * channels because the consumer-supplied component declares those itself.
  */
-export interface AbstractDisplayDefProps<T extends object, in FilterFnType, out FilterOptionsType> extends ColumnDefProps<T, FilterFnType, FilterOptionsType> {
+export interface AbstractDisplayDefProps<T extends object, in FilterFnType> extends ColumnDefProps<T, FilterFnType> {
     /** Optional Svelte component opened as a modal from the cell. */
     modal?: Component<DisplayModalProps<T>, any, any>;
 }
 /**
- * `AbstractDisplayDef<T, FilterValueType, FilterOptionsType>` is the
- * shared base for display-only columns (Bubble, Display, ProgressBar,
- * Validity). Each subclass pins `columnType = ColumnType.Display` and
- * further narrows the `displayType` inner discriminator.
+ * `AbstractDisplayDef<T, FilterValueType>` is the shared base for
+ * display-only columns (Bubble, Display, ProgressBar, Validity). Each
+ * subclass pins `columnType = ColumnType.Display` and further narrows
+ * the `displayType` inner discriminator.
  *
  * @remarks
  *
@@ -28,10 +28,10 @@ export interface AbstractDisplayDefProps<T extends object, in FilterFnType, out
  * `DisplayModalProps<T>` shape. The cell renderers hand it
  * `{ row: T; close: () => void }` at runtime.
  */
-export declare abstract class AbstractDisplayDef<T extends object, in FilterValueType = never, out FilterOptionsType = unknown> extends ColumnDef<T, FilterValueType, FilterOptionsType> {
+export declare abstract class AbstractDisplayDef<T extends object, in FilterValueType = never> extends ColumnDef<T, FilterValueType> {
     /** Inner discriminator literal narrowed by each leaf subclass. */
     abstract readonly displayType: DisplayType;
-    constructor(props: AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType>);
+    constructor(props: AbstractDisplayDefProps<T, FilterValueType>);
     /** Discriminator literal pinning every display column to `Display`. */
     readonly columnType: "Display";
     /** Optional Svelte component opened as a modal from the cell. */

package/dist/Components/Table/Types/Columns/Definitions/Display/AbstractDisplayDef.svelte.js

@@ -1,10 +1,10 @@
 import { ColumnType } from '../../ColumnType.js';
 import { ColumnDef } from '../ColumnDef.svelte.js';
 /**
- * `AbstractDisplayDef<T, FilterValueType, FilterOptionsType>` is the
- * shared base for display-only columns (Bubble, Display, ProgressBar,
- * Validity). Each subclass pins `columnType = ColumnType.Display` and
- * further narrows the `displayType` inner discriminator.
+ * `AbstractDisplayDef<T, FilterValueType>` is the shared base for
+ * display-only columns (Bubble, Display, ProgressBar, Validity). Each
+ * subclass pins `columnType = ColumnType.Display` and further narrows
+ * the `displayType` inner discriminator.
  *
  * @remarks
  *

package/dist/Components/Table/Types/Columns/Definitions/Display/BubbleDef.svelte.d.ts

@@ -11,7 +11,7 @@ import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisp
  * - `value` is a string today (the rendered cell text); a future
  *   tightening could thread the column's `TValue`.
  */
-export interface BubbleDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
+export interface BubbleDefProps<T extends object, in FilterValueType> extends AbstractDisplayDefProps<T, FilterValueType> {
     /** Per-bubble colour mapper. Invoked per bubble value per render. */
     getColour?: (item: T, index: number, value: string) => BubbleColour | Promise<BubbleColour | null | undefined>;
     /** Maximum number of pills shown per cell before the overflow chip
@@ -20,13 +20,13 @@ export interface BubbleDefProps<T extends object, in FilterValueType, out Filter
     maxBubbles?: number;
 }
 /**
- * `BubbleDef<T, FilterValueType, FilterOptionsType>` renders the cell
- * value as a row of coloured bubbles.
+ * `BubbleDef<T, FilterValueType>` renders the cell value as a row of
+ * coloured bubbles.
  */
-export declare class BubbleDef<T extends object, in FilterValueType = StringFilterValueType, out FilterOptionsType = unknown> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
+export declare class BubbleDef<T extends object, in FilterValueType = StringFilterValueType> extends AbstractDisplayDef<T, FilterValueType> {
     /** Inner discriminator literal. */
     readonly displayType: "Bubbles";
-    constructor(props: BubbleDefProps<T, FilterValueType, FilterOptionsType>);
+    constructor(props: BubbleDefProps<T, FilterValueType>);
     private _filterFn;
     /** Filter predicate. Reassignable. */
     get filterFn(): FilterFn<T, FilterValueType> | undefined;

package/dist/Components/Table/Types/Columns/Definitions/Display/BubbleDef.svelte.js

@@ -2,8 +2,8 @@ import { memoiseRowValueAccessor } from '../../../../../../Helpers/memoiseByRow.
 import { DisplayType } from '../../DisplayType.js';
 import { AbstractDisplayDef } from './AbstractDisplayDef.svelte.js';
 /**
- * `BubbleDef<T, FilterValueType, FilterOptionsType>` renders the cell
- * value as a row of coloured bubbles.
+ * `BubbleDef<T, FilterValueType>` renders the cell value as a row of
+ * coloured bubbles.
  */
 export class BubbleDef extends AbstractDisplayDef {
     /** Inner discriminator literal. */

package/dist/Components/Table/Types/Columns/Definitions/Display/DisplayDef.svelte.d.ts

@@ -6,16 +6,16 @@ import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisp
  * fields over `AbstractDisplayDefProps`; it exists so future
  * display-specific props can be added without a breaking-change rename.
  */
-export interface DisplayDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
+export interface DisplayDefProps<T extends object, in FilterValueType> extends AbstractDisplayDefProps<T, FilterValueType> {
 }
 /**
- * `DisplayDef<T, FilterValueType, FilterOptionsType>` renders the cell
- * value as plain text. The default display kind for non-input columns.
+ * `DisplayDef<T, FilterValueType>` renders the cell value as plain
+ * text. The default display kind for non-input columns.
  */
-export declare class DisplayDef<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
+export declare class DisplayDef<T extends object, in FilterValueType> extends AbstractDisplayDef<T, FilterValueType> {
     /** Inner discriminator literal. */
     readonly displayType: DisplayType;
-    constructor(props: DisplayDefProps<T, FilterValueType, FilterOptionsType>);
+    constructor(props: DisplayDefProps<T, FilterValueType>);
     private _filterFn;
     /** Filter predicate. Reassignable. */
     get filterFn(): FilterFn<T, FilterValueType> | undefined;

package/dist/Components/Table/Types/Columns/Definitions/Display/DisplayDef.svelte.js

@@ -1,8 +1,8 @@
 import { DisplayType } from '../../DisplayType.js';
 import { AbstractDisplayDef } from './AbstractDisplayDef.svelte.js';
 /**
- * `DisplayDef<T, FilterValueType, FilterOptionsType>` renders the cell
- * value as plain text. The default display kind for non-input columns.
+ * `DisplayDef<T, FilterValueType>` renders the cell value as plain
+ * text. The default display kind for non-input columns.
  */
 export class DisplayDef extends AbstractDisplayDef {
     /** Inner discriminator literal. */

package/dist/Components/Table/Types/Columns/Definitions/Display/ProgressBarDef.svelte.d.ts

@@ -12,18 +12,18 @@ import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisp
  * - `value: [number, number]` represents `[current, total]`; the
  *   column data shape is not yet connected to this tuple.
  */
-export interface ProgressBarDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
+export interface ProgressBarDefProps<T extends object, in FilterValueType> extends AbstractDisplayDefProps<T, FilterValueType> {
     /** Required. Per-cell colour mapper given the `[current, total]` tuple. */
     getColour: (item: T, index: number, value: [number, number]) => BubbleColour | Promise<BubbleColour> | undefined;
 }
 /**
- * `ProgressBarDef<T, FilterValueType, FilterOptionsType>` renders the
- * cell value as a horizontal progress bar.
+ * `ProgressBarDef<T, FilterValueType>` renders the cell value as a
+ * horizontal progress bar.
  */
-export declare class ProgressBarDef<T extends object, in FilterValueType = NumberFilterValueType, out FilterOptionsType = unknown> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
+export declare class ProgressBarDef<T extends object, in FilterValueType = NumberFilterValueType> extends AbstractDisplayDef<T, FilterValueType> {
     /** Inner discriminator literal. */
     readonly displayType: "Progress";
-    constructor(props: ProgressBarDefProps<T, FilterValueType, FilterOptionsType>);
+    constructor(props: ProgressBarDefProps<T, FilterValueType>);
     /** Per-cell colour mapper. */
     readonly getColour: (item: T, index: number, value: [number, number]) => BubbleColour | Promise<BubbleColour> | undefined;
     private _filterFn;

package/dist/Components/Table/Types/Columns/Definitions/Display/ProgressBarDef.svelte.js

@@ -1,8 +1,8 @@
 import { DisplayType } from '../../DisplayType.js';
 import { AbstractDisplayDef } from './AbstractDisplayDef.svelte.js';
 /**
- * `ProgressBarDef<T, FilterValueType, FilterOptionsType>` renders the
- * cell value as a horizontal progress bar.
+ * `ProgressBarDef<T, FilterValueType>` renders the cell value as a
+ * horizontal progress bar.
  */
 export class ProgressBarDef extends AbstractDisplayDef {
     /** Inner discriminator literal. */

package/dist/Components/Table/Types/Columns/Definitions/Display/ValidityDef.svelte.d.ts

@@ -5,13 +5,13 @@ import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisp
  * because the validity column has no other content; the rest of the
  * shape mirrors `AbstractDisplayDefProps`.
  */
-export interface ValidityDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
+export interface ValidityDefProps<T extends object, in FilterValueType> extends AbstractDisplayDefProps<T, FilterValueType> {
     /** Required per-row validity predicate. */
     isValid: ValidationFn<T>;
 }
 /**
- * `ValidityDef<T, FilterValueType, FilterOptionsType>` renders the row
- * validity as a status icon. Non-sortable and non-filterable.
+ * `ValidityDef<T, FilterValueType>` renders the row validity as a
+ * status icon. Non-sortable and non-filterable.
  *
  * @remarks
  *
@@ -26,10 +26,10 @@ export interface ValidityDefProps<T extends object, in FilterValueType, out Filt
  * mandatory on the subclass props) via the `declare` re-declaration
  * below. The runtime assignment happens in the base constructor.
  */
-export declare class ValidityDef<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
+export declare class ValidityDef<T extends object, in FilterValueType> extends AbstractDisplayDef<T, FilterValueType> {
     /** Inner discriminator literal. */
     readonly displayType: "Validity";
-    constructor(props: ValidityDefProps<T, FilterValueType, FilterOptionsType>);
+    constructor(props: ValidityDefProps<T, FilterValueType>);
     /** Validity columns are never filtered. */
     readonly filterFn: undefined;
     /** Required per-row validity predicate (narrowed from the base optional). */

package/dist/Components/Table/Types/Columns/Definitions/Display/ValidityDef.svelte.js

@@ -1,8 +1,8 @@
 import { DisplayType } from '../../DisplayType.js';
 import { AbstractDisplayDef } from './AbstractDisplayDef.svelte.js';
 /**
- * `ValidityDef<T, FilterValueType, FilterOptionsType>` renders the row
- * validity as a status icon. Non-sortable and non-filterable.
+ * `ValidityDef<T, FilterValueType>` renders the row validity as a
+ * status icon. Non-sortable and non-filterable.
  *
  * @remarks
  *

package/dist/Components/Table/Types/Columns/Definitions/Expand/ExpandDef.svelte.d.ts

@@ -4,17 +4,13 @@ import type { Primitive, TableInitOptions } from '../../../Context/TableInitOpti
 import type { DefsWrapper } from '../../DefsWrapper.js';
 import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
 /**
- * Construction-time props for `ExpandDef`. The generic name
- * `InnerIdType` (previously `InnterIdType` - typo) parameterises the
- * inner table's row id.
+ * Construction-time props for `ExpandDef`. The generic `InnerIdType`
+ * parameterises the inner table's row id.
  *
- * Notes:
- * - `getInnerColumnDefs` and `accessorFn` are invoked per expansion;
- *   caching is the consumer's responsibility (tracked in perf workorder).
- * - The class no longer mutates the incoming `props` object before
- *   calling `super`; the override is forwarded via a spread.
+ * `getInnerColumnDefs` and `accessorFn` are invoked per expansion;
+ * caching is the consumer's responsibility.
  */
-export interface ExpandDefProps<T extends object, R extends object, InnerIdType extends Primitive = Primitive, in FilterValueType = unknown, out FilterOptionsType = unknown> extends ColumnDefProps<T, FilterValueType, FilterOptionsType> {
+export interface ExpandDefProps<T extends object, R extends object, InnerIdType extends Primitive = Primitive, in FilterValueType = unknown> extends ColumnDefProps<T, FilterValueType> {
     /** Per-row enable predicate for the expansion affordance. */
     isEnabled: (item: T, index: number) => boolean | Promise<boolean>;
     /** Builds the inner table's column defs. Invoked per expansion. */
@@ -29,19 +25,15 @@ export interface ExpandDefProps<T extends object, R extends object, InnerIdType
     accessorFn: (item: T, index: number) => ReadonlyArray<R> | Promise<ReadonlyArray<R>>;
 }
 /**
- * `ExpandDef<T, R, InnerIdType, FilterValueType, FilterOptionsType>` is
- * a column whose cells expand to reveal an inner table.
- *
- * @remarks
- *
- * Non-sortable and non-filterable; the class spreads `props` with the
- * relevant overrides when forwarding to `super(...)` rather than
- * mutating the incoming props object.
+ * `ExpandDef<T, R, InnerIdType, FilterValueType>` is a column whose
+ * cells expand to reveal an inner table. Non-sortable and
+ * non-filterable; `allowFiltering` / `allowSorting` are forced
+ * `false` when forwarding to `super`.
  */
-export declare class ExpandDef<T extends object, R extends object, InnerIdType extends Primitive = Primitive, in FilterValueType = unknown, out FilterOptionsType = unknown> extends ColumnDef<T, FilterValueType, FilterOptionsType> {
+export declare class ExpandDef<T extends object, R extends object, InnerIdType extends Primitive = Primitive, in FilterValueType = unknown> extends ColumnDef<T, FilterValueType> {
     /** Discriminator literal. */
     readonly columnType: "Expand";
-    constructor(props: ExpandDefProps<T, R, InnerIdType, FilterValueType, FilterOptionsType>);
+    constructor(props: ExpandDefProps<T, R, InnerIdType, FilterValueType>);
     /** Narrowed accessorFn: returns the inner-row array. */
     readonly accessorFn: (item: T, index: number) => ReadonlyArray<R> | Promise<ReadonlyArray<R>>;
     /** Expand columns are never filtered. */

package/dist/Components/Table/Types/Columns/Definitions/Expand/ExpandDef.svelte.js

@@ -1,14 +1,10 @@
 import { ColumnType } from '../../ColumnType.js';
 import { ColumnDef } from '../ColumnDef.svelte.js';
 /**
- * `ExpandDef<T, R, InnerIdType, FilterValueType, FilterOptionsType>` is
- * a column whose cells expand to reveal an inner table.
- *
- * @remarks
- *
- * Non-sortable and non-filterable; the class spreads `props` with the
- * relevant overrides when forwarding to `super(...)` rather than
- * mutating the incoming props object.
+ * `ExpandDef<T, R, InnerIdType, FilterValueType>` is a column whose
+ * cells expand to reveal an inner table. Non-sortable and
+ * non-filterable; `allowFiltering` / `allowSorting` are forced
+ * `false` when forwarding to `super`.
  */
 export class ExpandDef extends ColumnDef {
     /** Discriminator literal. */

package/dist/Components/Table/Types/Columns/Definitions/FilterOnly/FilterOnlyDef.svelte.d.ts

@@ -5,16 +5,15 @@ import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
  * `ColumnDefProps`; the marker exists so future filter-only-specific
  * props can be added without a breaking-change rename.
  */
-export interface FilterOnlyDefProps<T extends object, in FilterFnType = unknown, out FilterOptionsType = unknown> extends ColumnDefProps<T, FilterFnType, FilterOptionsType> {
+export interface FilterOnlyDefProps<T extends object, in FilterFnType = unknown> extends ColumnDefProps<T, FilterFnType> {
 }
 /**
- * `FilterOnlyDef<T, FilterFnType, FilterOptionsType>` is a column that
- * participates in filtering but never renders a body cell. Used to
- * surface a filter input in the filter panel without occupying a body
- * slot.
+ * `FilterOnlyDef<T, FilterFnType>` is a column that participates in
+ * filtering but never renders a body cell. Used to surface a filter
+ * input in the filter panel without occupying a body slot.
  */
-export declare class FilterOnlyDef<T extends object, in FilterFnType = unknown, out FilterOptionsType = unknown> extends ColumnDef<T, FilterFnType, FilterOptionsType> {
-    constructor(props: FilterOnlyDefProps<T, FilterFnType, FilterOptionsType>);
+export declare class FilterOnlyDef<T extends object, in FilterFnType = unknown> extends ColumnDef<T, FilterFnType> {
+    constructor(props: FilterOnlyDefProps<T, FilterFnType>);
     /** Discriminator literal. */
     readonly columnType: "Filter Only";
     private _filterFn;

package/dist/Components/Table/Types/Columns/Definitions/FilterOnly/FilterOnlyDef.svelte.js

@@ -1,10 +1,9 @@
 import { ColumnType } from '../../ColumnType.js';
 import { ColumnDef } from '../ColumnDef.svelte.js';
 /**
- * `FilterOnlyDef<T, FilterFnType, FilterOptionsType>` is a column that
- * participates in filtering but never renders a body cell. Used to
- * surface a filter input in the filter panel without occupying a body
- * slot.
+ * `FilterOnlyDef<T, FilterFnType>` is a column that participates in
+ * filtering but never renders a body cell. Used to surface a filter
+ * input in the filter panel without occupying a body slot.
  */
 export class FilterOnlyDef extends ColumnDef {
     constructor(props) {

package/dist/Components/Table/Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.d.ts

@@ -6,17 +6,17 @@ import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
  * can construct it consistently. The legacy positional signature is
  * retained as an overload for backwards compatibility.
  */
-export interface RowSelectionDefProps<T extends object, FilterValueType = BoolFilterValueType, FilterOptionsType = undefined> {
+export interface RowSelectionDefProps<T extends object, FilterValueType = BoolFilterValueType> {
     /** Per-row predicate for whether the row may be selected. */
     isSelectable: (item: T, index: number) => boolean | Promise<boolean>;
     /** Optional row validity predicate. */
-    isValid?: ColumnDefProps<T, FilterValueType, FilterOptionsType>['isValid'];
+    isValid?: ColumnDefProps<T, FilterValueType>['isValid'];
 }
 /**
- * `RowSelectionDef<T, FilterValueType, FilterOptionsType>` is the
- * checkbox column that drives row selection. Non-sortable and
- * non-filterable; the header reads `'Row Selected'` and the id is
- * generated via `generateUUID` (UUIDv7).
+ * `RowSelectionDef<T, FilterValueType>` is the checkbox column that
+ * drives row selection. Non-sortable and non-filterable; the header
+ * reads `'Row Selected'` and the id is generated via `generateUUID`
+ * (UUIDv7).
  *
  * @remarks
  *
@@ -30,12 +30,12 @@ export interface RowSelectionDefProps<T extends object, FilterValueType = BoolFi
  * The positional form was the only outlier in the Def family;
  * consumers are encouraged to migrate to the props-object form.
  */
-export declare class RowSelectionDef<T extends object, in FilterValueType = BoolFilterValueType, out FilterOptionsType = undefined> extends ColumnDef<T, FilterValueType, FilterOptionsType> {
+export declare class RowSelectionDef<T extends object, in FilterValueType = BoolFilterValueType> extends ColumnDef<T, FilterValueType> {
     /** Discriminator literal. */
     readonly columnType: "RowSelect";
     readonly isSelectable: (item: T, index: number) => boolean | Promise<boolean>;
-    constructor(props: RowSelectionDefProps<T, FilterValueType, FilterOptionsType>);
-    constructor(isSelectable: (item: T, index: number) => boolean | Promise<boolean>, isValid?: ColumnDefProps<T, FilterValueType, FilterOptionsType>['isValid']);
+    constructor(props: RowSelectionDefProps<T, FilterValueType>);
+    constructor(isSelectable: (item: T, index: number) => boolean | Promise<boolean>, isValid?: ColumnDefProps<T, FilterValueType>['isValid']);
     /** Row-selection columns are never filtered. */
     readonly filterFn: undefined;
 }

package/dist/Components/Table/Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.js

@@ -2,10 +2,10 @@ import { generateUUID, syntheticColumnId } from '../../../../../../Helpers/Helpe
 import { ColumnType } from '../../ColumnType.js';
 import { ColumnDef } from '../ColumnDef.svelte.js';
 /**
- * `RowSelectionDef<T, FilterValueType, FilterOptionsType>` is the
- * checkbox column that drives row selection. Non-sortable and
- * non-filterable; the header reads `'Row Selected'` and the id is
- * generated via `generateUUID` (UUIDv7).
+ * `RowSelectionDef<T, FilterValueType>` is the checkbox column that
+ * drives row selection. Non-sortable and non-filterable; the header
+ * reads `'Row Selected'` and the id is generated via `generateUUID`
+ * (UUIDv7).
  *
  * @remarks
  *

package/dist/Components/Table/Types/Columns/ExpandTableCell.d.ts

@@ -2,11 +2,11 @@ import type { Row } from '../Context/Row.js';
 import type { Primitive } from '../Context/TableInitOptions.js';
 import type { ExpandColumn } from './ExpandColumn.js';
 /**
- * Narrowed `TableCell<T>` for expand columns. The natural shape of
- * `getValue` would be `ReadonlyArray<R> | Promise<ReadonlyArray<R>>`
- * (the inner-table rows for this row), but the cell is currently typed
- * `unknown` for consistency with `TableCell.getValue`; tightening is deferred
- * to the parent `TableCell.getValue` workorder.
+ * Narrowed `TableCell<T>` for expand columns. `getValue`'s natural
+ * shape is `ReadonlyArray<R> | Promise<ReadonlyArray<R>>` (the
+ * inner-table rows for this row), but it stays `unknown` for
+ * consistency with `TableCell.getValue`; narrowing happens once that
+ * is tightened library-wide.
  */
 export interface ExpandTableCell<T extends object, R extends object, IdType extends Primitive, FilterValueType> {
     column: ExpandColumn<T, R, IdType, FilterValueType>;

package/dist/Components/Table/Types/Columns/ProgressBarTableCell.d.ts

@@ -3,13 +3,13 @@ import type { NumberFilterValueType } from '../Filtering/FilterFn.js';
 import type { ProgressBarColumn } from './ProgressBarColumn.js';
 import type { TableCell } from './TableCell.js';
 /**
- * Narrowed `TableCell<T>` for progress-bar columns. The natural shape of
- * `getValue` here is `[number, number] | Promise<[number, number]>`
- * (current, max); tightening is deferred to the parent `TableCell.getValue`
- * workorder so the change happens in one place.
+ * Narrowed `TableCell<T>` for progress-bar columns. The natural shape
+ * of `getValue` here is `[number, number] | Promise<[number, number]>`
+ * (current, max); narrowing happens once `TableCell.getValue` is
+ * tightened library-wide.
  *
- * Default `FilterValueType = NumberFilterValueType` reflects the fact that
- * the only sensible filter shape for a progress column is a numeric range.
+ * Default `FilterValueType = NumberFilterValueType` because the only
+ * sensible filter shape for a progress column is a numeric range.
  */
 export interface ProgressBarTableCell<T extends object, FilterValueType = NumberFilterValueType> extends TableCell<T, FilterValueType> {
     column: ProgressBarColumn<T, FilterValueType>;

package/dist/Components/Table/Types/Columns/TableCell.d.ts

@@ -1,8 +1,8 @@
 import type { Row } from '../Context/Row.js';
 import type { Column } from './Column.js';
 /**
- * `TableCell<T, FilterValueType, FilterOptionsType, TValue>` is the per-cell
- * handle exposed to body components.
+ * `TableCell<T, FilterValueType, TValue>` is the per-cell handle exposed
+ * to body components.
  *
  * The optional `TValue` generic is the declared value type for the column
  * the cell belongs to. Defaulting it to `unknown` keeps all existing call
@@ -11,11 +11,12 @@ import type { Column } from './Column.js';
  *
  * Cell hosts that know the column shape (`TableNumberInput`, `TableCheckbox`,
  * etc.) can pass a narrower `TValue` either explicitly or by reading it from
- * a `ColumnDef<T, ..., TValue>`. The intent is to let `cell.getValue()` be
- * typed instead of `unknown` without breaking any external consumer.
+ * a `ColumnDef<T, FilterValueType, TValue>`. The intent is to let
+ * `cell.getValue()` be typed instead of `unknown` without breaking any
+ * external consumer.
  */
-export interface TableCell<T extends object, in FilterValueType = never, out FilterOptionsType = unknown, TValue = unknown> {
-    column: Column<T, FilterValueType, FilterOptionsType>;
+export interface TableCell<T extends object, in FilterValueType = never, TValue = unknown> {
+    column: Column<T, FilterValueType>;
     row: Row<T>;
     id: string;
     getValue: () => TValue | Promise<TValue>;