@elaraai/east-ui 1.0.74 → 1.0.76

package/dist/src/collections/sheet/types.js

@@ -0,0 +1,744 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `Sheet` IR — the UIComponent-free types of the planning spreadsheet
+ * (`libs/east-ui/docs/proposals/Sheet Spec.md` §4).
+ *
+ * A sheet's rows are the host's structs, projected by the factory into a
+ * CLOSED wire row — an id, an `owned` flag and one cell per declared column
+ * — through the columns' reified accessors (the Table `valueFn` move, the
+ * Plan `derive` move). The host's row type `R` and the driver's row type `D`
+ * never appear here: everything the author writes over them is bridged by
+ * the factory into the closed context / cell / edit types below (§4.8), so
+ * the `Sheet` arm of `UIComponentType` references {@link SheetRootType}
+ * directly, like `Calendar` and `Blend`.
+ *
+ * This file holds only plain data and closed function types — no
+ * `UIComponentType` — so `component.ts` imports it without a cycle. The
+ * author-facing TYPED constructors (`Sheet.Types.Context(R, D)`, `Fill(T)`,
+ * `Patch(R)`, `Proposal(R)`, `Edit(R)`, `CheckContext(R)`) live here too:
+ * they are type-level twins of the wire types, instantiated per row type
+ * (the `Plan.Types.Series(R)` pattern).
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, AsyncFunctionType, BooleanType, DateTimeType, DictType, EastTypeType, FloatType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, } from "@elaraai/east";
+import { StatusValueType } from "../../feedback/status/types.js";
+import { TickFormatType } from "../../format/types.js";
+import { DensityType } from "../../style/interaction.js";
+import { RowSourceType } from "../../contracts/source.js";
+import { SliceChromeType, SliceStateType } from "../../platform/slice/index.js";
+// ============================================================================
+// Links — members, the typed link value, the cell
+// ============================================================================
+/**
+ * One member of a link half — what the link grammar resolves a token to
+ * (B§4.1).
+ *
+ * @remarks
+ * A member is never a bare string the host has to re-parse: a code that
+ * resolved against the register is `identified`, a `M2140-45` span is a
+ * `range` the register expands, a `4 × CNC lathe` count is `counted`, `TBC` is
+ * the dashed `placeholder`, and anything the grammar did not recognise is
+ * kept verbatim as `text` — typed entry is never blocked.
+ *
+ * @property identified - A register code (`"M2140"`)
+ * @property range - A span of codes, `from` to `to` (`"M2140-45"`, the upper bound completed)
+ * @property counted - A count of a countable member (`{ n: 4, key: "CNC lathe" }`)
+ * @property placeholder - The `TBC` placeholder
+ * @property text - Free text the grammar kept as typed
+ */
+export const SheetMemberType = VariantType({
+    identified: StructType({ key: StringType }),
+    range: StructType({ from: StringType, to: StringType }),
+    counted: StructType({ n: IntegerType, key: StringType }),
+    placeholder: NullType,
+    text: StringType,
+});
+/**
+ * The typed link value — a directed hyperedge between two sets of members
+ * (B§4).
+ *
+ * @remarks
+ * A destination-only link is `from: []`; a source-only link is `to: []`, so
+ * the single-set data of B§4.2 needs no migration. The renderer's grammar is
+ * the kind's parse / print pair (`Sheet.link.parse` / `Sheet.link.print`).
+ *
+ * @property from - The source members
+ * @property to - The destination members
+ */
+export const SheetLinkType = StructType({
+    from: ArrayType(SheetMemberType),
+    to: ArrayType(SheetMemberType),
+});
+/**
+ * One cell of the wire row — the Table's literal cell (#206) plus the
+ * typed link.
+ *
+ * @remarks
+ * `Null` is the blank cell. A scalar column's cell is the field's value at
+ * the column kind's primitive; a `set` / `link` column's cell is a
+ * {@link SheetLinkType} value, never a string.
+ *
+ * @property Null - The blank cell
+ * @property Boolean - A boolean value
+ * @property Integer - An integer value
+ * @property Float - A float value (a `quantity` column's cell)
+ * @property String - A string value (text · lookup · reference · enum · stamped)
+ * @property DateTime - A UTC-midnight date (a `date` column's cell)
+ * @property Link - A typed link (a `set` / `link` column's cell)
+ */
+export const SheetCellType = VariantType({
+    Null: NullType,
+    Boolean: BooleanType,
+    Integer: IntegerType,
+    Float: FloatType,
+    String: StringType,
+    DateTime: DateTimeType,
+    Link: SheetLinkType,
+});
+/**
+ * One wire row — the closed projection of a host row.
+ *
+ * @remarks
+ * `cells` carries one entry per DECLARED column, always present (a blank
+ * cell is `Null`); a field of the host's row with no column never crosses
+ * the wire — the bridge (§4.8) reads it off the real row instead. Blank
+ * padding rows are renderer state, never rows.
+ *
+ * @property id - The row identity (the `id` field, or a keyed source's key)
+ * @property owned - `true` ⇒ the row belongs to the upstream system: no copilot, stamped columns read-only
+ * @property cells - Column key → cell, one entry per declared column
+ */
+export const SheetRowType = StructType({
+    id: StringType,
+    owned: BooleanType,
+    cells: DictType(StringType, SheetCellType),
+});
+/**
+ * The sheet's own row COLLECTION — wire rows in sheet order.
+ *
+ * @remarks
+ * The Sheet is POSITIONAL like the Table: the planner's order is the source's
+ * order, so the collection is an `Array` (a `Dict` inline is refused at
+ * build time — a sorted map would sit rows in key order).
+ */
+export const SheetRowsCollectionType = ArrayType(SheetRowType);
+/**
+ * How a sheet's rows arrive — inline, or a window at a time — the shared
+ * row-source contract (#567 / #576) at the sheet's row collection.
+ */
+export const SheetRowsType = RowSourceType(SheetRowsCollectionType);
+// ============================================================================
+// Registers and the driver
+// ============================================================================
+/**
+ * One register member — the grammar's vocabulary, and nothing else.
+ *
+ * @remarks
+ * There is no attribute bag: what a declaration needs from a driver row
+ * (`uom`, `sides`) is read by an accessor at build time and stored per driver
+ * key on the column that needs it ({@link SheetColumnKindType}); what a
+ * provider needs (`ctx.driver`) is the typed row, looked up by the bridge.
+ *
+ * @property key - What the grammar resolves (`"M2140"`, `"Line 2"`, `"CNC lathe"`)
+ * @property label - What a chip prints
+ * @property kind - The member kind (`"machine"` · `"line"` · `"family"` · `"activity"` · …)
+ * @property aliases - Alternative spellings the grammar also resolves (`"the 2 line"`)
+ * @property meta - Chip meta, shown when a half holds one chip (`"CNC lathe"`, `"line · 96"`)
+ * @property parent - A member's parent key — countable → identified resolution and "enumerate"
+ * @property tone - An `enum` member's valence dot
+ */
+export const SheetRegisterMemberType = StructType({
+    key: StringType,
+    label: StringType,
+    kind: StringType,
+    aliases: ArrayType(StringType),
+    meta: OptionType(StringType),
+    parent: OptionType(StringType),
+    tone: OptionType(StatusValueType),
+});
+/**
+ * One register — a list of members a column resolves against.
+ *
+ * @property members - The members, in declaration order
+ */
+export const SheetRegisterType = StructType({
+    members: ArrayType(SheetRegisterMemberType),
+});
+/**
+ * The driver — the `lookup` column whose member decides what the row does
+ * (B§1), with its members.
+ *
+ * @property column - The driver column's key
+ * @property members - The driver's register members
+ */
+export const SheetDriverType = StructType({
+    column: StringType,
+    members: ArrayType(SheetRegisterMemberType),
+});
+// ============================================================================
+// Link-column vocabulary — halves, sides, locks, counted members
+// ============================================================================
+/**
+ * One half of a link.
+ *
+ * @property from - The source half
+ * @property to - The destination half
+ */
+export const SheetHalfType = VariantType({ from: NullType, to: NullType });
+/**
+ * Which halves of a link column a driver member makes live (B§4.2) —
+ * `Sheet.Types.Sides`, the type a driver row's `sides` field carries.
+ *
+ * @property both - Both halves live
+ * @property from - Only the source half
+ * @property to - Only the destination half
+ * @property in - In place: the minus glyph, neither half moves anything
+ */
+export const SheetSidesValueType = VariantType({ both: NullType, from: NullType, to: NullType, in: NullType });
+/**
+ * How a `String`-backed link column writes its commit back (B§4.2).
+ *
+ * @property asTyped - The planner's text, verbatim
+ * @property canonical - Rewritten to register labels (evaluated by the renderer)
+ */
+export const SheetStoreType = VariantType({ asTyped: NullType, canonical: NullType });
+/**
+ * One member kind a link column accepts, and how (B§4.1).
+ *
+ * @property kind - The register member kind (`"machine"`, `"line"`, `"family"`, `"range"`)
+ * @property identified - The kind resolves by code (bare digits try the code prefix)
+ * @property countable - The kind takes the counted form (`N x kind`)
+ * @property resolvesTo - What a counted member of this kind resolves to later (`"machine"`)
+ */
+export const SheetMemberKindType = StructType({
+    kind: StringType,
+    identified: BooleanType,
+    countable: BooleanType,
+    resolvesTo: OptionType(StringType),
+});
+/**
+ * The counted-member grammar a link column declares (B§4.1).
+ *
+ * @property forms - The accepted forms (`"N x kind"`, `"kind x N"`)
+ * @property ops - The multiplication tokens (`"x"`, `"X"`, `"*"`, `"×"`)
+ * @property appliesTo - Which member kinds may be counted (`"countable"`)
+ */
+export const SheetMultipleType = StructType({
+    forms: ArrayType(StringType),
+    ops: ArrayType(StringType),
+    appliesTo: StringType,
+});
+/**
+ * One lock rule — the tag a half shows when the driver's sides value makes
+ * it read-only (B§4.2).
+ *
+ * @property half - The locked half
+ * @property when - The driver's sides value that locks it
+ * @property label - The lock tag text (`"external"`, `"in place"`)
+ */
+export const SheetSideLockType = StructType({
+    half: SheetHalfType,
+    when: SheetSidesValueType,
+    label: StringType,
+});
+/**
+ * A link column's sides declaration — the driver's `sides` accessor APPLIED
+ * over the driver data, plus the lock rules.
+ *
+ * @remarks
+ * The accessor itself never reaches the wire: the builder reifies it against
+ * the driver's row type and the root evaluates it once per driver member, so
+ * the renderer looks a row's sides up by its driver key.
+ *
+ * @property byDriver - Driver member key → the sides value
+ * @property locks - The lock rules
+ */
+export const SheetSidesType = StructType({
+    byDriver: DictType(StringType, SheetSidesValueType),
+    locks: ArrayType(SheetSideLockType),
+});
+/**
+ * A count of a countable member — the `n × CNC lathe` form (B§4.5) —
+ * `Sheet.Types.Counted`, what an arity rule proposes.
+ *
+ * @property n - The count
+ * @property key - The countable member's key
+ */
+export const SheetCountedType = StructType({ n: IntegerType, key: StringType });
+// ============================================================================
+// The copilot — the WIRE context, fills, proposals, providers
+// ============================================================================
+/**
+ * The WIRE copilot context — what the renderer hands a bridged provider.
+ *
+ * @remarks
+ * The bridge (§4.8) rebuilds the author's typed context from it: `row` is
+ * decoded over the REAL source row (`rowById(rowId, offset)`), every entry of
+ * `rows` over its own (`rowsOffset + index`), and `driver` through the
+ * driver lookup — so a field of the host's row that has no column keeps its
+ * value in every provider, check, edit event and patch.
+ *
+ * @property rowIndex - Sheet position among REAL (resident) rows
+ * @property rowId - The row's id — the source lookup's argument
+ * @property offset - The row's source offset — the paged arm's `page` lookup
+ * @property row - The row as it would be if the open editor committed
+ * @property rows - The resident sheet, real rows in sheet order
+ * @property rowsOffset - The source offset of `rows[0]` (`0` on the inline arm)
+ * @property partial - `true` on a paged sheet whose source is not exhausted
+ * @property driver - The resolved driver member's key
+ * @property today - UTC midnight — so providers stay pure
+ */
+export const SheetContextType = StructType({
+    rowIndex: IntegerType,
+    rowId: StringType,
+    offset: IntegerType,
+    row: DictType(StringType, SheetCellType),
+    rows: ArrayType(SheetRowType),
+    rowsOffset: IntegerType,
+    partial: BooleanType,
+    driver: OptionType(StringType),
+    today: DateTimeType,
+});
+/**
+ * The WIRE fill — one proposed cell value with its provenance (B§5.1).
+ *
+ * @property value - The proposed cell
+ * @property meta - The provenance line the strip prints
+ */
+export const SheetFillType = StructType({ value: SheetCellType, meta: StringType });
+/**
+ * The WIRE proposal — one proposed row as the cells a patch set, with its
+ * provenance (B§5.2).
+ *
+ * @property cells - The set fields, encoded; a field the patch left `none` is absent
+ * @property meta - The provenance line
+ */
+export const SheetProposalType = StructType({ cells: DictType(StringType, SheetCellType), meta: StringType });
+/**
+ * One fill provider on the wire — synchronous, or asynchronous (a model
+ * call). The factory picks the arm from the author's function value's East
+ * type and bridges it (§4.8).
+ *
+ * @property sync - Runs inline within the kind's latency
+ * @property async - The strip shows a pending chip; the result lands reactively, latest wins
+ */
+export const SheetProviderType = VariantType({
+    sync: FunctionType([SheetContextType], OptionType(SheetFillType)),
+    async: AsyncFunctionType([SheetContextType], OptionType(SheetFillType)),
+});
+/**
+ * One row proposer on the wire — synchronous, or asynchronous.
+ *
+ * @property sync - Runs inline
+ * @property async - Pending chip; latest wins
+ */
+export const SheetProposerType = VariantType({
+    sync: FunctionType([SheetContextType], ArrayType(SheetProposalType)),
+    async: AsyncFunctionType([SheetContextType], ArrayType(SheetProposalType)),
+});
+/**
+ * The copilot's row-proposal declaration (B§5.2).
+ *
+ * @property ahead - At most this many proposed rows below the anchor
+ * @property triggers - Column keys whose commit re-asks the proposers
+ * @property ghost - Draw proposed rows as hatched ghosts (the default)
+ * @property propose - The proposers, first that returns rows wins
+ */
+export const SheetSuggestType = StructType({
+    ahead: IntegerType,
+    triggers: ArrayType(StringType),
+    ghost: BooleanType,
+    propose: ArrayType(SheetProposerType),
+});
+// ============================================================================
+// Checks and arity — the WIRE check context
+// ============================================================================
+/**
+ * The WIRE check context — what a bridged member check receives (B§2).
+ *
+ * @property rowIndex - Sheet position among real rows
+ * @property rowId - The row's id (the source lookup's argument)
+ * @property offset - The row's source offset
+ * @property row - The row as it would be if the editor committed
+ * @property half - The half being edited
+ * @property member - The resolved member under check
+ */
+export const SheetCheckContextType = StructType({
+    rowIndex: IntegerType,
+    rowId: StringType,
+    offset: IntegerType,
+    row: DictType(StringType, SheetCellType),
+    half: SheetHalfType,
+    member: SheetMemberType,
+});
+/**
+ * One member check on a link column.
+ *
+ * @property exists - The grammar's own: the member must resolve in the register
+ * @property custom - An author rule — `some(message)` flags the member, `none` passes
+ */
+export const SheetCheckType = VariantType({
+    exists: NullType,
+    custom: FunctionType([SheetCheckContextType], OptionType(StringType)),
+});
+/**
+ * A link column's arity rule — how many members a half should hold, and
+ * which countable member to propose when none are named (B§4.6).
+ *
+ * @property half - The half the rule counts
+ * @property implied - The bridged rule over the wire context
+ */
+export const SheetArityType = StructType({
+    half: SheetHalfType,
+    implied: FunctionType([SheetContextType], OptionType(SheetCountedType)),
+});
+// ============================================================================
+// Column kinds
+// ============================================================================
+/**
+ * The column kind — what a column parses, displays and proposes (§3.2).
+ *
+ * @remarks
+ * Every function stored here takes the CLOSED context / cell types; the
+ * author's typed functions are bridged into them by the factory. The
+ * accessors that read the driver's row (`uom`, `sides.value`) are not stored
+ * at all — the builder reifies them against the driver's row type, the root
+ * applies them over the driver data, and they land as dictionaries keyed by
+ * the driver member's key.
+ *
+ * @property text - Free text
+ * @property date - A UTC-midnight date; `base` names the column relative entry counts from, `format` a display pattern
+ * @property quantity - A float with a unit per driver member (`uom`) and a display format
+ * @property integer - A whole number
+ * @property lookup - A scored register lookup — the driver column names the driver's register
+ * @property reference - A lookup over a flat member list
+ * @property enum - An upper-cased register word with a valence dot
+ * @property set - Comma members, the link grammar without an arrow
+ * @property link - `from > to` — the split cell (§3.4)
+ * @property stamped - A read-only code an upstream system owns
+ * @property custom - An author parse / print pair over the field's own payload
+ */
+export const SheetColumnKindType = VariantType({
+    text: NullType,
+    date: StructType({ base: OptionType(StringType), format: OptionType(StringType) }),
+    quantity: StructType({ uom: OptionType(DictType(StringType, StringType)), format: OptionType(TickFormatType) }),
+    integer: NullType,
+    lookup: StructType({ register: StringType }),
+    reference: StructType({ register: StringType }),
+    enum: StructType({ register: StringType }),
+    set: StructType({
+        register: StringType,
+        members: ArrayType(SheetMemberKindType),
+        multiple: OptionType(SheetMultipleType),
+        store: SheetStoreType,
+    }),
+    link: StructType({
+        register: StringType,
+        members: ArrayType(SheetMemberKindType),
+        multiple: OptionType(SheetMultipleType),
+        sides: OptionType(SheetSidesType),
+        arity: OptionType(SheetArityType),
+        check: ArrayType(SheetCheckType),
+        store: SheetStoreType,
+    }),
+    stamped: StructType({ owner: OptionType(StringType) }),
+    custom: StructType({
+        accepts: StringType,
+        parse: FunctionType([StringType, SheetContextType], OptionType(SheetCellType)),
+        print: FunctionType([SheetCellType], StringType),
+    }),
+});
+/**
+ * One declared column.
+ *
+ * @remarks
+ * `dataType` is the row field's static type and `payloadType` the kind's
+ * payload (a custom kind's primitive), both as type values, so the renderer
+ * parses and prints without the host types (the Table `dataType` / `valueType`
+ * precedent). `editable` is `false` for a stamped column, a `value`-projected
+ * column, or by option.
+ *
+ * @property key - The column key — the row field it sits on
+ * @property header - The header line
+ * @property sub - The grey second header line
+ * @property width - CSS width
+ * @property kind - The column kind
+ * @property dataType - The row field's static type
+ * @property payloadType - The kind's payload type
+ * @property editable - Whether the sheet writes the column
+ * @property fill - The fill providers; the first that yields wins
+ */
+export const SheetColumnType = StructType({
+    key: StringType,
+    header: StringType,
+    sub: OptionType(StringType),
+    width: OptionType(StringType),
+    kind: SheetColumnKindType,
+    dataType: EastTypeType,
+    payloadType: EastTypeType,
+    editable: BooleanType,
+    fill: ArrayType(SheetProviderType),
+});
+// ============================================================================
+// Views, edits, selection, footer, style
+// ============================================================================
+/**
+ * One saved view — a slice-state snapshot plus the lens's context and reveals
+ * (B§8), evaluated live.
+ *
+ * @property id - Stable identity
+ * @property name - The tab name
+ * @property narrowing - The slice state the view was made with
+ * @property context - The lens's band width (`0` · `1` · `3`)
+ * @property reveals - Revealed row indices
+ */
+export const SheetViewType = StructType({
+    id: StringType,
+    name: StringType,
+    narrowing: SliceStateType,
+    context: IntegerType,
+    reveals: ArrayType(IntegerType),
+});
+/**
+ * Where an edit came from — provenance a host can measure copilot uptake by (B§1).
+ *
+ * @property typed - The planner typed it
+ * @property pasted - A paste
+ * @property fill - A copilot fill was taken
+ * @property row - A row fill (⌘⏎)
+ * @property pattern - A proposed row was taken
+ */
+export const SheetSourceType = VariantType({
+    typed: NullType,
+    pasted: NullType,
+    fill: NullType,
+    row: NullType,
+    pattern: NullType,
+});
+/**
+ * The WIRE edit event — a raw commit / insert / remove carrying the wire row
+ * (§3.7). The author sees the typed twin, `Sheet.Types.Edit(R)`, through the
+ * bridge.
+ *
+ * @property commit - One cell committed: the row AFTER the commit, and its source offset
+ * @property insert - A row appended after `afterRowId` (`none` ⇒ at the end)
+ * @property remove - Rows removed by id
+ */
+export const SheetEditType = VariantType({
+    commit: StructType({ rowId: StringType, offset: IntegerType, key: StringType, row: SheetRowType, source: SheetSourceType }),
+    insert: StructType({ afterRowId: OptionType(StringType), row: SheetRowType, source: SheetSourceType }),
+    remove: StructType({ rowIds: ArrayType(StringType) }),
+});
+/**
+ * The selection ring's position — `Sheet.Types.Selection`.
+ *
+ * @property rowId - The selected row (`none` ⇒ a blank padding row or nothing)
+ * @property key - The selected column
+ */
+export const SheetSelectionType = StructType({
+    rowId: OptionType(StringType),
+    key: OptionType(StringType),
+});
+/**
+ * One footer item (B§9).
+ *
+ * @property text - The footer text
+ * @property tone - Optional status tint
+ */
+export const SheetFooterItemType = StructType({
+    text: StringType,
+    tone: OptionType(StatusValueType),
+});
+/**
+ * The Sheet style — uniform sizing (#320) and the gutter width.
+ *
+ * @property height - Definite height (`"fill"` fills the parent); the rows scroll within
+ * @property maxHeight - Max-height cap; content-sized up to it, then scrolls
+ * @property gutterWidth - The row-number gutter width, a CSS px size
+ */
+export const SheetStyleType = StructType({
+    height: OptionType(StringType),
+    maxHeight: OptionType(StringType),
+    gutterWidth: OptionType(StringType),
+});
+// ============================================================================
+// Root
+// ============================================================================
+/**
+ * The Sheet root IR — the whole planning spreadsheet, a CLOSED struct the
+ * `Sheet` arm of `UIComponentType` references directly.
+ *
+ * @remarks
+ * `onUpdate` never reaches the wire: the factory compiles it into `onEdit`
+ * (§4.7), and a typed `onEdit` is bridged into the same closed function
+ * (§4.8). `selection` present makes the selection controlled (§3.14).
+ *
+ * @property rows - The row source: inline wire rows, or a paged source of them
+ * @property columns - The declared columns, in order
+ * @property registers - Register name → register
+ * @property driver - The driver column and its members
+ * @property suggest - The row-proposal declaration
+ * @property slice - The slice chrome (search / filter / cohort); the lens reads the bound state
+ * @property views - The saved views
+ * @property activeView - The active view's id
+ * @property onViewsChange - Views changed (snapshot, rename, reorder, close)
+ * @property onEdit - The raw edit channel (`onUpdate` compiles to it)
+ * @property onSelect - The ring moved
+ * @property selection - Controlled selection when `some`
+ * @property newRowId - Overrides the renderer's id minting for inserted rows
+ * @property readOnly - The whole sheet is read-only
+ * @property blanks - Padding rows below the last real one (default 18)
+ * @property density - Row rhythm
+ * @property footer - Footer items
+ * @property style - Sizing and the gutter width
+ */
+export const SheetRootType = StructType({
+    rows: SheetRowsType,
+    columns: ArrayType(SheetColumnType),
+    registers: DictType(StringType, SheetRegisterType),
+    driver: OptionType(SheetDriverType),
+    suggest: OptionType(SheetSuggestType),
+    slice: OptionType(SliceChromeType),
+    views: ArrayType(SheetViewType),
+    activeView: OptionType(StringType),
+    onViewsChange: OptionType(FunctionType([ArrayType(SheetViewType)], NullType)),
+    onEdit: OptionType(FunctionType([SheetEditType], NullType)),
+    onSelect: OptionType(FunctionType([SheetSelectionType], NullType)),
+    selection: OptionType(SheetSelectionType),
+    newRowId: OptionType(FunctionType([], StringType)),
+    readOnly: OptionType(BooleanType),
+    blanks: OptionType(IntegerType),
+    density: OptionType(DensityType),
+    footer: ArrayType(SheetFooterItemType),
+    style: OptionType(SheetStyleType),
+});
+// ============================================================================
+// The TYPED constructors — the author's side (the `Plan.Types.Series(R)` pattern)
+// ============================================================================
+/**
+ * `Sheet.Types.Context(R, D)` — the copilot context as the author sees it:
+ * the host's row, the resident rows and the driver's row, all typed.
+ *
+ * @remarks
+ * A constructor rather than a generic wire type, so the row type lives
+ * structurally in a provider's signature: a provider written for one sheet
+ * is a compile error on another. Omit `D` on a sheet without a driver —
+ * `driver` is then `Option<Null>`, always `none`.
+ *
+ * @typeParam R - The host's row type
+ * @typeParam D - The driver's row type
+ * @param rowType - The row type value
+ * @param driverType - The driver's row type value (default `NullType`)
+ * @returns The concrete context `StructType`
+ *
+ * @property rowIndex - Sheet position among REAL (resident) rows
+ * @property row - The row as it would be if the open editor committed — the host's struct
+ * @property rows - The resident sheet, real rows in sheet order
+ * @property partial - `true` on a paged sheet whose source is not exhausted
+ * @property driver - The driver's row for `row` — typed, no attribute bag
+ * @property today - UTC midnight — so providers stay pure
+ */
+export function SheetContextTypeFor(rowType, driverType) {
+    return StructType({
+        rowIndex: IntegerType,
+        row: rowType,
+        rows: ArrayType(rowType),
+        partial: BooleanType,
+        driver: OptionType((driverType ?? NullType)),
+        today: DateTimeType,
+    });
+}
+/**
+ * `Sheet.Types.Fill(T)` — one proposed value of a column's payload with its
+ * provenance, as a provider returns it.
+ *
+ * @typeParam T - The column kind's payload type (§3.2)
+ * @param payloadType - The payload type value
+ * @returns The concrete fill `StructType`
+ *
+ * @property value - The proposed value
+ * @property meta - The provenance line the strip prints
+ */
+export function SheetFillTypeFor(payloadType) {
+    return StructType({ value: payloadType, meta: StringType });
+}
+/**
+ * `Sheet.Types.Patch(R)` — a row patch: every field of `R` as an `Option`,
+ * `none` meaning "left blank".
+ *
+ * @remarks
+ * Built with `Sheet.patch(R, { … })`, which takes the literal-record form of
+ * `R`'s fields and fills the omitted ones with `none`. The runner encodes the
+ * set fields that have editable columns; a set field with no column, a
+ * stamped column or a `value`-projected column is ignored.
+ *
+ * @typeParam R - The host's row type
+ * @param rowType - The row type value
+ * @returns The concrete patch `StructType`
+ */
+export function SheetPatchTypeFor(rowType) {
+    const fields = {};
+    for (const [name, type] of Object.entries(rowType.fields)) {
+        fields[name] = OptionType(type);
+    }
+    return StructType(fields);
+}
+/**
+ * `Sheet.Types.Proposal(R)` — one proposed row: a patch plus its provenance.
+ *
+ * @typeParam R - The host's row type
+ * @param rowType - The row type value
+ * @returns The concrete proposal `StructType`
+ *
+ * @property patch - The fields the proposal sets (`Sheet.patch(R, …)`)
+ * @property meta - The provenance line
+ */
+export function SheetProposalTypeFor(rowType) {
+    return StructType({ patch: SheetPatchTypeFor(rowType), meta: StringType });
+}
+/**
+ * `Sheet.Types.Edit(R)` — the raw edit event typed over the host's row
+ * (§3.7): `commit` carries the row AFTER the commit, `insert` the new row,
+ * `remove` the ids.
+ *
+ * @typeParam R - The host's row type
+ * @param rowType - The row type value
+ * @returns The concrete edit `VariantType`
+ *
+ * @property commit - One cell committed: `{ rowId, key, row, source }`
+ * @property insert - A row inserted after `afterRowId` (`none` ⇒ at the end): `{ afterRowId, row, source }`
+ * @property remove - Rows removed: `{ rowIds }`
+ */
+export function SheetEditTypeFor(rowType) {
+    return VariantType({
+        commit: StructType({ rowId: StringType, key: StringType, row: rowType, source: SheetSourceType }),
+        insert: StructType({ afterRowId: OptionType(StringType), row: rowType, source: SheetSourceType }),
+        remove: StructType({ rowIds: ArrayType(StringType) }),
+    });
+}
+/**
+ * `Sheet.Types.CheckContext(R)` — what an author's member check sees (§3.4):
+ * the typed row, the half and the resolved member.
+ *
+ * @typeParam R - The host's row type
+ * @param rowType - The row type value
+ * @returns The concrete check-context `StructType`
+ *
+ * @property rowIndex - Sheet position among real rows
+ * @property row - The row as it would be if the editor committed
+ * @property half - The half being edited
+ * @property member - The resolved member under check
+ */
+export function SheetCheckContextTypeFor(rowType) {
+    return StructType({
+        rowIndex: IntegerType,
+        row: rowType,
+        half: SheetHalfType,
+        member: SheetMemberType,
+    });
+}
+//# sourceMappingURL=types.js.map