@elaraai/e3-ui 1.0.82 → 1.0.84

package/dist/src/bind/record.d.ts

@@ -15,10 +15,16 @@
  * latest-wins mutation lifecycle. A record's mutations serialize server-side
  * under compare-and-swap, so one shared channel per record is the honest model.
  *
+ * `commit.<name>(…)` is the same write awaited: an async closure that resolves
+ * to the server's terminal outcome. `Record.onApply` builds on it — an
+ * editable collection's `onApply` that commits each batch to the record
+ * through its patch door, as one commit.
+ *
  * @packageDocumentation
  */
-import { ArrayType, BooleanType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type ExprType } from '@elaraai/east';
+import { ArrayType, AsyncFunctionType, BooleanType, DictType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
 import { DatasetStatusType, RecordCommitInfoType } from '@elaraai/e3-types';
+import { Editing } from '@elaraai/east-ui';
 import type { RecordDef, MutationDef } from '@elaraai/e3';
 /**
  * Shared mutate-lifecycle tag for a bound record. One launch channel per
@@ -93,11 +99,56 @@ export declare const RecordBindingType: StructType<{
 }>;
 /** Type representing the {@link RecordBindingType} structure. */
 export type RecordBindingType = typeof RecordBindingType;
+/**
+ * The outcome of an awaited write (`commit.<name>`): the server's terminal
+ * `MutationResult`, passed on as it came, and `transport` for a call that got
+ * no answer.
+ *
+ * @remarks
+ * Only `committed` wrote anything. `transport` is the one outcome that leaves
+ * it unknown whether the write committed — it may have reached the server
+ * before its answer was lost — which is what the write's request id is for: a
+ * retry with the same id resolves to that commit instead of writing twice.
+ *
+ * @property committed - The new commit, and the record state it wrote
+ * @property invalid - A lookup, arity or signature error; nothing ran
+ * @property failed - The mutation's program failed; see its stderr
+ * @property timed_out - The program ran out of time; nothing was written
+ * @property conflict - The compare-and-swap lost the race `attempts` times, or
+ *   the write no longer matched the record — then `detail` names the key
+ * @property transport - The call got no answer, so whether it committed is unknown
+ */
+export declare const RecordOutcomeType: VariantType<{
+    readonly transport: StructType<{
+        readonly message: StringType;
+    }>;
+    readonly committed: StructType<{
+        readonly commitHash: StringType;
+        readonly stateHash: StringType;
+    }>;
+    readonly invalid: StructType<{
+        readonly message: StringType;
+    }>;
+    readonly failed: StructType<{
+        readonly exitCode: IntegerType;
+        readonly stderr: StringType;
+    }>;
+    readonly timed_out: StructType<{
+        readonly ms: IntegerType;
+        readonly stderr: StringType;
+    }>;
+    readonly conflict: StructType<{
+        readonly attempts: IntegerType;
+        readonly detail: OptionType<StringType>;
+    }>;
+}>;
+/** Type representing the {@link RecordOutcomeType} structure. */
+export type RecordOutcomeType = typeof RecordOutcomeType;
 /**
  * The struct returned by every {@link Record.bind} call. The read side
  * (`read` / `status` / `history`) is served reactively from the shared dataset
  * cache; the write side lives under `mutate` — one closure per mutation plus
- * the shared lifecycle accessors.
+ * the shared lifecycle accessors — and under `commit`, the same writes awaited.
  *
  * @remarks
  * The handle's shape IS the signature: the runtime recovers the state type
@@ -118,6 +169,14 @@ export type RecordBindingType = typeof RecordBindingType;
  * @property mutate - The write surface: one fire-and-forget closure per
  *   mutation (typed from its def), plus the shared `pending` / `status` /
  *   `error` / `cancel`.
+ * @property commit - The writes awaited: one async closure per mutation,
+ *   taking a request id before the mutation's own arguments and resolving to
+ *   its {@link RecordOutcomeType}. The id makes a retry after an unanswered
+ *   call resolve to the first call's commit rather than writing twice; `""`
+ *   is a write without one. It runs on `mutate`'s channel, so `pending` /
+ *   `status` / `error` show it too, and a conflict reads the record and its
+ *   history again before the outcome settles — `read` and `history` then show
+ *   what the write lost to.
  * @property start - Launch the workspace dataflow without mutating, so tasks
  *   that consume this record recompute against its latest committed state.
  *   The standalone "Run" affordance — a mutation refreshes the record's own
@@ -142,6 +201,7 @@ export declare const RecordBindHandleType: <T extends EastType, M extends Record
         readonly delta: OptionType<StringType>;
     }>>>>;
     readonly mutate: StructType<Record<string, EastType>>;
+    readonly commit: StructType<Record<string, EastType>>;
     readonly start: FunctionType<[], NullType>;
     readonly binding: StructType<{
         readonly name: StringType;
@@ -172,6 +232,9 @@ type RecordHandle<T extends EastType, M extends Record<string, EastType[]>> = St
     } & {
         [K in keyof M]: FunctionType<M[K], typeof NullType>;
     }>;
+    commit: StructType<{
+        [K in keyof M]: AsyncFunctionType<[typeof StringType, ...M[K]], RecordOutcomeType>;
+    }>;
     start: FunctionType<[], typeof NullType>;
     binding: RecordBindingType;
 }>;
@@ -268,6 +331,31 @@ export declare const RecordBindPrimitives: {
     readonly mutateCancel: import("@elaraai/east").PlatformDefinition<[StringType], NullType>;
     /** `record_mutate([ArgsStruct], recordName, mutationName, argsStruct) -> Null`. */
     readonly mutate: import("@elaraai/east").GenericPlatformDefinition<readonly ["A"], readonly [StringType, StringType, "A"], NullType>;
+    /** `record_commit([ArgsStruct], recordName, mutationName, requestId, argsStruct) ~> RecordOutcome` — the awaited write. */
+    readonly commit: import("@elaraai/east").AsyncGenericPlatformDefinition<readonly ["A"], readonly [StringType, StringType, StringType, "A"], VariantType<{
+        readonly transport: StructType<{
+            readonly message: StringType;
+        }>;
+        readonly committed: StructType<{
+            readonly commitHash: StringType;
+            readonly stateHash: StringType;
+        }>;
+        readonly invalid: StructType<{
+            readonly message: StringType;
+        }>;
+        readonly failed: StructType<{
+            readonly exitCode: IntegerType;
+            readonly stderr: StringType;
+        }>;
+        readonly timed_out: StructType<{
+            readonly ms: IntegerType;
+            readonly stderr: StringType;
+        }>;
+        readonly conflict: StructType<{
+            readonly attempts: IntegerType;
+            readonly detail: OptionType<StringType>;
+        }>;
+    }>>;
 };
 /**
  * Bind an `e3.record` and its mutations to a reactive read/mutate handle.
@@ -317,21 +405,158 @@ export declare const RecordBindPrimitives: {
  * ```
  */
 declare function bindRecord<T extends EastType, Muts extends readonly MutationDef<string, T, EastType[]>[]>(record: RecordDef<T>, mutations: [...Muts]): BoundRecord<T, Muts>;
+/**
+ * Options for {@link Record.onApply} over the record's own entries — a Sheet or
+ * a Plan whose entries are the record's, each named by its key's text.
+ */
+export interface RecordApplyOptions {
+    /** The patch mutation each Apply commits through — the name
+     *  `e3.mutation.patch(record)` was given; `patch` when omitted. */
+    mutation?: string;
+    /** The collection hands keyed batches, `ChangeSet(V, K)`, as the Plan does;
+     *  a Sheet hands `ChangeSet(V)`, the default. */
+    keyed?: boolean;
+}
+/**
+ * Options for {@link Record.onApply} over a collection inside one entry — the
+ * rows of one Array field of one entry, which each Apply's patch reaches and
+ * nothing else.
+ *
+ * @typeParam K - The record's key type
+ * @typeParam V - The record's entry type
+ * @typeParam C - The collection's row type
+ */
+export interface RecordApplyInsideOptions<K extends EastType, V extends EastType, C extends StructType> {
+    /** The key of the entry the collection lives in. */
+    entry: SubtypeExprOrValue<K>;
+    /** The collection, read out of the entry. */
+    get: SubtypeExprOrValue<FunctionType<[V], ArrayType<C>>>;
+    /** The entry with its collection replaced, and nothing else changed. */
+    set: SubtypeExprOrValue<FunctionType<[V, ArrayType<C>], V>>;
+    /** The rows' String identity field. */
+    idField: string;
+    /** The patch mutation each Apply commits through; `patch` when omitted. */
+    mutation?: string;
+}
+/** A bound record whose state is keyed, `Dict<K, V>` — what an Apply writes by key. */
+type KeyedRecordHandle<K extends EastType, V extends EastType> = ExprType<StructType<{
+    read: FunctionType<[], DictType<K, V>>;
+}>>;
+/** An editable collection's async `onApply`, over the batch type it hands. */
+type RecordApplyFunction<B extends EastType> = ExprType<AsyncFunctionType<[B], typeof Editing.Types.ApplyResult>>;
+/**
+ * Commit an editable collection's batches to an `e3.record` — the `onApply` a
+ * Sheet, a Plan or a SnapGrid takes, each Apply one commit through the record's
+ * patch door (`e3.mutation.patch`).
+ *
+ * @remarks
+ * Two forms:
+ * - **Over the record's own entries** (`Record.onApply(handle)`): the
+ *   collection's entries are the record's, each change naming its entry by
+ *   the key's text — a String key as it is, any other its `.east` printing.
+ *   Each change is its entry's insert, update or delete: the batch's own
+ *   entry patches, restated by key.
+ * - **Over a collection inside one entry** (`{ entry, get, set, idField }`):
+ *   the rows of one entry's Array field. The batch is applied to the rows it
+ *   began from, and the patch is the diff of that entry before and after —
+ *   it reaches the rows and nothing else.
+ *
+ * Every patch carries what the entries were when the edit began, and the
+ * record checks it: an entry another write moved is a `conflict` naming it
+ * and who changed the record last, and nothing is overwritten. A commit is
+ * `applied` at the state it wrote; an invalid, failed or timed-out write is
+ * `rejected`. A write that got no answer throws, and the session's retry
+ * resolves to its commit, if it made one, through the batch's request id.
+ *
+ * The handle must be bound with the patch mutation — `Record.bind(record,
+ * [e3.mutation.patch(record)])` — and the record must be a `Dict`.
+ *
+ * @typeParam K - The record's key type
+ * @typeParam V - The record's entry type
+ * @param handle - The record, bound with its patch mutation
+ * @param options - {@link RecordApplyOptions} for the entries form, or
+ *   {@link RecordApplyInsideOptions} for a collection inside one entry
+ * @returns An async East function over the collection's batch, answering with
+ *   `Editing.Types.ApplyResult`
+ * @throws {Error} When the record is not a Dict, the mutation is not bound as
+ *   its patch door, or `get` / `set` do not fit the entry
+ *
+ * @example
+ * ```tsx
+ * import { DictType, East, IntegerType, StringType, StructType } from "@elaraai/east";
+ * import { Reactive, Sheet, UIComponentType } from "@elaraai/east-ui";
+ * import { Data, Record } from "@elaraai/e3-ui";
+ * import e3 from "@elaraai/e3";
+ *
+ * const JobType = StructType({ task: StringType, qty: IntegerType });
+ * const jobs = e3.record("jobs", DictType(StringType, JobType), new Map());
+ * const jobsPatch = e3.mutation.patch(jobs);
+ *
+ * // Mirrors `recordSheetApply` in test/bind/record/record.examples.tsx.
+ * const jobSheet = East.function([], UIComponentType, (_$) => (
+ *     <Reactive>{$ => {
+ *         const rows = $.let(Data.bindPaged(jobs));
+ *         const record = $.let(Record.bind(jobs, [jobsPatch]));
+ *         return (
+ *             <Sheet
+ *                 data={rows}
+ *                 columns={{
+ *                     task: Sheet.column.text(JobType, { header: "Task", width: "220px" }),
+ *                     qty:  Sheet.column.integer(JobType, { header: "Qty", width: "96px" }),
+ *                 }}
+ *                 onApply={Record.onApply(record)}
+ *                 style={{ height: "360px" }}
+ *             />
+ *         );
+ *     }}</Reactive>
+ * ));
+ * ```
+ */
+declare function applyToRecord<K extends EastType, V extends EastType>(handle: KeyedRecordHandle<K, V>, options?: RecordApplyOptions & {
+    keyed?: false;
+}): RecordApplyFunction<ReturnType<typeof Editing.Types.ChangeSet<V>>>;
+/**
+ * The entries form for a collection that hands keyed batches — the Plan.
+ *
+ * @typeParam K - The record's key type
+ * @typeParam V - The record's entry type
+ * @param handle - The record, bound with its patch mutation
+ * @param options - `{ keyed: true }`, and the patch mutation's name when it has one
+ * @returns An async East function over `Editing.Types.ChangeSet(V, K)`
+ */
+declare function applyToRecord<K extends EastType, V extends EastType>(handle: KeyedRecordHandle<K, V>, options: RecordApplyOptions & {
+    keyed: true;
+}): RecordApplyFunction<ReturnType<typeof Editing.Types.ChangeSet<V, K>>>;
+/**
+ * The form over a collection inside one entry.
+ *
+ * @typeParam K - The record's key type
+ * @typeParam V - The record's entry type
+ * @typeParam C - The collection's row type
+ * @param handle - The record, bound with its patch mutation
+ * @param options - The entry, how its rows are read and replaced, and their identity field
+ * @returns An async East function over `Editing.Types.ChangeSet(C)`
+ */
+declare function applyToRecord<K extends EastType, V extends EastType, C extends StructType>(handle: KeyedRecordHandle<K, V>, options: RecordApplyInsideOptions<K, V, C>): RecordApplyFunction<ReturnType<typeof Editing.Types.ChangeSet<C>>>;
 /**
  * The Record namespace — reactive record (read + mutate + history) binding for
- * e3 UI tasks.
+ * e3 UI tasks, and the Apply that commits an editable collection to a record.
  *
  * @remarks
  * `Record.bind` binds an `e3.record` and its mutations to a handle: `read` /
  * `status` / `history` observe the record's current state (served from the
  * shared dataset cache), and `mutate.<name>` applies a typed mutation
- * fire-and-forget under compare-and-swap, refreshing `read()` on commit.
+ * fire-and-forget under compare-and-swap, refreshing `read()` on commit;
+ * `commit.<name>` is the same write awaited. `Record.onApply` commits a
+ * Sheet's, a Plan's or a SnapGrid's batches to the record, each Apply one commit
+ * through its patch door.
  *
  * Use inside `Reactive.Root` for reactive re-rendering as the record and the
  * mutation lifecycle change.
  */
 export declare const Record: {
     readonly bind: typeof bindRecord;
+    readonly onApply: typeof applyToRecord;
 };
 export {};
 //# sourceMappingURL=record.d.ts.map

package/dist/src/bind/record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/bind/record.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/bind/record.ts"],"names":[],"mappings":"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"}

package/dist/src/bind/record.js

@@ -15,10 +15,16 @@
  * latest-wins mutation lifecycle. A record's mutations serialize server-side
  * under compare-and-swap, so one shared channel per record is the honest model.
  *
+ * `commit.<name>(…)` is the same write awaited: an async closure that resolves
+ * to the server's terminal outcome. `Record.onApply` builds on it — an
+ * editable collection's `onApply` that commits each batch to the record
+ * through its patch door, as one commit.
+ *
  * @packageDocumentation
  */
-import { East, ArrayType, BooleanType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, } from '@elaraai/east';
-import { DatasetStatusType, RecordCommitInfoType } from '@elaraai/e3-types';
+import { East, ArrayType, AsyncFunctionType, BooleanType, DictType, Expr, FunctionType, IntegerType, NullType, OptionType, PatchType, StringType, StructType, VariantType, dictPatchOpsType, isTypeEqual, none, printType, some, variant, } from '@elaraai/east';
+import { DatasetStatusType, MutationResultType, RecordCommitInfoType } from '@elaraai/e3-types';
+import { Editing } from '@elaraai/east-ui';
 // ============================================================================
 // Status + error + descriptor types
 // ============================================================================
@@ -79,6 +85,29 @@ export const RecordBindingType = StructType({
     name: StringType,
     mutations: ArrayType(StringType),
 });
+/**
+ * The outcome of an awaited write (`commit.<name>`): the server's terminal
+ * `MutationResult`, passed on as it came, and `transport` for a call that got
+ * no answer.
+ *
+ * @remarks
+ * Only `committed` wrote anything. `transport` is the one outcome that leaves
+ * it unknown whether the write committed — it may have reached the server
+ * before its answer was lost — which is what the write's request id is for: a
+ * retry with the same id resolves to that commit instead of writing twice.
+ *
+ * @property committed - The new commit, and the record state it wrote
+ * @property invalid - A lookup, arity or signature error; nothing ran
+ * @property failed - The mutation's program failed; see its stderr
+ * @property timed_out - The program ran out of time; nothing was written
+ * @property conflict - The compare-and-swap lost the race `attempts` times, or
+ *   the write no longer matched the record — then `detail` names the key
+ * @property transport - The call got no answer, so whether it committed is unknown
+ */
+export const RecordOutcomeType = VariantType({
+    ...MutationResultType.fields.outcome.cases,
+    transport: StructType({ message: StringType }),
+});
 // ============================================================================
 // Bind handle — return type of `Record.bind`.
 // ============================================================================
@@ -86,7 +115,7 @@ export const RecordBindingType = StructType({
  * The struct returned by every {@link Record.bind} call. The read side
  * (`read` / `status` / `history`) is served reactively from the shared dataset
  * cache; the write side lives under `mutate` — one closure per mutation plus
- * the shared lifecycle accessors.
+ * the shared lifecycle accessors — and under `commit`, the same writes awaited.
  *
  * @remarks
  * The handle's shape IS the signature: the runtime recovers the state type
@@ -107,6 +136,14 @@ export const RecordBindingType = StructType({
  * @property mutate - The write surface: one fire-and-forget closure per
  *   mutation (typed from its def), plus the shared `pending` / `status` /
  *   `error` / `cancel`.
+ * @property commit - The writes awaited: one async closure per mutation,
+ *   taking a request id before the mutation's own arguments and resolving to
+ *   its {@link RecordOutcomeType}. The id makes a retry after an unanswered
+ *   call resolve to the first call's commit rather than writing twice; `""`
+ *   is a write without one. It runs on `mutate`'s channel, so `pending` /
+ *   `status` / `error` show it too, and a conflict reads the record and its
+ *   history again before the outcome settles — `read` and `history` then show
+ *   what the write lost to.
  * @property start - Launch the workspace dataflow without mutating, so tasks
  *   that consume this record recompute against its latest committed state.
  *   The standalone "Run" affordance — a mutation refreshes the record's own
@@ -121,18 +158,21 @@ export const RecordBindHandleType = (stateType, mutations) => {
         error: FunctionType([], OptionType(RecordErrorType)),
         cancel: FunctionType([], NullType),
     };
+    const commitFields = {};
     for (const [name, argTypes] of Object.entries(mutations)) {
         if (name in mutateFields) {
             throw new Error(`Record.bind: mutation name "${name}" collides with a reserved mutate ` +
                 `field (pending/status/error/cancel). Rename the mutation.`);
         }
         mutateFields[name] = FunctionType(argTypes, NullType);
+        commitFields[name] = AsyncFunctionType([StringType, ...argTypes], RecordOutcomeType);
     }
     return StructType({
         read: FunctionType([], stateType),
         status: FunctionType([], DatasetStatusType),
         history: FunctionType([], OptionType(ArrayType(RecordCommitInfoType))),
         mutate: StructType(mutateFields),
+        commit: StructType(commitFields),
         start: FunctionType([], NullType),
         binding: RecordBindingType,
     });
@@ -166,6 +206,7 @@ export const recordBindPlatformFn = East.genericPlatform("record_bind", ["H"], [
 // `record_mutate` is generic over the per-mutation `ArgsStruct` `A` (the N args
 // bundled into one struct, since platform fns are fixed-arity): the impl recovers
 // the per-arg types from `A`'s fields and the values from the passed struct.
+// `record_commit` is its awaited sibling, which takes the write's request id too.
 const record_read = East.genericPlatform("record_read", ["T"], [StringType], "T", { optional: true });
 const record_status = East.platform("record_status", [StringType], DatasetStatusType, { optional: true });
 const record_history = East.platform("record_history", [StringType], OptionType(ArrayType(RecordCommitInfoType)), { optional: true });
@@ -175,6 +216,7 @@ const record_mutate_status = East.platform("record_mutate_status", [StringType],
 const record_mutate_error = East.platform("record_mutate_error", [StringType], OptionType(RecordErrorType), { optional: true });
 const record_mutate_cancel = East.platform("record_mutate_cancel", [StringType], NullType, { optional: true });
 const record_mutate = East.genericPlatform("record_mutate", ["A"], [StringType, StringType, "A"], NullType, { optional: true });
+const record_commit = East.asyncGenericPlatform("record_commit", ["A"], [StringType, StringType, StringType, "A"], RecordOutcomeType, { optional: true });
 /**
  * Low-level platform primitives that back {@link Record.bind}'s handle methods.
  *
@@ -201,6 +243,8 @@ export const RecordBindPrimitives = {
     mutateCancel: record_mutate_cancel,
     /** `record_mutate([ArgsStruct], recordName, mutationName, argsStruct) -> Null`. */
     mutate: record_mutate,
+    /** `record_commit([ArgsStruct], recordName, mutationName, requestId, argsStruct) ~> RecordOutcome` — the awaited write. */
+    commit: record_commit,
 };
 // ============================================================================
 // User-facing factory.
@@ -267,20 +311,216 @@ function bindRecord(record, mutations) {
     const nameValue = East.value(record.name, StringType);
     return recordBindPlatformFn([handleType], nameValue);
 }
+/**
+ * An awaited write's outcome as the editing session's answer. A commit is
+ * applied at the record state it wrote, which a pinned source installs; a
+ * conflict carries the issues naming what went stale; anything else refused
+ * the write. A call that got no answer may have committed, so it throws: the
+ * session keeps the request, and its retry sends the same request id, which
+ * resolves to that commit rather than writing twice.
+ */
+const settleWrite = East.function([RecordOutcomeType, ArrayType(Editing.Types.Issue)], Editing.Types.ApplyResult, ($, outcome, conflicts) => {
+    const result = $.let(variant("conflict", conflicts), Editing.Types.ApplyResult);
+    $.match(outcome, {
+        committed: ($, done) => { $.assign(result, variant("applied", { revision: some(done.stateHash) })); },
+        invalid: ($, refused) => {
+            $.assign(result, variant("rejected", [{ entry: "", row: none, field: none, message: refused.message }]));
+        },
+        failed: ($, refused) => {
+            $.assign(result, variant("rejected", [{ entry: "", row: none, field: none, message: East.str `The write failed: ${refused.stderr}` }]));
+        },
+        timed_out: ($, refused) => {
+            $.assign(result, variant("rejected", [{ entry: "", row: none, field: none, message: East.str `The write ran out of time after ${refused.ms} ms and wrote nothing` }]));
+        },
+        transport: ($, lost) => {
+            $.error(East.str `The write got no answer, so it may have committed — retry to find out: ${lost.message}`);
+        },
+    });
+    return result;
+});
+function applyToRecord(handle, options = {}) {
+    const fields = Expr.type(handle).fields;
+    const recordType = fields["read"].output;
+    if (recordType.type !== "Dict") {
+        throw new Error(`Record.onApply: an Apply writes a record's entries by key, so the record must be a Dict — ` +
+            `this one holds ${printType(recordType)}`);
+    }
+    const mutation = options.mutation ?? "patch";
+    const commits = fields["commit"];
+    const door = commits?.type === "Struct" ? commits.fields[mutation] : undefined;
+    if (door === undefined || !isTypeEqual(door, AsyncFunctionType([StringType, PatchType(recordType)], RecordOutcomeType))) {
+        throw new Error(`Record.onApply: "${mutation}" is not bound as this record's patch door — bind the record with ` +
+            `e3.mutation.patch(record${mutation === "patch" ? "" : `, "${mutation}"`}) among its mutations`);
+    }
+    // The handle's fields as the Apply reads them; entries are opaque here, as
+    // in Editing.apply, and their runtime types are exact.
+    const bound = handle;
+    const write = bound.commit[mutation];
+    // Who changed the record last, for a conflict's words. A conflict reads the
+    // history again before the write settles, so it is current.
+    const lastChange = East.function([], StringType, (_$) => bound.history().match({
+        some: (_$2, commits) => commits.tryGet(0n).match({
+            some: (_$3, head) => East.str ` — last changed by ${head.actor}`,
+            none: (_$3) => East.str ``,
+        }),
+        none: (_$2) => East.str ``,
+    }));
+    if ("entry" in options) {
+        const entryType = recordType.value;
+        const get = East.value(options.get);
+        const read = Expr.type(get);
+        if (read.type !== "Function" || read.inputs.length !== 1 || !isTypeEqual(read.inputs[0], entryType)
+            || read.output.type !== "Array" || read.output.value.type !== "Struct") {
+            throw new Error("Record.onApply: `get` must be an East function from the record's entry to an Array of row structs");
+        }
+        const rowType = read.output.value;
+        const rowsType = ArrayType(rowType);
+        const set = East.value(options.set);
+        const replace = Expr.type(set);
+        if (replace.type !== "Function" || replace.inputs.length !== 2 || !isTypeEqual(replace.inputs[0], entryType)
+            || !isTypeEqual(replace.inputs[1], rowsType) || !isTypeEqual(replace.output, entryType)) {
+            throw new Error("Record.onApply: `set` must be an East function from the record's entry and its new rows to the entry");
+        }
+        const entryKey = East.value(options.entry, recordType.key);
+        const apply = Editing.apply(rowType, options.idField);
+        return East.asyncFunction([Editing.Types.ChangeSet(rowType)], Editing.Types.ApplyResult, ($, batch) => {
+            const rowsOf = $.const(get);
+            const withRows = $.const(set);
+            const applyRows = $.const(apply);
+            const commit = $.const(write);
+            const settle = $.const(settleWrite);
+            const changedBy = $.const(lastChange);
+            const key = $.const(entryKey);
+            const result = $.let(variant("conflict", []), Editing.Types.ApplyResult);
+            $.match(batch.base, {
+                revision: ($) => {
+                    $.assign(result, variant("rejected", [{ entry: "", row: none, field: none,
+                            message: "Rows inside a record entry are checked against the rows the edit began from — a snapshot, never a revision" }]));
+                },
+                snapshot: ($, rows) => {
+                    $.match(bound.read().tryGet(key), {
+                        none: ($) => {
+                            $.assign(result, variant("conflict", [{ entry: "", row: none, field: none,
+                                    message: East.str `The entry was removed since this edit began${changedBy()}` }]));
+                        },
+                        some: ($, current) => {
+                            $.match(applyRows(rows, batch, none), {
+                                conflict: ($, issues) => { $.assign(result, variant("conflict", issues)); },
+                                applied: ($, next) => {
+                                    const now = $.const(rowsOf(current));
+                                    // Moved since the edit began — unless to this very edit's
+                                    // rows, which a retry after an unanswered write finds.
+                                    $.if(East.notEqual(now, rows).and(() => East.notEqual(now, next)), ($) => {
+                                        $.assign(result, variant("conflict", [{ entry: "", row: none, field: none,
+                                                message: East.str `The entry changed since this edit began${changedBy()}` }]));
+                                    }).else(($) => {
+                                        // The entry before and after the edit, each alone in a record:
+                                        // their diff reaches the entry's rows and nothing else.
+                                        const before = $.let(new Map(), recordType);
+                                        $(before.insert(key, withRows(current, rows)));
+                                        const after = $.let(new Map(), recordType);
+                                        $(after.insert(key, withRows(current, next)));
+                                        const outcome = $.const(commit(batch.requestId, East.diff(before, after)));
+                                        const conflicts = $.let([], ArrayType(Editing.Types.Issue));
+                                        $.match(outcome, {
+                                            conflict: ($) => {
+                                                $(conflicts.pushLast({ entry: "", row: none, field: none,
+                                                    message: East.str `The entry changed since this edit began${changedBy()}` }));
+                                            },
+                                        });
+                                        $.assign(result, settle(outcome, conflicts));
+                                    });
+                                },
+                            });
+                        },
+                    });
+                },
+            });
+            return result;
+        });
+    }
+    const keyType = recordType.key;
+    const entryType = recordType.value;
+    const batchType = "keyed" in options && options.keyed === true
+        ? Editing.Types.ChangeSet(entryType, keyType)
+        : Editing.Types.ChangeSet(entryType);
+    // A change names its entry by the key's text: a String key is its own
+    // text, any other key its `.east` printing, read back here.
+    const keyOf = keyType.type === "String"
+        ? East.function([StringType], StringType, (_$, id) => id)
+        : East.function([StringType], keyType, (_$, id) => id.parse(keyType));
+    return East.asyncFunction([batchType], Editing.Types.ApplyResult, ($, batch) => {
+        const keyFrom = $.const(keyOf);
+        const commit = $.const(write);
+        const settle = $.const(settleWrite);
+        const changedBy = $.const(lastChange);
+        // Each change is its entry's insert, update or delete, restated by key.
+        // The values and entry patches are the batch's own, carrying what each
+        // entry was when the edit began, which the record checks.
+        const ops = $.let(new Map(), DictType(keyType, dictPatchOpsType(entryType)));
+        $.for(batch.changes, ($, change) => {
+            const key = $.const(keyFrom(change.id));
+            $.match(change.patch, {
+                replace: ($, swap) => {
+                    $.match(swap.after, {
+                        some: ($, after) => {
+                            $.match(swap.before, {
+                                none: ($) => { $(ops.insert(key, variant("insert", after))); },
+                                some: ($, before) => { $(ops.insert(key, variant("update", East.diff(before, after)))); },
+                            });
+                        },
+                        none: ($) => {
+                            $.match(swap.before, { some: ($, before) => { $(ops.insert(key, variant("delete", before))); } });
+                        },
+                    });
+                },
+                patch: ($, entry) => {
+                    $.match(entry, { some: ($, update) => { $(ops.insert(key, variant("update", update))); } });
+                },
+            });
+        });
+        const outcome = $.const(commit(batch.requestId, variant("patch", ops)));
+        const conflicts = $.let([], ArrayType(Editing.Types.Issue));
+        $.match(outcome, {
+            conflict: ($) => {
+                // The entries whose change no longer applies to the record as it
+                // stands are the ones another write moved.
+                const current = $.const(bound.read());
+                const by = $.const(changedBy());
+                $.for(batch.changes, ($, change) => {
+                    const key = $.const(keyFrom(change.id));
+                    $.try(($) => {
+                        $(East.applyPatch(current.tryGet(key), change.patch));
+                    }).catch(($) => {
+                        $(conflicts.pushLast({ entry: change.id, row: none, field: none, message: East.str `Changed since this edit began${by}` }));
+                    });
+                });
+                $.if(conflicts.size().equal(0n), ($) => {
+                    $(conflicts.pushLast({ entry: "", row: none, field: none, message: East.str `The record changed since this edit began${by}` }));
+                });
+            },
+        });
+        return settle(outcome, conflicts);
+    });
+}
 /**
  * The Record namespace — reactive record (read + mutate + history) binding for
- * e3 UI tasks.
+ * e3 UI tasks, and the Apply that commits an editable collection to a record.
  *
  * @remarks
  * `Record.bind` binds an `e3.record` and its mutations to a handle: `read` /
  * `status` / `history` observe the record's current state (served from the
  * shared dataset cache), and `mutate.<name>` applies a typed mutation
- * fire-and-forget under compare-and-swap, refreshing `read()` on commit.
+ * fire-and-forget under compare-and-swap, refreshing `read()` on commit;
+ * `commit.<name>` is the same write awaited. `Record.onApply` commits a
+ * Sheet's, a Plan's or a SnapGrid's batches to the record, each Apply one commit
+ * through its patch door.
  *
  * Use inside `Reactive.Root` for reactive re-rendering as the record and the
  * mutation lifecycle change.
  */
 export const Record = {
     bind: bindRecord,
+    onApply: applyToRecord,
 };
 //# sourceMappingURL=record.js.map