@elaraai/east-ui 1.0.80 → 1.0.82

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

@@ -18,13 +18,16 @@
  * 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:
+ * `Patch(R)`, `Proposal(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 { ArrayType, AsyncFunctionType, BooleanType, BlobType, DateTimeType, DictType, EastTypeType, FloatType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, } from "@elaraai/east";
+import { SheetDraftTypeFor } from "./transactions.js";
+import { SheetDraftGroupTypeFor } from "./drafts.js";
+import { SheetEditingType } from "./editing-types.js";
 import { StatusValueType } from "../../feedback/status/types.js";
 import { TickFormatType } from "../../format/types.js";
 import { DensityType } from "../../style/interaction.js";
@@ -82,6 +85,7 @@ export const SheetLinkType = StructType({
  * the column kind's primitive; a `set` / `link` column's cell is a
  * {@link SheetLinkType} value, never a string.
  *
+ * @property Invalid - Unparseable draft text, retained verbatim until corrected
  * @property Null - The blank cell
  * @property Boolean - A boolean value
  * @property Integer - An integer value
@@ -91,6 +95,7 @@ export const SheetLinkType = StructType({
  * @property Link - A typed link (a `set` / `link` column's cell)
  */
 export const SheetCellType = VariantType({
+    Invalid: StringType,
     Null: NullType,
     Boolean: BooleanType,
     Integer: IntegerType,
@@ -99,6 +104,82 @@ export const SheetCellType = VariantType({
     DateTime: DateTimeType,
     Link: SheetLinkType,
 });
+/**
+ * One labelled fact of a sub row's detail (#844).
+ *
+ * @property label - What the fact is (the renderer sets it in capitals)
+ * @property value - The fact, printed
+ */
+export const SheetFacetType = StructType({
+    label: StringType,
+    value: StringType,
+});
+/**
+ * One SUB ROW on the wire (#844) — a read-only row under a line (or a flat
+ * row) that shares none of the sheet's columns: a lead (`code` and `name`),
+ * a detail (`chips`, then `facets`) and an `id` pinned right.
+ *
+ * @remarks
+ * `code` and `id` are display strings, `""` for none (the band's `sub`
+ * precedent). Build one with `Sheet.subRow({ … })`; declare where they come
+ * from with `Sheet.subRows(R, { … })`.
+ *
+ * @property code - The lead's code (`"ASM"`, or a word for what the row is); `""` for none
+ * @property name - The lead's words
+ * @property chips - The detail's parameter chips, first
+ * @property facets - The detail's labelled facts, after the chips
+ * @property id - The record the sub row traces to; `""` for none
+ */
+export const SheetSubRowType = StructType({
+    code: StringType,
+    name: StringType,
+    chips: ArrayType(StringType),
+    facets: ArrayType(SheetFacetType),
+    id: StringType,
+});
+/**
+ * One LINE of a group row on the wire (#740) — its cells, addressed within
+ * its group by `key`.
+ *
+ * @remarks
+ * A line has no id of its own: its `key` is its index in the group's lines
+ * array, printed. The line's cells are the line columns' projection, exactly
+ * a flat row's `cells`.
+ *
+ * @property key - The line's address within its group
+ * @property cells - Column key → cell, one entry per declared line column
+ * @property subRows - The line's sub rows, in declaration order (#844; empty without `subRows`)
+ */
+export const SheetLineType = StructType({
+    key: StringType,
+    cells: DictType(StringType, SheetCellType),
+    subRows: ArrayType(SheetSubRowType),
+});
+/**
+ * The band a group row draws above its lines (#740) — what the band shows
+ * beside its cells.
+ *
+ * @property sub - The eyebrow under the title (display only; `""` for none)
+ * @property folded - Whether the plan opens folded
+ */
+export const SheetBandType = StructType({
+    sub: StringType,
+    folded: BooleanType,
+});
+/** The cell key a group row's title rides under (#740) — never a line column's key. */
+export const SHEET_TITLE_CELL = "$title";
+/**
+ * The key of an UNRENDERED cell a column's rule projects into (#844) — a
+ * date column's `level` / `actual`, a column's `detail`. The `$` prefix keeps
+ * it clear of every field name, as {@link SHEET_TITLE_CELL} is.
+ *
+ * @param rule - The rule (`"level"`, `"actual"`, `"detail"`)
+ * @param column - The column key
+ * @returns The cell key (`"$level:start"`)
+ */
+export function sheetRuleCell(rule, column) {
+    return `$${rule}:${column}`;
+}
 /**
  * One wire row — the closed projection of a host row.
  *
@@ -108,14 +189,28 @@ export const SheetCellType = VariantType({
  * the wire — the bridge (§4.8) reads it off the real row instead. Blank
  * padding rows are renderer state, never rows.
  *
+ * On a GROUPED sheet (#740) a group row's `cells` hold the band's cells (the
+ * group's fields under line columns, the title under
+ * {@link SHEET_TITLE_CELL}), `lines` its lines and `band` is `some`. On a
+ * flat sheet `lines` is empty and `band` is `none` — and so on a grouped
+ * sheet with LOOSE rows between its groups (#846): a loose row is a row of
+ * the line type, its `cells` the line columns' projection, with no lines
+ * and no band.
+ *
  * @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
+ * @property lines - A group row's lines, in order (empty on a flat sheet, and for a loose row)
+ * @property band - A group row's band (`none` on a flat sheet, and for a loose row)
+ * @property subRows - A flat or loose row's sub rows (#844; empty for a group row, whose lines carry them)
  */
 export const SheetRowType = StructType({
     id: StringType,
     owned: BooleanType,
     cells: DictType(StringType, SheetCellType),
+    lines: ArrayType(SheetLineType),
+    band: OptionType(SheetBandType),
+    subRows: ArrayType(SheetSubRowType),
 });
 /**
  * The sheet's own row COLLECTION — wire rows in sheet order.
@@ -213,12 +308,14 @@ export const SheetStoreType = VariantType({ asTyped: NullType, canonical: NullTy
  * @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"`)
+ * @property ranged - Runs of consecutive identified codes are offered and printed as one range (`M2140-45`, #844)
  */
 export const SheetMemberKindType = StructType({
     kind: StringType,
     identified: BooleanType,
     countable: BooleanType,
     resolvesTo: OptionType(StringType),
+    ranged: BooleanType,
 });
 /**
  * The counted-member grammar a link column declares (B§4.1).
@@ -282,20 +379,24 @@ export const SheetCountedType = StructType({ n: IntegerType, key: StringType });
  * 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 drafts - Row id → its current draft, encoded
+ * @property rowIndex - The row's index in `rows` (a grouped sheet: a line's index within its group)
+ * @property rowId - The row's id — the source lookup's argument (a grouped sheet: a line's GROUP's id, a loose row's own)
  * @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 line - A grouped sheet: the line's address within its group; `none` on a flat sheet, and for a loose row (#846)
+ * @property row - The row as it would be if the open editor committed (a grouped sheet: the LINE's cells)
+ * @property rows - The resident sheet, real rows in sheet order (a grouped sheet: the resident GROUP rows and loose rows)
  * @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({
+    drafts: DictType(StringType, BlobType),
     rowIndex: IntegerType,
     rowId: StringType,
     offset: IntegerType,
+    line: OptionType(StringType),
     row: DictType(StringType, SheetCellType),
     rows: ArrayType(SheetRowType),
     rowsOffset: IntegerType,
@@ -303,6 +404,47 @@ export const SheetContextType = StructType({
     driver: OptionType(StringType),
     today: DateTimeType,
 });
+/**
+ * One row check of a readiness batch ({@link SheetReadyBatchType}, #882) —
+ * where its row sits among the batch's rows, and its driver.
+ * @internal
+ *
+ * @property index - The checked row's index in the batch's `rows` (a grouped sheet: a line's GROUP's)
+ * @property line - A grouped sheet: the checked line's index within its group; `none` on a flat sheet, and for a loose row (#846)
+ * @property driver - The resolved driver member's key
+ */
+export const SheetReadyCheckType = StructType({
+    index: IntegerType,
+    line: OptionType(IntegerType),
+    driver: OptionType(StringType),
+});
+/**
+ * The WIRE readiness batch (#882) — every row check of one readiness
+ * evaluation, over the rows they share.
+ * @internal
+ *
+ * @remarks
+ * The shared fields cross the wire once, and the bridge builds the typed
+ * rows from them once. A check carries only its place and its driver: its
+ * row is the draft the bridge built at that place — the row's own cells over
+ * its own draft — so nothing is substituted into the rows, as a
+ * {@link SheetContextType}'s provisional row is.
+ *
+ * @property drafts - Row id → its current draft, encoded
+ * @property rows - The rows, in sheet order (a grouped sheet: the GROUP rows)
+ * @property rowsOffset - The source offset of `rows[0]`
+ * @property partial - `true` on a paged sheet whose source is not exhausted
+ * @property today - UTC midnight — so checks stay pure
+ * @property checks - The checks; their results return in this order
+ */
+export const SheetReadyBatchType = StructType({
+    drafts: DictType(StringType, BlobType),
+    rows: ArrayType(SheetRowType),
+    rowsOffset: IntegerType,
+    partial: BooleanType,
+    today: DateTimeType,
+    checks: ArrayType(SheetReadyCheckType),
+});
 /**
  * The WIRE fill — one proposed cell value with its provenance (B§5.1).
  *
@@ -360,17 +502,23 @@ export const SheetSuggestType = StructType({
 /**
  * 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 drafts - Row id → its current draft, encoded
+ * @property group - A grouped sheet: the line's GROUP row; `none` on a flat sheet, and for a loose row (#846)
+ * @property rowIndex - Sheet position among real rows (a grouped sheet: a line's index within its group, a loose row's among the loose rows)
+ * @property rowId - The row's id (the source lookup's argument; a grouped sheet: a line's GROUP's id, a loose row's own)
  * @property offset - The row's source offset
- * @property row - The row as it would be if the editor committed
+ * @property line - A grouped sheet: the line's address within its group; `none` on a flat sheet, and for a loose row (#846)
+ * @property row - The row as it would be if the editor committed (a grouped sheet: the LINE's cells)
  * @property half - The half being edited
  * @property member - The resolved member under check
  */
 export const SheetCheckContextType = StructType({
+    drafts: DictType(StringType, BlobType),
+    group: OptionType(SheetRowType),
     rowIndex: IntegerType,
     rowId: StringType,
     offset: IntegerType,
+    line: OptionType(StringType),
     row: DictType(StringType, SheetCellType),
     half: SheetHalfType,
     member: SheetMemberType,
@@ -399,6 +547,25 @@ export const SheetArityType = StructType({
 // ============================================================================
 // Column kinds
 // ============================================================================
+/**
+ * How deep a date column reads and takes a row's date (#844) —
+ * `Sheet.Types.DateLevel`, what a date column's `level` rule returns.
+ *
+ * @remarks
+ * The cell is still one UTC instant; the level says how it is printed,
+ * typed and compared with an `actual`.
+ *
+ * @property week - The week the date falls in (printed as its Monday)
+ * @property day - The day
+ * @property range - One end of the days the work may run in
+ * @property time - The day and the time of day
+ */
+export const SheetDateLevelType = VariantType({ week: NullType, day: NullType, range: NullType, time: NullType });
+/**
+ * A column's OPTIONS rule on the wire (#844) — the register member keys a
+ * row may be offered; `none` offers the whole register.
+ */
+export const SheetOptionsRuleType = FunctionType([SheetContextType], OptionType(ArrayType(StringType)));
 /**
  * The column kind — what a column parses, displays and proposes (§3.2).
  *
@@ -410,26 +577,37 @@ export const SheetArityType = StructType({
  * applies them over the driver data, and they land as dictionaries keyed by
  * the driver member's key.
  *
+ * A date's `level` and `actual` and an `options` rule (#844) ride here too:
+ * `level` / `actual` name the unrendered cell ({@link sheetRuleCell}) the
+ * row projection filled, `options` is the bridged rule over the wire
+ * context — the renderer offers only those members, while typed text still
+ * resolves against the whole register.
+ *
  * @property text - Free text
- * @property date - A UTC-midnight date; `base` names the column relative entry counts from, `format` a display pattern
+ * @property date - A UTC-midnight date; `base` names the column relative entry counts from, `format` a display pattern, `level` the cell holding the row's {@link SheetDateLevelType} tag, `actual` the cell holding when the work really happened
  * @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 lookup - A scored register lookup — the driver column names the driver's register; `options` narrows what a row is offered
  * @property reference - A lookup over a flat member list
- * @property enum - An upper-cased register word with a valence dot
+ * @property enum - An upper-cased register word with a valence dot; `options` narrows what a row is offered
  * @property set - Comma members, the link grammar without an arrow
- * @property link - `from > to` — the split cell (§3.4)
+ * @property link - `from > to` — the split cell (§3.4); `options` narrows what a row is offered
  * @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) }),
+    date: StructType({
+        base: OptionType(StringType),
+        format: OptionType(StringType),
+        level: OptionType(StringType),
+        actual: OptionType(StringType),
+    }),
     quantity: StructType({ uom: OptionType(DictType(StringType, StringType)), format: OptionType(TickFormatType) }),
     integer: NullType,
-    lookup: StructType({ register: StringType }),
+    lookup: StructType({ register: StringType, options: OptionType(SheetOptionsRuleType) }),
     reference: StructType({ register: StringType }),
-    enum: StructType({ register: StringType }),
+    enum: StructType({ register: StringType, options: OptionType(SheetOptionsRuleType) }),
     set: StructType({
         register: StringType,
         members: ArrayType(SheetMemberKindType),
@@ -444,6 +622,7 @@ export const SheetColumnKindType = VariantType({
         arity: OptionType(SheetArityType),
         check: ArrayType(SheetCheckType),
         store: SheetStoreType,
+        options: OptionType(SheetOptionsRuleType),
     }),
     stamped: StructType({ owner: OptionType(StringType) }),
     custom: StructType({
@@ -471,6 +650,7 @@ export const SheetColumnKindType = VariantType({
  * @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
+ * @property detailCell - The unrendered cell whose text is the column's detail — the hover and the strip (#844)
  */
 export const SheetColumnType = StructType({
     key: StringType,
@@ -482,6 +662,57 @@ export const SheetColumnType = StructType({
     payloadType: EastTypeType,
     editable: BooleanType,
     fill: ArrayType(SheetProviderType),
+    detailCell: OptionType(StringType),
+});
+// ============================================================================
+// Grouped rows (#740) — the band's cells and the group declaration
+// ============================================================================
+/**
+ * One cell of a group row's band (#740) — a group field drawn under a line
+ * column (or the title), exactly a column declared over the group's row.
+ *
+ * @property key - The cell key: a line column's key, or {@link SHEET_TITLE_CELL}
+ * @property field - The group row's field the cell reads and writes
+ * @property kind - The cell's kind (the §3.2 table; no `lookup`, `set`, `link` or `custom` in a band)
+ * @property dataType - The group field's static type
+ * @property payloadType - The kind's payload type
+ * @property editable - Whether the band writes the field
+ */
+export const SheetGroupCellType = StructType({
+    key: StringType,
+    field: StringType,
+    kind: SheetColumnKindType,
+    dataType: EastTypeType,
+    payloadType: EastTypeType,
+    editable: BooleanType,
+});
+/**
+ * The host's word for a group (#844) — what fold-all, the footer count, hints
+ * and the new-group button call a group. When the declaration names none the
+ * wire carries none, and the renderer says its own word — its message
+ * table's, so a translation reaches it (#861).
+ *
+ * @property singular - One group (`"order"`)
+ * @property plural - Several (`"orders"`)
+ */
+export const SheetNounType = StructType({
+    singular: StringType,
+    plural: StringType,
+});
+/**
+ * The group declaration (#740) — how a grouped sheet's rows carry their
+ * lines, and what the band draws.
+ *
+ * @property lines - The group row's field that holds the lines — an `Array<L>`, so a line's key is its position
+ * @property cells - The band's cells, the title first under {@link SHEET_TITLE_CELL}
+ * @property noun - The host's word for a group (#844); `none` ⇒ the renderer's own (#861)
+ * @property loose - `true` ⇒ the source's entries are `Sheet.Types.Entry(P, "lines")`: a group, or a LOOSE row of the line type between the groups (#846) — a wire row with no band
+ */
+export const SheetGroupType = StructType({
+    lines: StringType,
+    cells: ArrayType(SheetGroupCellType),
+    noun: OptionType(SheetNounType),
+    loose: BooleanType,
 });
 // ============================================================================
 // Views, edits, selection, footer, style
@@ -495,6 +726,7 @@ export const SheetColumnType = StructType({
  * @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
+ * @property folds - A grouped sheet's fold overrides (#740): group id → folded; a group not listed opens as its `folded` accessor says
  */
 export const SheetViewType = StructType({
     id: StringType,
@@ -502,6 +734,7 @@ export const SheetViewType = StructType({
     narrowing: SliceStateType,
     context: IntegerType,
     reveals: ArrayType(IntegerType),
+    folds: DictType(StringType, BooleanType),
 });
 /**
  * Where an edit came from — provenance a host can measure copilot uptake by (B§1).
@@ -521,26 +754,39 @@ export const SheetSourceType = VariantType({
 });
 /**
  * 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.
+ * inside a renderer gesture. These records never call an author callback;
+ * the editing session emits one complete PatchEvent after the gesture.
+ * @internal
+ *
+ * On a grouped sheet (#740) the three row arms are the GROUP's — a band
+ * cell committed, a group created, groups removed — and the line arms carry
+ * a line's address within its group; `row` is always the whole group row.
  *
  * @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
+ * @property lineCommit - A line's cell committed: the GROUP row after the commit, the line's key, the column
+ * @property lineInsert - A line inserted into a group after `after` (`none` ⇒ first), at `line`
+ * @property lineRemove - Lines removed from a group, by key
  */
 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) }),
+    lineCommit: StructType({ rowId: StringType, offset: IntegerType, line: StringType, key: StringType, row: SheetRowType, source: SheetSourceType }),
+    lineInsert: StructType({ rowId: StringType, offset: IntegerType, after: OptionType(StringType), line: StringType, row: SheetRowType, source: SheetSourceType }),
+    lineRemove: StructType({ rowId: StringType, offset: IntegerType, lines: ArrayType(StringType), row: SheetRowType }),
 });
 /**
  * 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
+ * @property rowId - The selected row (`none` ⇒ a blank padding row or nothing); a grouped sheet: the GROUP's id
+ * @property line - A grouped sheet: the selected line's key within its group (`none` on the band, a blank line, or a flat sheet)
+ * @property key - The selected column (a band: the line column the cell sits under, or `$title`)
  */
 export const SheetSelectionType = StructType({
     rowId: OptionType(StringType),
+    line: OptionType(StringType),
     key: OptionType(StringType),
 });
 /**
@@ -573,9 +819,9 @@ export const SheetStyleType = StructType({
  * `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).
+ * `editing` carries the exact schemas and checked batch callbacks. The
+ * live onUpdate adapter writes once per application. `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
@@ -586,10 +832,10 @@ export const SheetStyleType = StructType({
  * @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 group - The group declaration (#740); `none` on a flat sheet
  * @property readOnly - The whole sheet is read-only
  * @property blanks - Padding rows below the last real one (default 18)
  * @property density - Row rhythm
@@ -598,6 +844,7 @@ export const SheetStyleType = StructType({
  */
 export const SheetRootType = StructType({
     rows: SheetRowsType,
+    editing: SheetEditingType,
     columns: ArrayType(SheetColumnType),
     registers: DictType(StringType, SheetRegisterType),
     driver: OptionType(SheetDriverType),
@@ -606,10 +853,10 @@ export const SheetRootType = StructType({
     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)),
+    group: OptionType(SheetGroupType),
     readOnly: OptionType(BooleanType),
     blanks: OptionType(IntegerType),
     density: OptionType(DensityType),
@@ -645,8 +892,9 @@ export const SheetRootType = StructType({
 export function SheetContextTypeFor(rowType, driverType) {
     return StructType({
         rowIndex: IntegerType,
-        row: rowType,
-        rows: ArrayType(rowType),
+        row: SheetDraftTypeFor(rowType),
+        rows: ArrayType(SheetDraftTypeFor(rowType)),
+        group: OptionType(NullType),
         partial: BooleanType,
         driver: OptionType((driverType ?? NullType)),
         today: DateTimeType,
@@ -700,26 +948,6 @@ export function SheetPatchTypeFor(rowType) {
 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.
@@ -736,9 +964,98 @@ export function SheetEditTypeFor(rowType) {
 export function SheetCheckContextTypeFor(rowType) {
     return StructType({
         rowIndex: IntegerType,
-        row: rowType,
+        row: SheetDraftTypeFor(rowType),
+        group: OptionType(NullType),
         half: SheetHalfType,
         member: SheetMemberType,
     });
 }
+/**
+ * The line type a group row's lines field holds, checked at build time.
+ *
+ * @param groupType - The group's row type value
+ * @param field - The lines field
+ * @returns The line type
+ * @throws Error naming the field when it is not an `Array<Struct>`
+ */
+export function sheetLinesOf(groupType, field) {
+    const fields = groupType.fields;
+    const t = fields[field];
+    if (t === undefined) {
+        throw new Error(`Sheet: \`group\` names "${field}", which is not a field of the row type (${Object.keys(fields).join(", ")})`);
+    }
+    if (t.type === "Array" && t.value?.type === "Struct") {
+        return { lineType: t.value };
+    }
+    throw new Error(`Sheet: the lines field "${field}" must be an Array of row structs — got ${t.type ?? "an unknown type"}`);
+}
+/**
+ * `Sheet.Types.Context(P, "lines", D)` — the copilot context of a GROUPED
+ * sheet: the line as it would be, its group's lines, the group, the resident
+ * groups and the driver's row, all typed.
+ *
+ * @typeParam P - The group's row type
+ * @typeParam F - The lines field
+ * @typeParam D - The driver's row type
+ * @param groupType - The group's row type value
+ * @param lines - The lines field
+ * @param driverType - The driver's row type value (default `NullType`)
+ * @returns The concrete context `StructType`
+ *
+ * On a sheet with loose rows between its groups (#846), a LOOSE row's
+ * context has no group: `rows` are the resident loose rows, `rowIndex` its
+ * index among them.
+ *
+ * @property rowIndex - The line's index WITHIN its group (a loose row: its index in `rows`)
+ * @property row - The line as it would be if the open editor committed
+ * @property rows - The group's lines, in order (a loose row: the resident loose rows)
+ * @property group - The group row (`none` for a loose row)
+ * @property groups - The resident groups, in sheet order
+ * @property partial - `true` on a paged sheet whose source is not exhausted
+ * @property driver - The driver's row for `row`
+ * @property today - UTC midnight
+ */
+export function SheetGroupContextTypeFor(groupType, lines, driverType) {
+    const { lineType } = sheetLinesOf(groupType, lines);
+    return StructType({
+        rowIndex: IntegerType,
+        row: SheetDraftTypeFor(lineType),
+        rows: ArrayType(SheetDraftTypeFor(lineType)),
+        group: OptionType(SheetDraftGroupTypeFor(groupType, lines)),
+        groups: ArrayType(SheetDraftGroupTypeFor(groupType, lines)),
+        partial: BooleanType,
+        driver: OptionType((driverType ?? NullType)),
+        today: DateTimeType,
+    });
+}
+/**
+ * `Sheet.Types.CheckContext(P, "lines")` — what an author's member check
+ * sees on a GROUPED sheet: the typed line, its group, the half and the member.
+ *
+ * @typeParam P - The group's row type
+ * @typeParam F - The lines field
+ * @param groupType - The group's row type value
+ * @param lines - The lines field
+ * @returns The concrete check-context `StructType`
+ */
+export function SheetGroupCheckContextTypeFor(groupType, lines) {
+    const { lineType } = sheetLinesOf(groupType, lines);
+    return StructType({
+        rowIndex: IntegerType,
+        row: SheetDraftTypeFor(lineType),
+        group: OptionType(SheetDraftGroupTypeFor(groupType, lines)),
+        half: SheetHalfType,
+        member: SheetMemberType,
+    });
+}
+export function sheetContextType(first, second, third) {
+    if (typeof second === "string")
+        return SheetGroupContextTypeFor(first, second, third);
+    return SheetContextTypeFor(first, second);
+}
+export function sheetCheckContextType(first, second) {
+    if (typeof second === "string")
+        return SheetGroupCheckContextTypeFor(first, second);
+    return SheetCheckContextTypeFor(first);
+}
 //# sourceMappingURL=types.js.map