@playfast/reform 0.0.4 → 0.0.7

package/{src/ui/trigger.ts → dist/ui/trigger.d.ts}

@@ -3,4 +3,5 @@
  * (High priority) through the runtime. The UI never sees Effect — it just calls
  * `events.submit({ text })`.
  */
-export type Trigger<P> = (payload: P) => void
+export type Trigger<P> = (payload: P) => void;
+//# sourceMappingURL=trigger.d.ts.map

package/dist/ui/trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../src/ui/trigger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAA"}

package/dist/ui/trigger.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trigger.js.map

package/dist/ui/trigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.js","sourceRoot":"","sources":["../../src/ui/trigger.ts"],"names":[],"mappings":""}

package/dist/wire/tree.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The serializable model of a rendered UI tree, and the pure diff/apply over it.
+ *
+ * This is the renderer-neutral heart of the remote transport (REMOTE_UI.md §3):
+ * the server renders a scene to a `WireTree`, sends `diff(prev, next)` as
+ * `WirePatch`es, and the client folds them back with `apply`. No React, no
+ * Effect — pure data, so both ends and the proofs share one source of truth.
+ */
+/**
+ * A prop on a wire node: either an already-encoded data value, or a handle the
+ * client invokes to fire the server-side trigger (resolved by the trigger
+ * registry, REMOTE_UI.md §4). Streams, when added, become a third arm.
+ */
+export type WireProp = {
+    readonly _tag: 'Data';
+    readonly name: string;
+    readonly value: unknown;
+} | {
+    readonly _tag: 'Event';
+    readonly name: string;
+    readonly handle: string;
+};
+/** One rendered UI contract instance, identified stably across frames. */
+export interface WireNode {
+    /** Stable identity across renders — the unit of diffing. */
+    readonly id: string;
+    /** The UI contract name (`UiCapture.name`) the client looks up a presentation by. */
+    readonly name: string;
+    /** Parent node id, or `null` for a root. */
+    readonly parentId: string | null;
+    /** Order among siblings under the same parent. */
+    readonly childIndex: number;
+    /** The slot name this node fills in its parent, or `null` for a root / direct child. */
+    readonly slot: string | null;
+    /**
+     * The React `key` the parent gave this slot child (`createElement(slots.Row, { key })`),
+     * or `null` when none was set. It is the per-child identity a KEYED slot selects on: the
+     * client renders `<slots.Row slotKey={id} />` and the slot thunk picks the one wire child
+     * whose `key` matches, instead of rendering every child of that slot at every call site.
+     * Without it the client slot is render-all-children (correct for singleton slots, wrong for
+     * a list slot invoked once per item — it duplicates the whole list under each call).
+     */
+    readonly key: string | null;
+    readonly props: ReadonlyArray<WireProp>;
+}
+export type WireTree = ReadonlyArray<WireNode>;
+/** A change to apply to a client's tree: upsert a node, or drop one by id. */
+export type WirePatch = {
+    readonly _tag: 'Upsert';
+    readonly node: WireNode;
+} | {
+    readonly _tag: 'Delete';
+    readonly id: string;
+};
+/**
+ * The patches that turn `previous` into `next`. Deletes precede upserts so a
+ * client never holds a child whose reparented slot was freed in the same frame.
+ */
+export declare const diff: (previous: WireTree, next: WireTree) => ReadonlyArray<WirePatch>;
+/** Fold patches into a client's tree (the receiving side's reducer). */
+export declare const apply: (state: WireTree, patches: ReadonlyArray<WirePatch>) => WireTree;
+/** The root nodes of a tree, in sibling order. */
+export declare const roots: (tree: WireTree) => WireTree;
+/** The children of a node, in sibling order. */
+export declare const childrenOf: (tree: WireTree, parentId: string) => WireTree;
+//# sourceMappingURL=tree.d.ts.map

package/dist/wire/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../src/wire/tree.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACzE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9E,0EAA0E;AAC1E,MAAM,WAAW,QAAQ;IACvB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,qFAAqF;IACrF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,wFAAwF;IACxF,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CACxC;AAED,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;AAE9C,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAoCpD;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,UAAU,QAAQ,EAAE,MAAM,QAAQ,KAAG,aAAa,CAAC,SAAS,CAahF,CAAA;AAQD,wEAAwE;AACxE,eAAO,MAAM,KAAK,GAAI,OAAO,QAAQ,EAAE,SAAS,aAAa,CAAC,SAAS,CAAC,KAAG,QASxE,CAAA;AAEH,kDAAkD;AAClD,eAAO,MAAM,KAAK,GAAI,MAAM,QAAQ,KAAG,QACoD,CAAA;AAE3F,gDAAgD;AAChD,eAAO,MAAM,UAAU,GAAI,MAAM,QAAQ,EAAE,UAAU,MAAM,KAAG,QACiC,CAAA"}

package/dist/wire/tree.js

@@ -0,0 +1,60 @@
+import { Match } from 'effect';
+const arraysEqual = (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]));
+const recordsEqual = (a, b) => {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return aKeys.length === bKeys.length && aKeys.every((key) => deepEqual(a[key], b[key]));
+};
+/** Structural equality over serializable wire values (and the tagged props that carry them). */
+const deepEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    if (Array.isArray(a))
+        return Array.isArray(b) && arraysEqual(a, b);
+    if (Array.isArray(b))
+        return false;
+    if (typeof a === 'object' && typeof b === 'object') {
+        return recordsEqual(a, b);
+    }
+    return false;
+};
+const nodesEqual = (a, b) => a.name === b.name &&
+    a.parentId === b.parentId &&
+    a.childIndex === b.childIndex &&
+    a.slot === b.slot &&
+    a.key === b.key &&
+    deepEqual(a.props, b.props);
+const isUnchanged = (node, previousById) => {
+    const previous = previousById.get(node.id);
+    return previous !== undefined && nodesEqual(previous, node);
+};
+/**
+ * The patches that turn `previous` into `next`. Deletes precede upserts so a
+ * client never holds a child whose reparented slot was freed in the same frame.
+ */
+export const diff = (previous, next) => {
+    const previousById = new Map(previous.map((node) => [node.id, node]));
+    const nextById = new Map(next.map((node) => [node.id, node]));
+    const deletes = previous
+        .filter((node) => !nextById.has(node.id))
+        .map((node) => ({ _tag: 'Delete', id: node.id }));
+    const upserts = next
+        .filter((node) => !isUnchanged(node, previousById))
+        .map((node) => ({ _tag: 'Upsert', node }));
+    return [...deletes, ...upserts];
+};
+const upsertNode = (state, node) => {
+    const index = state.findIndex((existing) => existing.id === node.id);
+    if (index < 0)
+        return [...state, node];
+    return [...state.slice(0, index), node, ...state.slice(index + 1)];
+};
+/** Fold patches into a client's tree (the receiving side's reducer). */
+export const apply = (state, patches) => patches.reduce((current, patch) => Match.value(patch).pipe(Match.tag('Delete', ({ id }) => current.filter((node) => node.id !== id)), Match.tag('Upsert', ({ node }) => upsertNode(current, node)), Match.exhaustive), state);
+/** The root nodes of a tree, in sibling order. */
+export const roots = (tree) => tree.filter((node) => node.parentId === null).sort((a, b) => a.childIndex - b.childIndex);
+/** The children of a node, in sibling order. */
+export const childrenOf = (tree, parentId) => tree.filter((node) => node.parentId === parentId).sort((a, b) => a.childIndex - b.childIndex);
+//# sourceMappingURL=tree.js.map

package/dist/wire/tree.js.map

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

package/dist/wire/triggers.d.ts

@@ -0,0 +1,44 @@
+import { type Cause, Context, Effect, Layer, type ParseResult, Schema } from 'effect';
+import type { Trigger } from '../ui/trigger';
+/**
+ * The server-side bridge for trigger handles (REMOTE_UI.md §4). A rendered
+ * `WireProp` of `_tag: 'Event'` carries a `handle`; the client invokes it by
+ * sending `(handle, encodedPayload)`. Here we hold the live `Trigger` and its
+ * payload schema, decode the wire payload, and fire — so the UI never ships a
+ * function, only a handle, and the payload is validated at the seam.
+ *
+ * Handles are caller-provided keys, by convention `${nodeId}:${eventName}`: a
+ * re-render re-`register`s the same handle with that frame's fresh trigger, so the
+ * handle is stable across frames (the client's in-flight handle stays valid) and
+ * the handle space never grows. The schema is the contract's own per-event wire
+ * schema (`WiredUiManifest.events`, Phase 1) — the single source of truth for the
+ * UI boundary, decoupled from which `Event` the composition binds behind it.
+ */
+export type TriggerHandle = string;
+declare const UnknownTriggerBase: new (args: {
+    readonly handle: TriggerHandle;
+}) => Cause.YieldableError & {
+    readonly _tag: 'reform/UnknownTrigger';
+} & Readonly<{
+    readonly handle: TriggerHandle;
+}>;
+/** A wire message named a trigger handle the server no longer holds (a stale client). */
+export declare class UnknownTrigger extends UnknownTriggerBase {
+    get message(): string;
+}
+export interface TriggerRegistryApi {
+    /** Register (or overwrite) a trigger + its payload schema under a handle key. */
+    readonly register: <P>(handle: TriggerHandle, trigger: Trigger<P>, schema: Schema.Schema<P, any>) => Effect.Effect<void>;
+    /** Decode an encoded payload via the handle's schema and fire the trigger. */
+    readonly invoke: (handle: TriggerHandle, encodedPayload: unknown) => Effect.Effect<void, UnknownTrigger | ParseResult.ParseError>;
+    /** Drop a handle once its node unmounts (the Phase 2 tree diff signals it). */
+    readonly revoke: (handle: TriggerHandle) => Effect.Effect<void>;
+}
+declare const TriggerRegistryBase: Context.TagClass<TriggerRegistry, 'reform/wire/TriggerRegistry', TriggerRegistryApi>;
+export declare class TriggerRegistry extends TriggerRegistryBase {
+}
+export declare const make: Effect.Effect<TriggerRegistryApi>;
+/** Provide a fresh registry — one per remote connection (each client gets its own handle space). */
+export declare const layer: Layer.Layer<TriggerRegistry>;
+export {};
+//# sourceMappingURL=triggers.d.ts.map

package/dist/wire/triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggers.d.ts","sourceRoot":"","sources":["../../src/wire/triggers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAE,KAAK,WAAW,EAAO,MAAM,EAAE,MAAM,QAAQ,CAAA;AAChG,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAA;AAUlC,QAAA,MAAM,kBAAkB,EAAE,KAAK,IAAI,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAAE,KAAK,KAAK,CAAC,cAAc,GAAG;IACjG,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAA;CACvC,GAAG,QAAQ,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAAE,CAE7C,CAAA;AAEF,yFAAyF;AACzF,qBAAa,cAAe,SAAQ,kBAAkB;IACpD,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EACnB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,KAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,CACf,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,OAAO,KACpB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;IACjE,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAChE;AAED,QAAA,MAAM,mBAAmB,EAAE,OAAO,CAAC,QAAQ,CACzC,eAAe,EACf,6BAA6B,EAC7B,kBAAkB,CACiE,CAAA;AAErF,qBAAa,eAAgB,SAAQ,mBAAmB;CAAG;AAE3D,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,kBAAkB,CA6BjD,CAAA;AAEF,oGAAoG;AACpG,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,eAAe,CAAuC,CAAA"}

package/dist/wire/triggers.js

@@ -0,0 +1,31 @@
+import { Context, Data, Effect, Layer, Ref, Schema } from 'effect';
+const UnknownTriggerBase = (Data.TaggedError('reform/UnknownTrigger'));
+/** A wire message named a trigger handle the server no longer holds (a stale client). */
+export class UnknownTrigger extends UnknownTriggerBase {
+    get message() {
+        return `reform: no trigger registered under handle '${this.handle}'`;
+    }
+}
+const TriggerRegistryBase = Context.Tag('reform/wire/TriggerRegistry')();
+export class TriggerRegistry extends TriggerRegistryBase {
+}
+export const make = Effect.gen(function* () {
+    const entries = yield* Ref.make(new Map());
+    const register = (handle, trigger, schema) => Ref.update(entries, (map) => new Map(map).set(handle, { trigger, schema }));
+    const invoke = (handle, encodedPayload) => Effect.gen(function* () {
+        const entry = (yield* Ref.get(entries)).get(handle);
+        if (entry === undefined)
+            return yield* Effect.fail(new UnknownTrigger({ handle }));
+        const payload = yield* Schema.decodeUnknown(entry.schema)(encodedPayload);
+        entry.trigger(payload);
+    });
+    const revoke = (handle) => Ref.update(entries, (map) => {
+        const next = new Map(map);
+        next.delete(handle);
+        return next;
+    });
+    return { register, invoke, revoke };
+});
+/** Provide a fresh registry — one per remote connection (each client gets its own handle space). */
+export const layer = Layer.effect(TriggerRegistry, make);
+//# sourceMappingURL=triggers.js.map

package/dist/wire/triggers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggers.js","sourceRoot":"","sources":["../../src/wire/triggers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAoB,GAAG,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AA4BhG,MAAM,kBAAkB,GAE2B,CAAA,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAEzF,CAAA,CAAA;AAEF,yFAAyF;AACzF,MAAM,OAAO,cAAe,SAAQ,kBAAkB;IACpD,IAAa,OAAO;QAClB,OAAO,+CAA+C,IAAI,CAAC,MAAM,GAAG,CAAA;IACtE,CAAC;CACF;AAkBD,MAAM,mBAAmB,GAIrB,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,EAAuC,CAAA;AAErF,MAAM,OAAO,eAAgB,SAAQ,mBAAmB;CAAG;AAE3D,MAAM,CAAC,MAAM,IAAI,GAAsC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IACzE,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,EAA+B,CAAC,CAAA;IAEvE,MAAM,QAAQ,GAAG,CACf,MAAqB,EACrB,OAAmB,EACnB,MAA6B,EACR,EAAE,CACvB,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAA;IAE7E,MAAM,MAAM,GAAG,CACb,MAAqB,EACrB,cAAuB,EACuC,EAAE,CAChE,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACnD,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAA;QAClF,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,CAAA;QACzE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IACxB,CAAC,CAAC,CAAA;IAEJ,MAAM,MAAM,GAAG,CAAC,MAAqB,EAAuB,EAAE,CAC5D,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;QAC1B,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAA;QACzB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QACnB,OAAO,IAAI,CAAA;IACb,CAAC,CAAC,CAAA;IAEJ,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;AACrC,CAAC,CAAC,CAAA;AAEF,oGAAoG;AACpG,MAAM,CAAC,MAAM,KAAK,GAAiC,KAAK,CAAC,MAAM,CAAC,eAAe,EAAE,IAAI,CAAC,CAAA"}

package/package.json

@@ -1,24 +1,45 @@
 {
   "name": "@playfast/reform",
-  "version": "0.0.4",
+  "playbook": "./playbook",
+  "version": "0.0.7",
   "type": "module",
-  "sideEffects": [],
+  "description": "The renderer-neutral core of the reform framework — typed, headless state, events, reducers, derived values, async/remote data, and compositions built on Effect.",
+  "keywords": [
+    "reform",
+    "effect",
+    "state-management",
+    "headless",
+    "framework",
+    "reactive"
+  ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/playfast/reform.git",
+    "directory": "packages/reform"
+  },
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
+  "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./*": "./src/*.ts"
   },
   "files": [
-    "src",
-    "README.md",
-    "!src/**/*.test.ts",
-    "!src/**/*.test.tsx",
-    "!src/**/*.typecheck.ts",
-    "!src/**/*.typecheck.tsx"
+    "dist",
+    "README.md"
   ],
   "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "clean": "rm -rf dist .tsbuildinfo",
+    "check": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint --fix src"
   },
   "peerDependencies": {
     "effect": "*",

package/src/boundary/boundary.ts

@@ -1,192 +0,0 @@
-import { Context, Data, Effect, Layer, MutableRef, Predicate } from 'effect'
-import { type Manifest, yieldableClass } from '../definition/definition'
-import { resolveScheduler } from '../internal/scheduler'
-import { type InputStores, sameKey, wireSources } from '../internal/sources'
-import { makeDerivedStore, type Store } from '../internal/store'
-import { readTracked } from '../internal/track'
-import { type Source } from '../state/token'
-
-// Boundary: the Suspense-boundary analog, value-level. One derived store that
-// merges the lifecycles of several async sources into a single
-// Pending/Errored/Ready value, so ONE surface (a splash, a skeleton) covers a
-// whole subtree's first load instead of every query consumer painting its own.
-//
-// Reform can do this without React's throw-a-promise machinery because
-// fetching is layer-driven, not render-driven: an `AsyncCalc` runs because its
-// layer is built, never because something rendered. A boundary therefore only
-// *aggregates* lifecycles — it cannot create render-waterfalls, and content it
-// reveals already has its data.
-//
-// The arm mapping IS the semantics, and most of it falls out of `AsyncData`:
-//   Loading            → Pending  (the arm only exists before the first value,
-//                                  so a boundary is first-load-only by construction)
-//   Success            → Ready    (even `refetching: true` — SWR refetches never
-//                                  re-show the fallback; no transition machinery)
-//   Idle               → Ready    (a gated query that is off is DELIBERATELY off —
-//                                  a signed-out viewer must not wait on a query
-//                                  that only runs signed-in)
-//   Error              → Errored  (the error-boundary half, also value-level)
-//
-// Chained gates (B enables when A succeeds) cannot leak a Ready between hops:
-// the boundary's layer requires every covered store, so each driver subscribes
-// upstream BEFORE the boundary does, the scheduler flush runs listeners in
-// subscription order to a fixpoint within one microtask, and reads are
-// pull-fresh — by the time any subscriber reads, the next hop is already
-// Loading. `boundary.test.ts` pins this with a recorded-notification proof.
-
-/** Some covered source is still on its FIRST load — show the fallback. */
-export interface BoundaryPending {
-  readonly _tag: 'Pending'
-}
-
-/** Some covered source failed before its first value. */
-export interface BoundaryErrored {
-  readonly _tag: 'Errored'
-  /** The failures, in `over` order (heterogeneous — display via `String`). */
-  readonly errors: ReadonlyArray<unknown>
-}
-
-/** Every covered source has settled (or is deliberately gated off). */
-export interface BoundaryReady {
-  readonly _tag: 'Ready'
-}
-
-export type BoundaryState = BoundaryPending | BoundaryErrored | BoundaryReady
-
-// Stable arm references: repeated recomputes return the same object, so the
-// derived store's Equal gate (and `useSyncExternalStore`'s stable-snapshot
-// contract) hold without a wrapper. `Errored` carries data, so it is a `Data`
-// struct — value-equal failures coalesce the same way.
-const pendingArm: BoundaryState = { _tag: 'Pending' }
-const readyArm: BoundaryState = { _tag: 'Ready' }
-const erroredArm = (errors: ReadonlyArray<unknown>): BoundaryState =>
-  Data.struct({ _tag: 'Errored' as const, errors: Data.array(errors) })
-
-/**
- * Anything a boundary can cover: a `Source` whose value is an async lifecycle —
- * an `AsyncCalc`, or anything lifecycle-valued built over one (e.g. a
- * `RemoteState` overlay). The constraint is the same erased `Source` every calc
- * input uses (store invariance rules out a fixed lifecycle value type — each
- * definition's union carries its own `Gated`/`E` arms); the captured `const`
- * tuple keeps each member's precise store requirement, and the runtime merge
- * reads arms through structural guards, so a non-lifecycle source simply
- * counts as settled.
- */
-export type AnyLifecycleSource = Source<string, any>
-
-export interface BoundaryManifest<N extends string> extends Manifest {
-  readonly kind: 'Boundary'
-  readonly name: N
-}
-
-export interface BoundaryClass<out N extends string, out Over extends ReadonlyArray<AnyLifecycleSource>>
-  extends Effect.Effect<BoundaryState, never, Store<BoundaryState>> {
-  new (): {}
-  readonly manifest: BoundaryManifest<N>
-  readonly store: Context.Tag<Store<BoundaryState>, Store<BoundaryState>>
-  /** The boundary's name, so it doubles as a `Source` input to a calc. */
-  readonly name: N
-  /** The covered lifecycle sources — read by `live` and the editor's graph. */
-  readonly over: Over
-}
-
-export interface BoundaryConfig<Over extends ReadonlyArray<AnyLifecycleSource>> {
-  readonly over: Over
-}
-
-export interface BoundaryOptions {
-  /**
-   * Latch: once Ready, stay Ready. A BOOT boundary wants this — a covered
-   * route-gated query that first enables on a later navigation (Idle →
-   * Loading) must not re-splash the whole shell; its own screen owns that
-   * loading state. Without the latch the boundary re-pends on any covered
-   * first load, which is what a per-screen boundary wants.
-   */
-  readonly once?: boolean
-}
-
-/**
- * Define a boundary over async sources. `yield* MyBoundary` reads the merged
- * `Pending | Errored | Ready` lifecycle; the consuming view renders ONE
- * fallback on Pending and its content slot on Ready — content reveals
- * together, with data already present (fetching never waited on rendering).
- */
-export const make = <const N extends string, const Over extends ReadonlyArray<AnyLifecycleSource>>(
-  name: N,
-  config: BoundaryConfig<Over>,
-): BoundaryClass<N, Over> => {
-  const store = Context.GenericTag<Store<BoundaryState>, Store<BoundaryState>>(
-    `reform/boundary/${name}`,
-  )
-  const manifest: BoundaryManifest<N> = { kind: 'Boundary', name }
-  const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name, over: config.over })
-}
-
-// The snapshot values arrive through `wireSources`' erased key projection
-// (`ReadonlyArray<unknown>`), so read the two facts the merge needs through
-// honest structural guards — no cast back to `AnyAsyncData`.
-const tagOf = (arm: unknown): string =>
-  Predicate.hasProperty(arm, '_tag') && Predicate.isString(arm._tag) ? arm._tag : ''
-const errorOf = (arm: unknown): ReadonlyArray<unknown> =>
-  Predicate.hasProperty(arm, 'error') && tagOf(arm) === 'Error' ? [arm.error] : []
-
-/**
- * Wire the merge. A derived store over the covered stores (sensed through the
- * same `wireSources` plumbing every calc uses): recomputes are memoized on the
- * input snapshots and the arms are stable references, so input churn that does
- * not move the merged arm wakes nobody.
- */
-export const live = <N extends string, Over extends ReadonlyArray<AnyLifecycleSource>>(
-  boundary: BoundaryClass<N, Over>,
-  options: BoundaryOptions = {},
-): Layer.Layer<Store<BoundaryState>, never, InputStores<Over>> =>
-  // Scoped so the source subscriptions are released with the layer's scope.
-  Layer.scoped(
-    boundary.store,
-    Effect.gen(function* () {
-      const scheduler = yield* resolveScheduler
-      const sources = yield* wireSources(boundary.over)
-
-      const latched = MutableRef.make(false)
-      const memo = MutableRef.make<
-        { readonly key: ReadonlyArray<unknown>; readonly value: BoundaryState } | undefined
-      >(undefined)
-      const recompute = (): BoundaryState => {
-        if (options.once === true && MutableRef.get(latched)) return readyArm
-        const arms = sources.keyOf(sources.snapshot())
-        const prev = MutableRef.get(memo)
-        if (prev !== undefined && sameKey(arms, prev.key)) return prev.value
-        const errors = arms.flatMap(errorOf)
-        const value =
-          errors.length > 0
-            ? erroredArm(errors)
-            : arms.some((arm) => tagOf(arm) === 'Loading')
-              ? pendingArm
-              : readyArm
-        MutableRef.set(memo, { key: arms, value })
-        return value
-      }
-
-      const derived = makeDerivedStore(recompute, sources.subscribe, scheduler)
-      yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
-
-      if (options.once === true) {
-        // Latch on CONVERGED values only — at build and on (coalesced,
-        // post-fixpoint) notifications — never inside `recompute`. A chained
-        // gate with a plain Calc hop between the async stores (bootstrap →
-        // current-workspace → boards) propagates over TWO flush rounds, so a
-        // mid-flush recompute can observe the frame where the downstream
-        // driver has not yet flipped its query to Loading. That intermediate
-        // Ready self-corrects within the flush for readers, but a latch taken
-        // there would freeze it; a subscriber runs only after the fixpoint,
-        // where the value is converged.
-        if (recompute()._tag === 'Ready') MutableRef.set(latched, true)
-        const offSelf = derived.store.subscribe(() => {
-          if (derived.store.get()._tag === 'Ready') MutableRef.set(latched, true)
-        })
-        yield* Effect.addFinalizer(() => Effect.sync(offSelf))
-      }
-      return derived.store
-    }),
-  )