@elaraai/east-ui 1.0.74 → 1.0.76

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

@@ -0,0 +1,630 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The typed bridge (`Sheet Spec.md` §4.8) — factory internals, both arms.
+ *
+ * Everything the author writes is typed over the host's row `R` and the
+ * driver's row `D`; everything on the wire is closed. This module joins the
+ * two with compiled East functions that capture only data, bind handles and
+ * the author's functions:
+ *
+ * - `projectRow` — `R` → the wire cells (the same projection the row source
+ *   uses, so `encode` and `make` cannot disagree);
+ * - `rowById` — the REAL source row by id: the captured collection or bind
+ *   handle on the inline arm, the source's `page` at the row's offset on the
+ *   paged arm. Built ONCE per sheet and shared by every wrapper;
+ * - `decode` — the source row as the base (the row type's default when
+ *   absent — an insert, a proposal), then each column's field from its cell
+ *   by the static tag. A field with no column keeps the base row's value;
+ * - `bridgeCtx` — the wire context to `Sheet.Types.Context(R, D)`;
+ * - the wrappers — a fill provider, a proposer, an arity rule, a member
+ *   check, a custom kind's parse / print, `onEdit` — each the author's typed
+ *   function inside its closed wire twin.
+ *
+ * The bridge is the one place a string ever names a field: inside the
+ * factory, against the column list it has already validated.
+ *
+ * @packageDocumentation
+ */
+import { East, Expr, ArrayType, AsyncFunctionType, BooleanType, DateTimeType, DictType, FloatType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, defaultValue, variant, some, none, } from "@elaraai/east";
+import { SheetCellType, SheetLinkType, SheetContextType, SheetFillType, SheetProposalType, SheetProviderType, SheetProposerType, SheetCheckContextType, SheetCheckType, SheetCountedType, SheetEditType, SheetHalfType, SheetContextTypeFor, SheetCheckContextTypeFor, SheetEditTypeFor, SheetPatchTypeFor, SheetProposalTypeFor, } from "./types.js";
+import { SheetMembersType, SheetRegisterMembersType, parseLink, printLink, printLinkWith, EMPTY_LINK } from "./link.js";
+/** The wire cells dictionary type. */
+export const SheetCellsType = DictType(StringType, SheetCellType);
+/** The East type of an erased expression (`Expr.type` cannot infer through `ExprType<EastType>`). */
+function typeOf(e) {
+    return Expr.type(e);
+}
+/** Whether a type is `Option<T>` — a variant of exactly `none: Null` and `some`. */
+export function optionPayload(t) {
+    const v = t;
+    if (v.type !== "Variant" || v.cases === undefined)
+        return undefined;
+    const keys = Object.keys(v.cases);
+    if (keys.length !== 2 || v.cases["none"] === undefined || v.cases["some"] === undefined)
+        return undefined;
+    if (v.cases["none"].type !== "Null")
+        return undefined;
+    return v.cases["some"];
+}
+/** The cell arm a primitive payload lands in, or `undefined` for a type no cell holds. */
+export function cellTagOf(t) {
+    if (t === SheetLinkType)
+        return "Link";
+    switch (t.type) {
+        case "String": return "String";
+        case "DateTime": return "DateTime";
+        case "Float": return "Float";
+        case "Integer": return "Integer";
+        case "Boolean": return "Boolean";
+        default: return undefined;
+    }
+}
+const SCALAR_PAYLOAD = {
+    text: StringType, lookup: StringType, reference: StringType, enum: StringType, stamped: StringType,
+    date: DateTimeType, quantity: FloatType, integer: IntegerType,
+};
+/**
+ * Describe one column against the row type — the build-time refusals of
+ * §3.12 live here, every one naming the column and the remedy.
+ *
+ * @param key - The column key
+ * @param col - The built column
+ * @param rowType - The host's row type
+ * @returns The column's metadata
+ * @throws Error naming the column when the kind cannot sit on the field
+ */
+export function describeColumn(key, col, rowType) {
+    const fields = rowType.fields;
+    const fieldType = fields[key];
+    if (fieldType === undefined) {
+        throw new Error(`Sheet: column "${key}" is not a field of the row type — the columns map is keyed by the row's fields (${Object.keys(fields).join(", ")})`);
+    }
+    const cfg = col.config;
+    const kind = col.kind;
+    const payloadOf = optionPayload(fieldType);
+    const optional = payloadOf !== undefined;
+    const unwrapped = payloadOf ?? fieldType;
+    // A derived read — the projection decides the payload; the field is free.
+    if (cfg.value !== undefined && kind !== "set" && kind !== "link" && kind !== "stamped" && kind !== "custom") {
+        const payloadType = SCALAR_PAYLOAD[kind];
+        const derived = East.function([rowType], undefined, (_$, r) => cfg.value(r));
+        const out = Expr.type(derived).output;
+        const outPayload = optionPayload(out);
+        const outUnwrapped = outPayload ?? out;
+        if (outUnwrapped !== payloadType) {
+            throw new Error(`Sheet: column "${key}" is a ${kind} column whose \`value\` projection returns ${outUnwrapped.type} — a ${kind} column's projection must return ${payloadType.type} or its Option`);
+        }
+        return {
+            key, kind, config: cfg, fieldType, optional, payloadType,
+            cellTag: cellTagOf(payloadType), editable: false,
+            derived, derivedOptional: outPayload !== undefined,
+            ...(col.register !== undefined ? { register: col.register } : {}),
+            ...(col.driverType !== undefined ? { driverType: col.driverType } : {}),
+        };
+    }
+    if (kind === "set" || kind === "link") {
+        let form;
+        let ownHalf;
+        let otherField;
+        if (fieldType === SheetLinkType || unwrapped === SheetLinkType) {
+            form = "link";
+        }
+        else if (fieldType === SheetMembersType) {
+            form = "array";
+            if (kind === "set") {
+                ownHalf = "to";
+            }
+            else if (cfg.to !== undefined && cfg.from === undefined) {
+                ownHalf = "from";
+                otherField = cfg.to;
+            }
+            else if (cfg.from !== undefined && cfg.to === undefined) {
+                ownHalf = "to";
+                otherField = cfg.from;
+            }
+            else {
+                throw new Error(`Sheet: link column "${key}" sits on an Array<Member> field, so it must name the OTHER half's field — \`to: "…"\` when this field holds the from members, \`from: "…"\` when it holds the to members`);
+            }
+            if (otherField !== undefined && fields[otherField] !== SheetMembersType) {
+                throw new Error(`Sheet: link column "${key}" names "${otherField}" as its other half, but that is not an Array<Sheet.Types.Member> field of the row`);
+            }
+        }
+        else if (unwrapped.type === "String") {
+            form = "string";
+        }
+        else {
+            throw new Error(`Sheet: ${kind} column "${key}" must sit on a Sheet.Types.Link, Array<Sheet.Types.Member> or String field — got ${fieldType.type}`);
+        }
+        return {
+            key, kind, config: cfg, fieldType, optional: form === "link" ? unwrapped === SheetLinkType && optional : optional,
+            payloadType: SheetLinkType, cellTag: "Link", editable: cfg.editable !== false,
+            form,
+            ...(ownHalf !== undefined ? { ownHalf } : {}),
+            ...(otherField !== undefined ? { otherField } : {}),
+            ...(col.register !== undefined ? { register: col.register } : {}),
+            ...(col.driverType !== undefined ? { driverType: col.driverType } : {}),
+        };
+    }
+    if (kind === "custom") {
+        const parseFn = East.value(cfg.parse);
+        const parseType = typeOf(parseFn);
+        const parsed = optionPayload(parseType.output);
+        if (parsed === undefined) {
+            throw new Error(`Sheet: custom column "${key}" has a \`parse\` whose output is not an Option — it must return Option<payload>, \`none\` meaning unrecognised`);
+        }
+        if (parsed !== unwrapped) {
+            throw new Error(`Sheet: custom column "${key}" parses to ${parsed.type} but sits on a ${unwrapped.type} field — the payload must be the field's type (or its Option's)`);
+        }
+        const tag = cellTagOf(parsed);
+        if (tag === undefined) {
+            throw new Error(`Sheet: custom column "${key}" has payload ${parsed.type}, which no cell holds — use String, Integer, Float, DateTime, Boolean or Sheet.Types.Link`);
+        }
+        return { key, kind, config: cfg, fieldType, optional, payloadType: parsed, cellTag: tag, editable: cfg.editable !== false };
+    }
+    const payloadType = SCALAR_PAYLOAD[kind];
+    if (unwrapped !== payloadType) {
+        throw new Error(`Sheet: ${kind} column "${key}" must sit on a ${payloadType.type} or Option<${payloadType.type}> field — got ${fieldType.type}`);
+    }
+    return {
+        key, kind, config: cfg, fieldType, optional, payloadType,
+        cellTag: cellTagOf(payloadType),
+        editable: kind !== "stamped" && cfg.editable !== false,
+        ...(col.register !== undefined ? { register: col.register } : {}),
+        ...(col.driverType !== undefined ? { driverType: col.driverType } : {}),
+    };
+}
+// ============================================================================
+// Cells — payload ↔ cell (the static-tag moves)
+// ============================================================================
+/** A payload value as a cell. */
+export function cellOfPayload(tag, v) {
+    return East.value(variant(tag, v), SheetCellType);
+}
+/** The blank cell. */
+export const NULL_CELL = East.value(variant("Null", null), SheetCellType);
+/** A field VALUE (the payload or its Option) as a cell, by the column's static shape. */
+function cellOfFieldValue(meta, v, optional) {
+    if (!optional)
+        return cellOfPayload(meta.cellTag, v);
+    return v.match({
+        some: (_$, x) => cellOfPayload(meta.cellTag, x),
+        none: (_$) => NULL_CELL,
+    });
+}
+/**
+ * The cell of a column for one row — the projection `make` and `encode`
+ * share. `members` is the column's register (bound in the caller's block)
+ * for the `String` link form.
+ */
+function projectCell(meta, r, members) {
+    const row = r;
+    if (meta.derived !== undefined) {
+        return cellOfFieldValue(meta, meta.derived(r), meta.derivedOptional === true);
+    }
+    const fv = row[meta.key];
+    if (meta.form === undefined)
+        return cellOfFieldValue(meta, fv, meta.optional);
+    if (meta.form === "link")
+        return cellOfFieldValue(meta, fv, meta.optional);
+    if (meta.form === "array") {
+        const half = fv;
+        const empty = East.value([], SheetMembersType);
+        const other = meta.otherField !== undefined ? row[meta.otherField] : empty;
+        const link = meta.ownHalf === "from"
+            ? East.value({ from: half, to: other }, SheetLinkType)
+            : East.value({ from: other, to: half }, SheetLinkType);
+        return cellOfPayload("Link", link);
+    }
+    // The String form — the grammar parses it on read; blank text is the blank cell.
+    const parse = (text) => text.trim().length().equal(0n).ifElse((_$) => NULL_CELL, (_$) => cellOfPayload("Link", parseLink(text, members ?? East.value([], SheetRegisterMembersType))));
+    if (!meta.optional)
+        return parse(fv);
+    return fv.match({
+        some: (_$, s) => parse(s),
+        none: (_$) => NULL_CELL,
+    });
+}
+/** The field value a cell decodes to — the payload or its Option, by the column's static shape. */
+function fieldValueOfCell(meta, cell, optional, payloadType) {
+    if (optional) {
+        return cell.match({ [meta.cellTag]: (_$, v) => East.value(some(v), OptionType(payloadType)) }, (_$) => East.value(none, OptionType(payloadType)));
+    }
+    return cell.match({ [meta.cellTag]: (_$, v) => v }, (_$) => East.value(defaultValue(payloadType), payloadType));
+}
+/**
+ * The value of THIS column's field from its cell (the base field when the cell
+ * is absent or the column is read-only). `members` is the column's register,
+ * bound in the caller's block, for the String link form's canonical print.
+ */
+function decodeOwnField(meta, cellOpt, base, members) {
+    if (!meta.editable)
+        return base;
+    // The String form prints the link back through the grammar — the keys as
+    // typed, or the register's labels under `store: "canonical"` (B§4.2).
+    const print = (l) => meta.config.store === "canonical" && members !== undefined ? printLinkWith(l, members) : printLink(l);
+    return cellOpt.match({
+        none: (_$) => base,
+        some: (_$, cell) => {
+            if (meta.form === undefined)
+                return fieldValueOfCell(meta, cell, meta.optional, meta.payloadType);
+            if (meta.form === "link")
+                return fieldValueOfCell(meta, cell, meta.optional, SheetLinkType);
+            if (meta.form === "array") {
+                return cell.match({ Link: (_$2, l) => meta.ownHalf === "from" ? l.from : l.to }, (_$2) => East.value([], SheetMembersType));
+            }
+            if (meta.optional) {
+                return cell.match({ Link: (_$2, l) => East.value(some(print(l)), OptionType(StringType)) }, (_$2) => East.value(none, OptionType(StringType)));
+            }
+            return cell.match({ Link: (_$2, l) => print(l) }, (_$2) => East.value("", StringType));
+        },
+    });
+}
+/** The OTHER half's field of an `array`-form link column, from that column's cell. */
+function decodeOtherHalf(meta, cellOpt, base) {
+    if (!meta.editable)
+        return base;
+    return cellOpt.match({
+        none: (_$) => base,
+        some: (_$, cell) => cell.match({ Link: (_$2, l) => meta.ownHalf === "from" ? l.to : l.from }, (_$2) => East.value([], SheetMembersType)),
+    });
+}
+/** The id of a row — the id field, or the key of a keyed window. */
+function idOf(r, idField) {
+    if (idField === undefined)
+        throw new Error("Sheet: a positional source needs `id` — the String field that identifies a row");
+    return r[idField];
+}
+/**
+ * Compile the bridge for one sheet.
+ *
+ * @param input - The root's resolved declaration
+ * @returns The bridge
+ */
+export function buildBridge(input) {
+    const { rowType, idField, metas, registers, driver, source } = input;
+    const driverType = driver !== undefined ? driver.rowType : NullType;
+    const ctxType = SheetContextTypeFor(rowType, driverType);
+    const checkCtxType = SheetCheckContextTypeFor(rowType);
+    const editType = SheetEditTypeFor(rowType);
+    const patchType = SheetPatchTypeFor(rowType);
+    const proposalType = SheetProposalTypeFor(rowType);
+    const fields = rowType.fields;
+    const byField = new Map(metas.map((m) => [m.key, m]));
+    const otherHalfBy = new Map();
+    for (const m of metas)
+        if (m.otherField !== undefined)
+            otherHalfBy.set(m.otherField, m);
+    // R → the wire cells. Registers are bound ONCE per body for the String
+    // link form (the capture rule: data, never a spliced expression).
+    const stringFormRegisters = [...new Set(metas.filter((m) => m.form === "string" && m.register !== undefined).map((m) => m.register))];
+    const projectRow = East.function([rowType], SheetCellsType, ($, r) => {
+        const cells = $.let(new Map(), SheetCellsType);
+        const bound = new Map();
+        for (const name of stringFormRegisters) {
+            bound.set(name, $.const(registers[name], SheetRegisterMembersType));
+        }
+        for (const m of metas) {
+            $(cells.insert(m.key, projectCell(m, r, m.register !== undefined ? bound.get(m.register) : undefined)));
+        }
+        return cells;
+    });
+    // (id, cells, base) → R: the base row (the type's default when absent),
+    // every column's field from its cell, the id field from the wire id.
+    const decode = East.function([StringType, SheetCellsType, OptionType(rowType)], rowType, ($, id, cells, base) => {
+        const b = $.let(base.match({
+            some: (_$, x) => x,
+            none: (_$) => East.value(defaultValue(rowType), rowType),
+        }), rowType);
+        // The String link form's registers, bound once per body (the capture rule).
+        const bound = new Map();
+        for (const name of stringFormRegisters) {
+            bound.set(name, $.const(registers[name], SheetRegisterMembersType));
+        }
+        const out = {};
+        for (const f of Object.keys(fields)) {
+            const baseField = $.let(b[f], fields[f]);
+            if (f === idField) {
+                out[f] = id;
+                continue;
+            }
+            const own = byField.get(f);
+            if (own !== undefined) {
+                out[f] = decodeOwnField(own, cells.tryGet(own.key), baseField, own.register !== undefined ? bound.get(own.register) : undefined);
+                continue;
+            }
+            const other = otherHalfBy.get(f);
+            if (other !== undefined) {
+                out[f] = decodeOtherHalf(other, cells.tryGet(other.key), baseField);
+                continue;
+            }
+            out[f] = baseField;
+        }
+        return East.value(out, rowType);
+    });
+    // (id, offset) → the real source row.
+    const rowById = source.kind === "inline"
+        ? East.function([StringType, IntegerType], OptionType(rowType), ($, id, _offset) => {
+            const rows = $.const(source.rows, ArrayType(rowType));
+            return rows.firstMap((_$, r) => idOf(r, idField).equal(id).ifElse((_$2) => East.value(some(r), OptionType(rowType)), (_$2) => East.value(none, OptionType(rowType))));
+        })
+        : East.function([StringType, IntegerType], OptionType(rowType), ($, id, offset) => {
+            const src = $.const(source.source);
+            const noRow = $.const(none, OptionType(rowType));
+            return src.page(offset, 1n).match({
+                none: (_$) => noRow,
+                some: (_$, win) => source.keyed
+                    ? win.tryGet(id)
+                    : win.firstMap((_$2, r) => idOf(r, idField).equal(id).ifElse((_$3) => East.value(some(r), OptionType(rowType)), (_$3) => East.value(none, OptionType(rowType)))),
+            });
+        });
+    // The driver lookup — the driver data folded once into a dictionary; a
+    // driverless sheet's lookup is always `none` (its `D` is `Null`).
+    const lookupDriver = driver !== undefined
+        ? East.function([StringType], OptionType(driverType), ($, k) => {
+            const dict = $.const(driver.data.toDict((_$, d) => driver.keyFn(d), (_$, d) => d), DictType(StringType, driverType));
+            return dict.tryGet(k);
+        })
+        : East.function([StringType], OptionType(driverType), ($, _k) => $.const(none, OptionType(driverType)));
+    // The wire context → Sheet.Types.Context(R, D).
+    const bridgeCtx = East.function([SheetContextType], ctxType, ($, ctx) => {
+        const byId = $.const(rowById);
+        const dec = $.const(decode);
+        const row = $.let(dec(ctx.rowId, ctx.row, byId(ctx.rowId, ctx.offset)), rowType);
+        const rows = $.let(ctx.rows.map((_$, r, i) => dec(r.id, r.cells, byId(r.id, ctx.rowsOffset.add(i)))), ArrayType(rowType));
+        const lookup = $.const(lookupDriver);
+        const driverRow = $.let(ctx.driver.match({
+            none: (_$) => East.value(none, OptionType(driverType)),
+            some: (_$, k) => lookup(k),
+        }), OptionType(driverType));
+        return East.value({
+            rowIndex: ctx.rowIndex,
+            row,
+            rows,
+            partial: ctx.partial,
+            driver: driverRow,
+            today: ctx.today,
+        }, ctxType);
+    });
+    // Sheet.Types.Patch(R) → the set fields as cells.
+    const encodePatch = East.function([patchType], SheetCellsType, ($, patch) => {
+        const cells = $.let(new Map(), SheetCellsType);
+        const p = patch;
+        const bound = new Map();
+        for (const name of stringFormRegisters) {
+            bound.set(name, $.const(registers[name], SheetRegisterMembersType));
+        }
+        for (const m of metas) {
+            if (!m.editable || m.derived !== undefined)
+                continue;
+            if (m.form === "array") {
+                // The other half is `none` when the column names no other field.
+                const otherKey = m.otherField;
+                const own = $.let(p[m.key], OptionType(SheetMembersType));
+                const other = $.let((otherKey !== undefined ? p[otherKey] : none), OptionType(SheetMembersType));
+                $.if(own.hasTag("some").or(() => other.hasTag("some")), ($2) => {
+                    const empty = $2.const([], SheetMembersType);
+                    const ownVal = $2.let(own.match({ some: (_$, v) => v, none: (_$) => empty }), SheetMembersType);
+                    const otherVal = $2.let(other.match({ some: (_$, v) => v, none: (_$) => empty }), SheetMembersType);
+                    const link = m.ownHalf === "from"
+                        ? $2.let({ from: ownVal, to: otherVal }, SheetLinkType)
+                        : $2.let({ from: otherVal, to: ownVal }, SheetLinkType);
+                    $2(cells.insert(m.key, cellOfPayload("Link", link)));
+                });
+                continue;
+            }
+            const field = $.let(p[m.key], OptionType(fields[m.key]));
+            $.if(field.hasTag("some"), ($2) => {
+                const v = $2.let(field.unwrap("some"), fields[m.key]);
+                const asRow = { [m.key]: v };
+                $2(cells.insert(m.key, projectCell(m, asRow, m.register !== undefined ? bound.get(m.register) : undefined)));
+            });
+        }
+        return cells;
+    });
+    return {
+        rowType, driverType, ctxType, checkCtxType, editType, patchType, proposalType,
+        projectRow, decode,
+        rowById: rowById,
+        bridgeCtx, encodePatch,
+    };
+}
+// ============================================================================
+// Wrappers — the author's typed functions inside their wire twins
+// ============================================================================
+/** Whether an East function value is asynchronous. */
+export function isAsyncFunction(fn) {
+    return typeOf(fn).type === "AsyncFunction";
+}
+/** Pin an author function value and check its East input type against the bridge's context type. */
+function pinProvider(bridge, fn, where, expectedOutput) {
+    const expr = East.value(fn);
+    const t = typeOf(expr);
+    if (t.type !== "Function" && t.type !== "AsyncFunction") {
+        throw new Error(`Sheet: ${where} must be an East.function or East.asyncFunction — got a ${t.type}`);
+    }
+    const inputs = t.inputs ?? [];
+    if (inputs.length !== 1 || inputs[0] !== bridge.ctxType) {
+        throw new Error(`Sheet: ${where} must take exactly this sheet's context — Sheet.Types.Context(RowType${bridge.driverType === NullType ? "" : ", DriverType"}) — as its one argument; a function written over another row or driver type cannot run here`);
+    }
+    if (t.output !== expectedOutput) {
+        throw new Error(`Sheet: ${where} returns the wrong type — it must return ${describeType(expectedOutput)}`);
+    }
+    return { fn: expr, async: t.type === "AsyncFunction" };
+}
+/** A short description of an East type for a refusal message. */
+function describeType(t) {
+    const v = t;
+    if (v.type === "Variant" && v.cases !== undefined && optionPayload(t) !== undefined)
+        return `Option<${describeType(optionPayload(t))}>`;
+    if (v.type === "Struct" && v.fields !== undefined)
+        return `{ ${Object.entries(v.fields).map(([k, f]) => `${k}: ${describeType(f)}`).join(", ")} }`;
+    if (v.type === "Array" && v.value !== undefined)
+        return `Array<${describeType(v.value)}>`;
+    return v.type;
+}
+/**
+ * Wrap a fill provider — `Sheet.Types.Context(R, D)` → `Option<Fill(T)>` —
+ * into the wire provider variant (sync or async by the function's type).
+ */
+export function wrapProvider(bridge, meta, fn, index) {
+    const fillType = StructType({ value: meta.payloadType, meta: StringType });
+    const { fn: author, async } = pinProvider(bridge, fn, `column "${meta.key}" fill provider #${index + 1}`, OptionType(fillType));
+    const body = ($, ctx) => {
+        const a = $.const(author);
+        const bc = $.const(bridge.bridgeCtx);
+        const typed = $.let(bc(ctx), bridge.ctxType);
+        return a(typed).match({
+            none: (_$) => East.value(none, OptionType(SheetFillType)),
+            some: (_$, f) => East.value(some({ value: cellOfPayload(meta.cellTag, f.value), meta: f.meta }), OptionType(SheetFillType)),
+        });
+    };
+    const wire = async
+        ? East.asyncFunction([SheetContextType], OptionType(SheetFillType), body)
+        : East.function([SheetContextType], OptionType(SheetFillType), body);
+    return East.value(variant(async ? "async" : "sync", wire), SheetProviderType);
+}
+/**
+ * Wrap a row proposer — `Sheet.Types.Context(R, D)` → `Array<Proposal(R)>` —
+ * into the wire proposer variant.
+ */
+export function wrapProposer(bridge, fn, index) {
+    const { fn: author, async } = pinProvider(bridge, fn, `suggest.propose #${index + 1}`, ArrayType(bridge.proposalType));
+    const body = ($, ctx) => {
+        const a = $.const(author);
+        const bc = $.const(bridge.bridgeCtx);
+        const enc = $.const(bridge.encodePatch);
+        const typed = $.let(bc(ctx), bridge.ctxType);
+        return a(typed).map((_$, p) => East.value({ cells: enc(p.patch), meta: p.meta }, SheetProposalType));
+    };
+    const wire = async
+        ? East.asyncFunction([SheetContextType], ArrayType(SheetProposalType), body)
+        : East.function([SheetContextType], ArrayType(SheetProposalType), body);
+    return East.value(variant(async ? "async" : "sync", wire), SheetProposerType);
+}
+/** Wrap an arity rule — `Sheet.Types.Context(R, D)` → `Option<Counted>`. */
+export function wrapArity(bridge, meta, fn) {
+    const { fn: author, async } = pinProvider(bridge, fn, `column "${meta.key}" arity rule`, OptionType(SheetCountedType));
+    if (async)
+        throw new Error(`Sheet: column "${meta.key}" arity rule must be synchronous — the strip reads it while the half is edited`);
+    return East.function([SheetContextType], OptionType(SheetCountedType), ($, ctx) => {
+        const a = $.const(author);
+        const bc = $.const(bridge.bridgeCtx);
+        return a(bc(ctx));
+    });
+}
+/** Wrap an author member check — `Sheet.Types.CheckContext(R)` → `Option<String>` — into the `custom` check arm. */
+export function wrapCheck(bridge, meta, fn, index) {
+    const expr = East.value(fn);
+    const t = typeOf(expr);
+    if (t.type !== "Function" || (t.inputs ?? []).length !== 1 || t.inputs[0] !== bridge.checkCtxType || t.output !== OptionType(StringType)) {
+        throw new Error(`Sheet: column "${meta.key}" check #${index + 1} must be an East.function over Sheet.Types.CheckContext(RowType) returning Option<String>`);
+    }
+    const wire = East.function([SheetCheckContextType], OptionType(StringType), ($, c) => {
+        const a = $.const(expr);
+        const byId = $.const(bridge.rowById);
+        const dec = $.const(bridge.decode);
+        const row = $.let(dec(c.rowId, c.row, byId(c.rowId, c.offset)), bridge.rowType);
+        return a(East.value({ rowIndex: c.rowIndex, row, half: c.half, member: c.member }, bridge.checkCtxType));
+    });
+    return East.value(variant("custom", wire), SheetCheckType);
+}
+/** Wrap a custom kind's `parse` — `(text, Context(R, D))` → `Option<P>` — into the wire parse. */
+export function wrapCustomParse(bridge, meta, fn) {
+    const expr = East.value(fn);
+    const t = typeOf(expr);
+    const inputs = t.inputs ?? [];
+    if (t.type !== "Function" || inputs.length !== 2 || inputs[0] !== StringType || inputs[1] !== bridge.ctxType) {
+        throw new Error(`Sheet: custom column "${meta.key}" \`parse\` must be an East.function over (String, Sheet.Types.Context(RowType, DriverType)) returning Option<payload>`);
+    }
+    return East.function([StringType, SheetContextType], OptionType(SheetCellType), ($, text, ctx) => {
+        const a = $.const(expr);
+        const bc = $.const(bridge.bridgeCtx);
+        return a(text, bc(ctx)).match({
+            none: (_$) => East.value(none, OptionType(SheetCellType)),
+            some: (_$, v) => East.value(some(cellOfPayload(meta.cellTag, v)), OptionType(SheetCellType)),
+        });
+    });
+}
+/** Wrap a custom kind's `print` — `P` → `String` — into the wire print. */
+export function wrapCustomPrint(meta, fn) {
+    const expr = East.value(fn);
+    const t = typeOf(expr);
+    const inputs = t.inputs ?? [];
+    if (t.type !== "Function" || inputs.length !== 1 || inputs[0] !== meta.payloadType || t.output !== StringType) {
+        throw new Error(`Sheet: custom column "${meta.key}" \`print\` must be an East.function over the payload (${describeType(meta.payloadType)}) returning String`);
+    }
+    return East.function([SheetCellType], StringType, ($, cell) => {
+        const a = $.const(expr);
+        return cell.match({ [meta.cellTag]: (_$, v) => a(v) }, (_$) => East.value("", StringType));
+    });
+}
+/** Wrap a typed `onEdit` — `Sheet.Types.Edit(R)` → `Null` — into the wire edit handler. */
+export function wrapOnEdit(bridge, fn) {
+    const expr = East.value(fn, FunctionType([bridge.editType], NullType));
+    return East.function([SheetEditType], NullType, ($, e) => {
+        const a = $.const(expr);
+        const byId = $.const(bridge.rowById);
+        const dec = $.const(bridge.decode);
+        const noRow = $.const(none, OptionType(bridge.rowType));
+        const et = bridge.editType;
+        $(e.match({
+            commit: (_$, c) => a(East.value(variant("commit", {
+                rowId: c.rowId, key: c.key, row: dec(c.rowId, c.row.cells, byId(c.rowId, c.offset)), source: c.source,
+            }), et)),
+            insert: (_$, i) => a(East.value(variant("insert", {
+                afterRowId: i.afterRowId, row: dec(i.row.id, i.row.cells, noRow), source: i.source,
+            }), et)),
+            remove: (_$, r) => a(East.value(variant("remove", { rowIds: r.rowIds }), et)),
+        }));
+    });
+}
+/**
+ * Compile `onUpdate` into the wire edit handler (§4.7) — the whole-value
+ * rebuild: a commit rewrites one row, an insert appends a fresh row after
+ * `afterRowId`, a remove filters ids; then the author's `onUpdate` receives
+ * the collection.
+ */
+export function compileOnUpdate(bridge, rows, idField, fn) {
+    const rowsType = ArrayType(bridge.rowType);
+    const expr = East.value(fn, FunctionType([rowsType], NullType));
+    return East.function([SheetEditType], NullType, ($, ev) => {
+        const current = $.let(rows, rowsType);
+        const upd = $.const(expr);
+        const dec = $.const(bridge.decode);
+        const noRow = $.const(none, OptionType(bridge.rowType));
+        const next = $.let(ev.match({
+            commit: (_$, c) => current.map((_$2, r) => idOf(r, idField).equal(c.rowId).ifElse((_$3) => dec(c.rowId, c.row.cells, East.value(some(r), OptionType(bridge.rowType))), (_$3) => r)),
+            insert: ($2, i) => {
+                const fresh = $2.let(dec(i.row.id, i.row.cells, noRow), bridge.rowType);
+                return i.afterRowId.match({
+                    none: (_$3) => current.concat(East.value([fresh], rowsType)),
+                    some: (_$3, after) => current.flatMap((_$4, r) => idOf(r, idField).equal(after).ifElse((_$5) => East.value([r, fresh], rowsType), (_$5) => East.value([r], rowsType))),
+                });
+            },
+            remove: ($2, rm) => {
+                const ids = $2.let(rm.rowIds.toSet());
+                return current.filter((_$3, r) => ids.has(idOf(r, idField)).not());
+            },
+        }), rowsType);
+        $(upd(next));
+    });
+}
+/** Both channels at once — `onEdit` observes, then `onUpdate` writes. */
+export function composeEditHandlers(observe, write) {
+    if (observe === undefined)
+        return write;
+    if (write === undefined)
+        return observe;
+    return East.function([SheetEditType], NullType, ($, e) => {
+        const o = $.const(observe);
+        const w = $.const(write);
+        $(o(e));
+        $(w(e));
+    });
+}
+/** Re-exported for the root's driver-typed refusals. */
+export { SheetHalfType, BooleanType, AsyncFunctionType, EMPTY_LINK };
+//# sourceMappingURL=bridge.js.map