@elaraai/e3-ui 1.0.12 → 1.0.14

package/dist/src/{data.d.ts → bind/data.d.ts}

@@ -66,6 +66,11 @@ export type DiffBindingType = typeof DiffBindingType;
  * @property writeAndStart - Like `write`, but kicks the workspace dataflow
  *   so downstream tasks recompute. Only meaningful when `mode = "direct"`
  *   and `patch` is absent — in other modes it falls back to `write`.
+ * @property start - Launch the workspace dataflow on its own, without
+ *   writing first, so downstream tasks recompute against the current
+ *   datasets. The standalone half of `writeAndStart`; queued behind any
+ *   pending writes, so `write(v)` then `start()` propagates the new value.
+ *   Always returns null.
  * @property source - Read the raw source value with no overlay applied.
  * @property pending - True when there is an in-flight change waiting to be
  *   committed. Always false in `mode = "direct"` without a `patch` dataset.
@@ -82,6 +87,7 @@ export declare const DataBindHandleType: <T extends EastType | string>(t: T) =>
     readonly read: FunctionType<[], T>;
     readonly write: FunctionType<[T], NullType>;
     readonly writeAndStart: FunctionType<[T], NullType>;
+    readonly start: FunctionType<[], NullType>;
     readonly source: FunctionType<[], T>;
     readonly pending: FunctionType<[], BooleanType>;
     readonly commit: FunctionType<[], NullType>;
@@ -143,6 +149,7 @@ export declare const bindPlatformFn: import("@elaraai/east").GenericPlatformDefi
     readonly read: FunctionType<[], "T">;
     readonly write: FunctionType<["T"], NullType>;
     readonly writeAndStart: FunctionType<["T"], NullType>;
+    readonly start: FunctionType<[], NullType>;
     readonly source: FunctionType<[], "T">;
     readonly pending: FunctionType<[], BooleanType>;
     readonly commit: FunctionType<[], NullType>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/bind/data.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AAEH,OAAO,EAEH,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACX,UAAU,EAIV,KAAK,QAAQ,EACb,KAAK,QAAQ,EAChB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAMvD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;EAG3B,CAAC;AACH,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAEvD,uDAAuD;AACvD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;EAI1B,CAAC;AACH,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAMrD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,GAAG,MAAM,EAAE,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYlE,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,QAAQ,IAAI,QAAQ,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAMhG;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkB1B,CAAC;AAMF;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC5B,2DAA2D;IAC3D,IAAI,CAAC,EAAG,mBAAmB,CAAC;IAC5B;0EACsE;IACtE,KAAK,CAAC,EAAE,UAAU,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,iBAAS,QAAQ,CAAC,CAAC,SAAS,QAAQ,EAChC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACnC,OAAO,CAAC,EAAE,eAAe,GAC1B,UAAU,CAAC,CAAC,CAAC,CAYf;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI;;CAEP,CAAC"}

package/dist/src/{data.js → bind/data.js}

@@ -59,6 +59,11 @@ export const DiffBindingType = StructType({
  * @property writeAndStart - Like `write`, but kicks the workspace dataflow
  *   so downstream tasks recompute. Only meaningful when `mode = "direct"`
  *   and `patch` is absent — in other modes it falls back to `write`.
+ * @property start - Launch the workspace dataflow on its own, without
+ *   writing first, so downstream tasks recompute against the current
+ *   datasets. The standalone half of `writeAndStart`; queued behind any
+ *   pending writes, so `write(v)` then `start()` propagates the new value.
+ *   Always returns null.
  * @property source - Read the raw source value with no overlay applied.
  * @property pending - True when there is an in-flight change waiting to be
  *   committed. Always false in `mode = "direct"` without a `patch` dataset.
@@ -75,6 +80,7 @@ export const DataBindHandleType = (t) => StructType({
     read: FunctionType([], t),
     write: FunctionType([t], NullType),
     writeAndStart: FunctionType([t], NullType),
+    start: FunctionType([], NullType),
     source: FunctionType([], t),
     pending: FunctionType([], BooleanType),
     commit: FunctionType([], NullType),
@@ -96,6 +102,7 @@ export const bindPlatformFn = East.genericPlatform("data_bind", ["T"], [TreePath
     read: FunctionType([], "T"),
     write: FunctionType(["T"], NullType),
     writeAndStart: FunctionType(["T"], NullType),
+    start: FunctionType([], NullType),
     source: FunctionType([], "T"),
     pending: FunctionType([], BooleanType),
     commit: FunctionType([], NullType),

package/dist/src/bind/data.js.map

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"func.d.ts","sourceRoot":"","sources":["../../../src/bind/func.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAEH,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,KAAK,QAAQ,EACb,KAAK,QAAQ,EAChB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc;;;;;;EAMzB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;EAWxB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;EAE1B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAMrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,EAAE,EAAE,CAAC,SAAS,QAAQ,EACvE,QAAQ,CAAC,GAAG,CAAC,CAAC,EACd,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASX,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,EAAE,CAAC,SAAS,QAAQ,IAC1D,QAAQ,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAM1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,+FAM9B,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,iBAAS,YAAY,CAAC,MAAM,SAAS,QAAQ,EAAE,EAAE,MAAM,SAAS,QAAQ,EACpE,EAAE,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAO3B;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI;;CAEP,CAAC"}

package/dist/src/bind/func.js.map

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

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

@@ -0,0 +1,275 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Reactive record binding for e3 UI tasks — read an `e3.record`'s current
+ * state and apply its typed mutations from East UI code.
+ *
+ * `Record.bind` is the record-shaped sibling of `Data.bind` / `Func.bind`,
+ * adapting the TanStack query/mutation split to East's reactive,
+ * fire-and-forget model: `read` / `status` / `history` observe the record (the
+ * read side, served from the shared dataset cache), while `mutate.<name>(…)`
+ * launches a typed mutation fire-and-forget (the write side), with
+ * `mutate.pending` / `status` / `error` / `cancel` tracking the shared,
+ * 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.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BooleanType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type ExprType } from '@elaraai/east';
+import { DatasetStatusType, RecordCommitInfoType } from '@elaraai/e3-types';
+import type { RecordDef, MutationDef } from '@elaraai/e3';
+/**
+ * Shared mutate-lifecycle tag for a bound record. One launch channel per
+ * record (mutations serialize via CAS), latest-wins.
+ *
+ * @remarks
+ * Client-defined. `idle` means no mutation has been launched through this
+ * binding; `cancelled` means the client stopped waiting (via `cancel()` or a
+ * superseding mutation) — the server's CAS reducer still ran to completion.
+ *
+ * @property idle - No mutation launched
+ * @property running - A mutation is in flight
+ * @property committed - The most recent mutation committed a new commit
+ * @property failed - The most recent mutation failed (see `error`)
+ * @property cancelled - The client stopped waiting for the most recent mutation
+ */
+export declare const RecordMutateStatusType: VariantType<{
+    readonly idle: NullType;
+    readonly running: NullType;
+    readonly committed: NullType;
+    readonly failed: NullType;
+    readonly cancelled: NullType;
+}>;
+/** Type representing the {@link RecordMutateStatusType} structure. */
+export type RecordMutateStatusType = typeof RecordMutateStatusType;
+/**
+ * Failure detail for a bound mutation, mirroring the server's
+ * `MutationResult` non-committed outcome arms plus client-side transport
+ * errors — the record-side analogue of `FuncError`.
+ *
+ * @property kind - Which way the mutation failed:
+ *   `invalid` (lookup/arity/signature), `failed` (reducer exited non-zero),
+ *   `too_large` (new state exceeded the server limit), `timed_out` (reducer
+ *   deadline hit), `conflict` (the compare-and-swap lost the race), `transport`
+ *   (HTTP/decode failure — never reached the server).
+ * @property message - One-line human-readable summary, always present
+ * @property stderr - Captured reducer stderr (empty unless the reducer ran)
+ */
+export declare const RecordErrorType: StructType<{
+    readonly kind: VariantType<{
+        readonly invalid: StructType<{
+            readonly message: StringType;
+        }>;
+        readonly failed: StructType<{
+            readonly exitCode: IntegerType;
+        }>;
+        readonly too_large: StructType<{
+            readonly bytes: IntegerType;
+            readonly limit: IntegerType;
+        }>;
+        readonly timed_out: StructType<{
+            readonly ms: IntegerType;
+        }>;
+        readonly conflict: StructType<{
+            readonly attempts: IntegerType;
+        }>;
+        readonly transport: StructType<{
+            readonly message: StringType;
+        }>;
+    }>;
+    readonly message: StringType;
+    readonly stderr: StringType;
+}>;
+/** Type representing the {@link RecordErrorType} structure. */
+export type RecordErrorType = typeof RecordErrorType;
+/**
+ * Descriptor for a record binding — carried on the handle's `binding` field
+ * for inspector surfaces.
+ *
+ * @property name - The bound record's name in the deployed package
+ * @property mutations - The mutation names this binding exposes
+ */
+export declare const RecordBindingType: StructType<{
+    readonly name: StringType;
+    readonly mutations: ArrayType<StringType>;
+}>;
+/** Type representing the {@link RecordBindingType} structure. */
+export type RecordBindingType = typeof RecordBindingType;
+/**
+ * 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.
+ *
+ * @remarks
+ * The handle's shape IS the signature: the runtime recovers the state type
+ * from `read`'s output and each mutation's name + arg types from the `mutate`
+ * sub-struct's fields, so there are no duplicate signature arguments to drift.
+ *
+ * @typeParam T - The record's East state type.
+ * @typeParam M - Map of mutation name to its extra positional arg types.
+ * @param stateType - The record's state East type.
+ * @param mutations - Map of mutation name to its arg types.
+ * @returns The handle StructType for that record + mutation set.
+ *
+ * @property read - The record's current committed state. Reactive — re-fires
+ *   when a mutation commits (the dataset cache refreshes the record's bytes).
+ * @property status - Per-dataset freshness signal — see {@link DatasetStatusType}.
+ * @property history - The commit chain, newest first; `none` until the first
+ *   load completes, then the cached chain (refreshed after each commit).
+ * @property mutate - The write surface: one fire-and-forget closure per
+ *   mutation (typed from its def), plus the shared `pending` / `status` /
+ *   `error` / `cancel`.
+ * @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
+ *   bytes but does not propagate downstream until a dataflow run; call this
+ *   (e.g. from a Run button) to drive that run. Always returns null.
+ * @property binding - Descriptor for this binding — see {@link RecordBindingType}.
+ */
+export declare const RecordBindHandleType: <T extends EastType, M extends Record<string, EastType[]>>(stateType: T, mutations: M) => StructType<{
+    readonly read: FunctionType<[], T>;
+    readonly status: FunctionType<[], VariantType<{
+        readonly unset: NullType;
+        readonly stale: NullType;
+        readonly 'up-to-date': NullType;
+    }>>;
+    readonly history: FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: import("@elaraai/east").DateTimeType;
+    }>>>>;
+    readonly mutate: StructType<Record<string, EastType>>;
+    readonly start: FunctionType<[], NullType>;
+    readonly binding: StructType<{
+        readonly name: StringType;
+        readonly mutations: ArrayType<StringType>;
+    }>;
+}>;
+/**
+ * Map of each mutation's name (literal) to its extra positional arg types,
+ * recovered structurally from a tuple of {@link MutationDef}s.
+ */
+type MutationsArgMap<Muts extends readonly MutationDef<string, EastType, EastType[]>[]> = {
+    [M in Muts[number] as M['name']]: M extends MutationDef<string, EastType, infer A> ? [...A] : never;
+};
+/**
+ * The precise East struct type of a record handle — written as a mapped type
+ * (rather than inferred from {@link RecordBindHandleType}'s runtime loop, which
+ * TS widens) so each `mutate.<name>` closure keeps its arg types.
+ */
+type RecordHandle<T extends EastType, M extends Record<string, EastType[]>> = StructType<{
+    read: FunctionType<[], T>;
+    status: FunctionType<[], typeof DatasetStatusType>;
+    history: FunctionType<[], OptionType<ArrayType<typeof RecordCommitInfoType>>>;
+    mutate: StructType<{
+        pending: FunctionType<[], typeof BooleanType>;
+        status: FunctionType<[], RecordMutateStatusType>;
+        error: FunctionType<[], OptionType<RecordErrorType>>;
+        cancel: FunctionType<[], typeof NullType>;
+    } & {
+        [K in keyof M]: FunctionType<M[K], typeof NullType>;
+    }>;
+    start: FunctionType<[], typeof NullType>;
+    binding: RecordBindingType;
+}>;
+/**
+ * The TypeScript type of a {@link Record.bind} handle bound to a record of
+ * state type `T` with mutations `Muts` — i.e. the return of
+ * `Record.bind(record, [...mutations])`.
+ *
+ * @remarks
+ * The mutation names + arg types live structurally in the `mutate` field's
+ * closure signatures (recovered from the {@link MutationDef} tuple), not a
+ * phantom TS brand, so they survive `$.let` / `$.const` and ordinary
+ * expression plumbing.
+ *
+ * @typeParam T - The record's East state type.
+ * @typeParam Muts - The bound mutation defs (their names + arg types).
+ */
+export type BoundRecord<T extends EastType, Muts extends readonly MutationDef<string, T, EastType[]>[]> = ExprType<RecordHandle<T, MutationsArgMap<Muts>>>;
+/**
+ * The underlying `Record.bind` platform-function definition. End-users should
+ * call {@link Record.bind} (the typed factory in this module); runtime
+ * implementations register against this raw definition via
+ * `recordBindPlatformFn.implement(...)`.
+ *
+ * @remarks
+ * Generic over `H`, the fully-instantiated handle struct — its shape IS the
+ * signature (the runtime recovers the state type from `read` and the mutation
+ * names + arg types from `mutate`). The single literal argument is the record
+ * name; the record's dataset path is reconstructed runtime-side, and mutation
+ * names are validated against the deployed record signature.
+ */
+export declare const recordBindPlatformFn: import("@elaraai/east").GenericPlatformDefinition<readonly ["H"], readonly [StringType], "H">;
+/**
+ * Bind an `e3.record` and its mutations to a reactive read/mutate handle.
+ *
+ * Takes the {@link RecordDef} returned by `e3.record` plus the array of its
+ * {@link MutationDef}s — the state type comes from the record, and each
+ * mutation's name and arg types come from its def, the same way `Func.bind`
+ * takes a function's signature from its `FunctionDef`. The binding is correct
+ * by construction: it cannot drift from the deployed record's mutations.
+ *
+ * @typeParam T - The record's state East type (from the def).
+ * @typeParam Muts - The mutation defs to expose (names + arg types from defs).
+ * @param record - The `e3.record` definition to bind.
+ * @param mutations - The mutations to expose on `handle.mutate`.
+ * @returns A handle struct described by {@link RecordBindHandleType} —
+ *   `read` / `status` / `history` / `mutate.{<name>,pending,status,error,cancel}`
+ *   / `binding`.
+ *
+ * @remarks
+ * The launch/observe split is the same shape `Func.bind` uses for `call`:
+ * `mutate.<name>` never blocks, and everything you'd want back arrives through
+ * `read` / `mutate.status` / `mutate.error` on the next reactive render. A
+ * committed mutation auto-refreshes `read()` (the record's dataset bytes are
+ * re-fetched) — no manual invalidation. All handles bound to the same record
+ * in the same workspace share one mutation channel.
+ *
+ * @example
+ * ```ts
+ * import { East, IntegerType, NullType } from "@elaraai/east";
+ * import { Button, Reactive, Stat, UIComponentType, VStack } from "@elaraai/east-ui";
+ * import { Record } from "@elaraai/e3-ui";
+ * import e3 from "@elaraai/e3";
+ *
+ * const counter = e3.record("counter", IntegerType, 0n);
+ * const increment = e3.mutation("increment", counter,
+ *     East.function([IntegerType, IntegerType], IntegerType, ($, state, by) => state.add(by)));
+ *
+ * const counterUi = East.function([], UIComponentType, _$ =>
+ *     Reactive.Root(East.function([], UIComponentType, $ => {
+ *         const r = $.let(Record.bind(counter, [increment]));
+ *         const bump = $.const(East.function([], NullType, $ => { $(r.mutate.increment(1n)); }));
+ *         return VStack.Root([
+ *             Stat.Root({ label: "Counter", value: East.print(r.read()) }),
+ *             Button.Root("Increment", { onClick: bump, loading: r.mutate.pending() }),
+ *         ], { gap: "3" });
+ *     })));
+ * ```
+ */
+declare function bindRecord<T extends EastType, Muts extends readonly MutationDef<string, T, EastType[]>[]>(record: RecordDef<T>, mutations: [...Muts]): BoundRecord<T, Muts>;
+/**
+ * The Record namespace — reactive record (read + mutate + history) binding for
+ * e3 UI tasks.
+ *
+ * @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.
+ *
+ * Use inside `Reactive.Root` for reactive re-rendering as the record and the
+ * mutation lifecycle change.
+ */
+export declare const Record: {
+    readonly bind: typeof bindRecord;
+};
+export {};
+//# sourceMappingURL=record.d.ts.map

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

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

package/dist/src/bind/record.js

@@ -0,0 +1,239 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Reactive record binding for e3 UI tasks — read an `e3.record`'s current
+ * state and apply its typed mutations from East UI code.
+ *
+ * `Record.bind` is the record-shaped sibling of `Data.bind` / `Func.bind`,
+ * adapting the TanStack query/mutation split to East's reactive,
+ * fire-and-forget model: `read` / `status` / `history` observe the record (the
+ * read side, served from the shared dataset cache), while `mutate.<name>(…)`
+ * launches a typed mutation fire-and-forget (the write side), with
+ * `mutate.pending` / `status` / `error` / `cancel` tracking the shared,
+ * 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.
+ *
+ * @packageDocumentation
+ */
+import { East, ArrayType, BooleanType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, } from '@elaraai/east';
+import { DatasetStatusType, RecordCommitInfoType } from '@elaraai/e3-types';
+// ============================================================================
+// Status + error + descriptor types
+// ============================================================================
+/**
+ * Shared mutate-lifecycle tag for a bound record. One launch channel per
+ * record (mutations serialize via CAS), latest-wins.
+ *
+ * @remarks
+ * Client-defined. `idle` means no mutation has been launched through this
+ * binding; `cancelled` means the client stopped waiting (via `cancel()` or a
+ * superseding mutation) — the server's CAS reducer still ran to completion.
+ *
+ * @property idle - No mutation launched
+ * @property running - A mutation is in flight
+ * @property committed - The most recent mutation committed a new commit
+ * @property failed - The most recent mutation failed (see `error`)
+ * @property cancelled - The client stopped waiting for the most recent mutation
+ */
+export const RecordMutateStatusType = VariantType({
+    idle: NullType,
+    running: NullType,
+    committed: NullType,
+    failed: NullType,
+    cancelled: NullType,
+});
+/**
+ * Failure detail for a bound mutation, mirroring the server's
+ * `MutationResult` non-committed outcome arms plus client-side transport
+ * errors — the record-side analogue of `FuncError`.
+ *
+ * @property kind - Which way the mutation failed:
+ *   `invalid` (lookup/arity/signature), `failed` (reducer exited non-zero),
+ *   `too_large` (new state exceeded the server limit), `timed_out` (reducer
+ *   deadline hit), `conflict` (the compare-and-swap lost the race), `transport`
+ *   (HTTP/decode failure — never reached the server).
+ * @property message - One-line human-readable summary, always present
+ * @property stderr - Captured reducer stderr (empty unless the reducer ran)
+ */
+export const RecordErrorType = StructType({
+    kind: VariantType({
+        invalid: StructType({ message: StringType }),
+        failed: StructType({ exitCode: IntegerType }),
+        too_large: StructType({ bytes: IntegerType, limit: IntegerType }),
+        timed_out: StructType({ ms: IntegerType }),
+        conflict: StructType({ attempts: IntegerType }),
+        transport: StructType({ message: StringType }),
+    }),
+    message: StringType,
+    stderr: StringType,
+});
+/**
+ * Descriptor for a record binding — carried on the handle's `binding` field
+ * for inspector surfaces.
+ *
+ * @property name - The bound record's name in the deployed package
+ * @property mutations - The mutation names this binding exposes
+ */
+export const RecordBindingType = StructType({
+    name: StringType,
+    mutations: ArrayType(StringType),
+});
+// ============================================================================
+// Bind handle — return type of `Record.bind`.
+// ============================================================================
+/**
+ * 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.
+ *
+ * @remarks
+ * The handle's shape IS the signature: the runtime recovers the state type
+ * from `read`'s output and each mutation's name + arg types from the `mutate`
+ * sub-struct's fields, so there are no duplicate signature arguments to drift.
+ *
+ * @typeParam T - The record's East state type.
+ * @typeParam M - Map of mutation name to its extra positional arg types.
+ * @param stateType - The record's state East type.
+ * @param mutations - Map of mutation name to its arg types.
+ * @returns The handle StructType for that record + mutation set.
+ *
+ * @property read - The record's current committed state. Reactive — re-fires
+ *   when a mutation commits (the dataset cache refreshes the record's bytes).
+ * @property status - Per-dataset freshness signal — see {@link DatasetStatusType}.
+ * @property history - The commit chain, newest first; `none` until the first
+ *   load completes, then the cached chain (refreshed after each commit).
+ * @property mutate - The write surface: one fire-and-forget closure per
+ *   mutation (typed from its def), plus the shared `pending` / `status` /
+ *   `error` / `cancel`.
+ * @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
+ *   bytes but does not propagate downstream until a dataflow run; call this
+ *   (e.g. from a Run button) to drive that run. Always returns null.
+ * @property binding - Descriptor for this binding — see {@link RecordBindingType}.
+ */
+export const RecordBindHandleType = (stateType, mutations) => {
+    const mutateFields = {
+        pending: FunctionType([], BooleanType),
+        status: FunctionType([], RecordMutateStatusType),
+        error: FunctionType([], OptionType(RecordErrorType)),
+        cancel: FunctionType([], NullType),
+    };
+    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);
+    }
+    return StructType({
+        read: FunctionType([], stateType),
+        status: FunctionType([], DatasetStatusType),
+        history: FunctionType([], OptionType(ArrayType(RecordCommitInfoType))),
+        mutate: StructType(mutateFields),
+        start: FunctionType([], NullType),
+        binding: RecordBindingType,
+    });
+};
+// ============================================================================
+// Platform function — single generic over the instantiated handle type.
+// ============================================================================
+/**
+ * The underlying `Record.bind` platform-function definition. End-users should
+ * call {@link Record.bind} (the typed factory in this module); runtime
+ * implementations register against this raw definition via
+ * `recordBindPlatformFn.implement(...)`.
+ *
+ * @remarks
+ * Generic over `H`, the fully-instantiated handle struct — its shape IS the
+ * signature (the runtime recovers the state type from `read` and the mutation
+ * names + arg types from `mutate`). The single literal argument is the record
+ * name; the record's dataset path is reconstructed runtime-side, and mutation
+ * names are validated against the deployed record signature.
+ */
+export const recordBindPlatformFn = East.genericPlatform("record_bind", ["H"], [StringType], "H", { optional: true });
+// ============================================================================
+// User-facing factory.
+// ============================================================================
+/**
+ * Bind an `e3.record` and its mutations to a reactive read/mutate handle.
+ *
+ * Takes the {@link RecordDef} returned by `e3.record` plus the array of its
+ * {@link MutationDef}s — the state type comes from the record, and each
+ * mutation's name and arg types come from its def, the same way `Func.bind`
+ * takes a function's signature from its `FunctionDef`. The binding is correct
+ * by construction: it cannot drift from the deployed record's mutations.
+ *
+ * @typeParam T - The record's state East type (from the def).
+ * @typeParam Muts - The mutation defs to expose (names + arg types from defs).
+ * @param record - The `e3.record` definition to bind.
+ * @param mutations - The mutations to expose on `handle.mutate`.
+ * @returns A handle struct described by {@link RecordBindHandleType} —
+ *   `read` / `status` / `history` / `mutate.{<name>,pending,status,error,cancel}`
+ *   / `binding`.
+ *
+ * @remarks
+ * The launch/observe split is the same shape `Func.bind` uses for `call`:
+ * `mutate.<name>` never blocks, and everything you'd want back arrives through
+ * `read` / `mutate.status` / `mutate.error` on the next reactive render. A
+ * committed mutation auto-refreshes `read()` (the record's dataset bytes are
+ * re-fetched) — no manual invalidation. All handles bound to the same record
+ * in the same workspace share one mutation channel.
+ *
+ * @example
+ * ```ts
+ * import { East, IntegerType, NullType } from "@elaraai/east";
+ * import { Button, Reactive, Stat, UIComponentType, VStack } from "@elaraai/east-ui";
+ * import { Record } from "@elaraai/e3-ui";
+ * import e3 from "@elaraai/e3";
+ *
+ * const counter = e3.record("counter", IntegerType, 0n);
+ * const increment = e3.mutation("increment", counter,
+ *     East.function([IntegerType, IntegerType], IntegerType, ($, state, by) => state.add(by)));
+ *
+ * const counterUi = East.function([], UIComponentType, _$ =>
+ *     Reactive.Root(East.function([], UIComponentType, $ => {
+ *         const r = $.let(Record.bind(counter, [increment]));
+ *         const bump = $.const(East.function([], NullType, $ => { $(r.mutate.increment(1n)); }));
+ *         return VStack.Root([
+ *             Stat.Root({ label: "Counter", value: East.print(r.read()) }),
+ *             Button.Root("Increment", { onClick: bump, loading: r.mutate.pending() }),
+ *         ], { gap: "3" });
+ *     })));
+ * ```
+ */
+function bindRecord(record, mutations) {
+    const mutMap = {};
+    for (const m of mutations) {
+        if (m.record.name !== record.name) {
+            throw new Error(`Record.bind: mutation "${m.name}" writes record "${m.record.name}", not "${record.name}".`);
+        }
+        mutMap[m.name] = [...m.argTypes];
+    }
+    const handleType = RecordBindHandleType(record.type, mutMap);
+    // The record name must be a single literal Value IR node — the only shape
+    // manifest derivation (`derive.ts`) handles. `record.name` is a static JS
+    // string at IR-build time, so this holds by construction.
+    const nameValue = East.value(record.name, StringType);
+    return recordBindPlatformFn([handleType], nameValue);
+}
+/**
+ * The Record namespace — reactive record (read + mutate + history) binding for
+ * e3 UI tasks.
+ *
+ * @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.
+ *
+ * Use inside `Reactive.Root` for reactive re-rendering as the record and the
+ * mutation lifecycle change.
+ */
+export const Record = {
+    bind: bindRecord,
+};
+//# sourceMappingURL=record.js.map

package/dist/src/bind/record.js.map

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

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

@@ -28,7 +28,7 @@
  */
 import { ArrayType, DictType, OptionType, StructType, VariantType, FunctionType, StringType, IntegerType, NullType, type EastType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
 import { SliceStateType } from '@elaraai/east-ui/internal';
-import { type BoundValue } from '../data.js';
+import { type BoundValue } from '../bind/data.js';
 import { DecisionType, DecisionConstraintType } from './types.js';
 /**
  * The derived commit gate for one case — a pure function of the decision's