@playfast/reform 0.0.1

package/README.md

@@ -0,0 +1,64 @@
+# `reform` — core
+
+The renderer-neutral primitives and runtime. Renders nothing itself (that is
+`@reform/react`); the whole core is headless and testable without a DOM.
+
+## What's here (v0)
+
+Every primitive follows the **definition / implementation split**: `X.make(…)`
+is a reflectable definition (a manifest + DI tag), provided separately by
+`.live`. Nothing self-registers on
+import.
+
+| primitive                                | definition                          | implementation        |
+| ---------------------------------------- | ----------------------------------- | --------------------- |
+| `State` / `StateGroup` / `StateFamily`   | `State.make(name, schema, opts)`    | `.live`               |
+| `Event` / `EventGroup`                   | `Event.make(name, schema)`          | — (pure data)         |
+| `Reducer`                                | `Reducer.make(name, { states/family, events })` | `.live(fold)` |
+| `Calc`                                   | `Calc.make(name, { inputs, output })` | `.live(fn)`    |
+| `AsyncCalc`                              | `AsyncCalc.make(name, { inputs, output, error?, alwaysOn? })` | `.live({ query })` |
+| `RemoteState`                            | `RemoteState.make(name, { inputs, output, error?, alwaysOn?, intents })` | `.live({ query, send, apply, … })` |
+| `Procedure`                              | `Procedure.make(name, { events, concurrency })` | `.live(fn*)` |
+| `Composition`                            | `Composition.make(name, manifest)`  | `.live(fn*)`     |
+| `ui` / `slot`                            | `ui(name)<C>()` / `slot(name)<P>()` | `.make` / `provide`   |
+
+## The model
+
+```
+UI trigger ──► Bus (High) ─┐
+                           ├─► reduce loop ──► reducers (the only writers) ──► stores
+procedure  ──► Bus (Normal)┘                          │
+   ▲                                                   ▼
+   └────────────── reads state, dispatches ◄──── calc (derived, memoized)
+```
+
+- **State** lives in plain reactive stores outside Effect; `set` is internal, so
+  reducers (which only *return* values) are the sole writers by construction.
+- **The bus** is one bounded `PubSub`. A central loop drains it and runs matching
+  reducers per event; **procedures** consume it on their own forked fibers with a
+  concurrency policy (`latest` = switch, `merge` = unbounded).
+- **Reads** (`yield* group.state('x')`, `yield* Calc`, `family.at(k).read`) return
+  the current snapshot. The yieldable class trick (a class whose static prototype
+  is an Effect) is what lets `yield* VisibleTodos` return the derived value.
+- **Derived reads** take any `Source` as input (a state member, a `Calc`, or an
+  `AsyncCalc`) and accept an optional `invalidateBy` queryKey projection that
+  bounds recompute/re-fetch to a value-equal key change. `AsyncCalc` yields an
+  `AsyncData` query lifecycle (`Idle`/`Loading`/`Success`/`Error`), matched with
+  `effect`'s `Match`.
+- **Remote state is derived-only.** `RemoteState` is server-owned state with
+  optimistic mutations: the only writer is the server, the only write surface is
+  dispatching one of the declared intent events, and the visible value is
+  `pending.reduce(apply, serverTruth)`. A failed or settled intent leaves the
+  queue and the derivation converges — no rollback machinery. Settles obey the
+  generation rule (an intent acked at query-run generation g settles only on a
+  later-generation `Success` run), so an optimistic change never flickers out
+  between the RPC confirm and the refetch landing.
+- **Notifications** coalesce into one microtask flush (the React bridge will bind
+  `getSnapshot`/`subscribe`).
+
+## Status
+
+Engine complete and proven headless (see `examples/todo/src/app/engine.test.ts`):
+boot → load → add → toggle → filter flows through events, procedures, reducers
+and the calc, and a composition renders against a capturing UI. React rendering,
+the editor and proofs are the next phases.

package/dist/cjs/boundary/boundary.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.live = exports.make = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const scheduler_js_1 = require("../internal/scheduler.js");
+const sources_js_1 = require("../internal/sources.js");
+const store_js_1 = require("../internal/store.js");
+const track_js_1 = require("../internal/track.js");
+// 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 = { _tag: 'Pending' };
+const readyArm = { _tag: 'Ready' };
+const erroredArm = (errors) => effect_1.Data.struct({ _tag: 'Errored', errors: effect_1.Data.array(errors) });
+/**
+ * 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).
+ */
+const make = (name, config) => {
+    const store = effect_1.Context.GenericTag(`reform/boundary/${name}`);
+    const manifest = { kind: 'Boundary', name };
+    const read = effect_1.Effect.flatMap(store, track_js_1.readTracked);
+    return (0, definition_js_1.yieldableClass)(read, { manifest, store, name, over: config.over });
+};
+exports.make = make;
+// 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) => effect_1.Predicate.hasProperty(arm, '_tag') && effect_1.Predicate.isString(arm._tag) ? arm._tag : '';
+const errorOf = (arm) => effect_1.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.
+ */
+const live = (boundary, options = {}) => 
+// Scoped so the source subscriptions are released with the layer's scope.
+effect_1.Layer.scoped(boundary.store, effect_1.Effect.gen(function* () {
+    const scheduler = yield* scheduler_js_1.resolveScheduler;
+    const sources = yield* (0, sources_js_1.wireSources)(boundary.over);
+    const latched = effect_1.MutableRef.make(false);
+    const memo = effect_1.MutableRef.make(undefined);
+    const recompute = () => {
+        if (options.once === true && effect_1.MutableRef.get(latched))
+            return readyArm;
+        const arms = sources.keyOf(sources.snapshot());
+        const prev = effect_1.MutableRef.get(memo);
+        if (prev !== undefined && (0, sources_js_1.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;
+        effect_1.MutableRef.set(memo, { key: arms, value });
+        return value;
+    };
+    const derived = (0, store_js_1.makeDerivedStore)(recompute, sources.subscribe, scheduler);
+    yield* effect_1.Effect.addFinalizer(() => effect_1.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')
+            effect_1.MutableRef.set(latched, true);
+        const offSelf = derived.store.subscribe(() => {
+            if (derived.store.get()._tag === 'Ready')
+                effect_1.MutableRef.set(latched, true);
+        });
+        yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(offSelf));
+    }
+    return derived.store;
+}));
+exports.live = live;

package/dist/cjs/calc/asyncCalc.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.make = void 0;
+exports.live = live;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const queryDriver_js_1 = require("../internal/queryDriver.js");
+const track_js_1 = require("../internal/track.js");
+const Reducer = __importStar(require("../reducer/reducer.js"));
+const loop_js_1 = require("../runtime/loop.js");
+const State = __importStar(require("../state/state.js"));
+const asyncData_js_1 = require("./asyncData.js");
+/**
+ * Define an async derived value. `output`/`error` schemas and `alwaysOn` shape
+ * the value type, so `yield* MyQuery` is typed to exactly the arms that can
+ * occur. The query effect itself is supplied by `AsyncCalc.live`.
+ */
+const make = (name, config) => {
+    const store = effect_1.Context.GenericTag(`reform/asyncCalc/${name}`);
+    // Runtime mirror of the type-level `Gated`, typed as its literal in one place.
+    const gated = (0, queryDriver_js_1.gatedFlag)(config.alwaysOn);
+    const manifest = {
+        kind: 'AsyncCalc',
+        name,
+        output: config.output,
+        gated,
+        ...(config.error !== undefined ? { error: config.error } : {}),
+    };
+    const read = effect_1.Effect.flatMap(store, track_js_1.readTracked);
+    return (0, definition_js_1.yieldableClass)(read, {
+        manifest,
+        store,
+        name,
+        inputs: config.inputs,
+        gated,
+    });
+};
+exports.make = make;
+function live(calc, config) {
+    // The hidden revision pair, built once per `live` call. Namespacing the state
+    // by the calc's name (`reform/state/${calcName}/invalidateOn`) keeps the tag
+    // out of any plausible user namespace; the duplicate-reducer check is
+    // warning-only and calc names are unique by convention.
+    const revisionState = config.invalidateOn === undefined
+        ? undefined
+        : State.make(`${calc.manifest.name}/invalidateOn`, queryDriver_js_1.RevisionSchema);
+    // Scoped so the source subscriptions and the driver fiber are released when
+    // the layer's scope closes (each proof/test builds and disposes its runtime).
+    const driver = effect_1.Layer.scoped(calc.store, effect_1.Effect.gen(function* () {
+        // `disabled` is rejected at the type level for non-gated calcs (erased to
+        // `never` there); read it through a loose view for the runtime.
+        const cfg = config;
+        // The hidden revision store, read requirement-free (`serviceOption`): the
+        // assembly below always provides it alongside this driver, and feeding it
+        // through `extraKey` (not `wireSources`) keeps it out of the snapshot —
+        // the user's `query` and `invalidateBy` receive exactly
+        // `InputsObject<Inputs>`, with no hidden property to leak into
+        // spread-into-RPC payloads.
+        const revision = revisionState === undefined
+            ? undefined
+            : effect_1.Option.getOrUndefined(yield* effect_1.Effect.serviceOption(revisionState.store));
+        const driver = yield* (0, queryDriver_js_1.makeQueryDriver)({
+            name: calc.manifest.name,
+            label: 'AsyncCalc',
+            gated: calc.gated,
+            inputs: calc.inputs,
+            query: cfg.query,
+            invalidateBy: cfg.invalidateBy,
+            disabled: cfg.disabled,
+            coalesce: cfg.coalesce,
+            reuse: cfg.reuse,
+            extraKey: revision === undefined
+                ? undefined
+                : {
+                    read: () => revision.getSnapshot(),
+                    subscribe: (listener) => revision.subscribe(listener),
+                },
+        });
+        // The internal store is the full union; narrow to the definition's arms.
+        return (0, asyncData_js_1.narrowStore)(driver.store);
+    }));
+    if (config.invalidateOn === undefined || revisionState === undefined)
+        return driver;
+    // The hidden reducer: an ordinary `Reducer` folding every listed event to
+    // n + 1 — the revision's sole writer, registered/unregistered with this
+    // layer's scope like any user reducer. `Layer.provide` builds the hidden
+    // state once and feeds the same store to both the driver and the reducer,
+    // while the outer context (user inputs, the `Reducers` registry) passes
+    // through untouched.
+    const revisionReducer = Reducer.make(`${calc.manifest.name}/invalidateOn`, {
+        states: [revisionState],
+        events: config.invalidateOn,
+    });
+    return effect_1.Layer.merge(driver, Reducer.live(revisionReducer, queryDriver_js_1.bumpRevision)).pipe(effect_1.Layer.provide(State.live(revisionState, queryDriver_js_1.revisionZero)));
+}

package/dist/cjs/calc/asyncData.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.widenStore = exports.narrowStore = exports.AsyncData = void 0;
+const idle = { _tag: 'Idle' };
+const loading = { _tag: 'Loading' };
+const success = (value, refetching = false) => ({
+    _tag: 'Success',
+    value,
+    refetching,
+});
+const error = (err, refetching = false) => ({
+    _tag: 'Error',
+    error: err,
+    refetching,
+});
+/**
+ * Constructors for the arms, namespaced under the same name as the type so call
+ * sites read `AsyncData.success(v)` / `AsyncData.error(e)` — no `error` import
+ * shadowing the keyword and one obvious home for every arm.
+ */
+exports.AsyncData = { idle, loading, success, error };
+/**
+ * Narrow the live store (which holds the full `AnyAsyncData` union) to the arms
+ * the definition actually permits (`Gated`/`E`). The single documented home for
+ * that narrowing, so `AsyncCalc.live` returns it without an inline cast.
+ */
+const narrowStore = (store) => store;
+exports.narrowStore = narrowStore;
+/**
+ * The read-only inverse of `narrowStore`: widen a definition-narrowed store back
+ * to the full union, so a consumer (the `RemoteState` overlay) can dispatch on the
+ * lifecycle arms without carrying the definition's `Gated`/`E` conditionals.
+ * Sound for reads only — every narrowed value IS an `AnyAsyncData` — so callers
+ * must never `set` through the widened view (derived stores ignore `set` anyway).
+ */
+const widenStore = (store) => store;
+exports.widenStore = widenStore;

package/dist/cjs/calc/calc.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.live = exports.make = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const sources_js_1 = require("../internal/sources.js");
+const scheduler_js_1 = require("../internal/scheduler.js");
+const reuse_js_1 = require("../internal/reuse.js");
+const store_js_1 = require("../internal/store.js");
+const track_js_1 = require("../internal/track.js");
+/**
+ * A derived, memoized value over explicit inputs (state members, other calcs, or
+ * async calcs). The *definition* fixes the inputs and the output schema; the
+ * *implementation* is the pure projection. Recomputes only when an input changes;
+ * `yield* Calc` reads the memoized value.
+ */
+const make = (name, config) => {
+    const store = effect_1.Context.GenericTag(`reform/calc/${name}`);
+    const manifest = { kind: 'Calc', name, output: config.output };
+    const read = effect_1.Effect.flatMap(store, track_js_1.readTracked);
+    return (0, definition_js_1.yieldableClass)(read, { manifest, store, name, inputs: config.inputs });
+};
+exports.make = make;
+/**
+ * Wire the pure projection for a calc. Recomputes only when its invalidation key
+ * changes (by default every input value; override with `invalidateBy`), memoized
+ * on that key; `yield* Calc` reads the memoized value. The derived store reuses
+ * the shared coalescing scheduler, so a recompute that yields an equal value
+ * wakes no subscriber.
+ */
+const live = (calc, compute, options = {}) => 
+// Scoped so the source subscriptions are released when the layer's scope
+// closes (each proof/test builds and disposes its own runtime).
+effect_1.Layer.scoped(calc.store, effect_1.Effect.gen(function* () {
+    const scheduler = yield* scheduler_js_1.resolveScheduler;
+    const sources = yield* (0, sources_js_1.wireSources)(calc.inputs, options.invalidateBy);
+    // Memo cell: key and output captured together so reads are always
+    // consistent (no separate output that could lag the key it was computed for).
+    const memo = effect_1.MutableRef.make(undefined);
+    const recompute = () => {
+        const args = sources.snapshot();
+        const key = sources.keyOf(args);
+        const prev = effect_1.MutableRef.get(memo);
+        if (prev !== undefined && (0, sources_js_1.sameKey)(key, prev.key))
+            return prev.output;
+        const fresh = compute(args);
+        // With `reuse`, a recompute that lands value-equal to the previous
+        // output returns the previous reference — the derived store's Equal
+        // gate then wakes no subscriber at all.
+        const output = options.reuse === true && prev !== undefined ? (0, reuse_js_1.reuse)(prev.output, fresh) : fresh;
+        effect_1.MutableRef.set(memo, { key, output });
+        return output;
+    };
+    const derived = (0, store_js_1.makeDerivedStore)(recompute, sources.subscribe, scheduler);
+    yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(derived.unsubscribe));
+    return derived.store;
+}));
+exports.live = live;

package/dist/cjs/calc/calcFamily.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.live = exports.read = exports.make = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const sources_js_1 = require("../internal/sources.js");
+const scheduler_js_1 = require("../internal/scheduler.js");
+const store_js_1 = require("../internal/store.js");
+const track_js_1 = require("../internal/track.js");
+/**
+ * Define a keyed derived value: per-key memoized projections over shared
+ * inputs. The *definition* fixes the key/output schemas and the inputs; the
+ * *implementation* (the per-key projection) is supplied by `CalcFamily.live`.
+ */
+const make = (name, config) => {
+    const store = effect_1.Context.GenericTag(`reform/calcFamily/${name}`);
+    const manifest = {
+        kind: 'CalcFamily',
+        name,
+        key: config.key,
+        output: config.output,
+    };
+    return (0, definition_js_1.definitionClass)({
+        manifest,
+        store,
+        inputs: config.inputs,
+    });
+};
+exports.make = make;
+/**
+ * Read one member by key — `CalcFamily.read(GroupProjection, id)`. Inside a
+ * render it subscribes exactly that member's store (unrelated members never
+ * wake the subtree); elsewhere it just snapshots — the same one-read-API
+ * contract as `StateFamily.read`.
+ */
+const read = (family, key) => effect_1.Effect.flatMap(family.store, (fs) => (0, track_js_1.readTracked)(fs.at(key)));
+exports.read = read;
+/**
+ * Wire the per-key projection. `compute` is curried — `(key) => (inputs) =>
+ * Out` — so per-key construction (closing over key-derived constants) runs once
+ * per member while the inner projection runs per recompute. Each member is a
+ * lazy derived store over the shared wired sources: memoized on the family's
+ * invalidation key, notifying only when its own output moves. Unlike a
+ * `StateFamily` entry, a member holds an upstream subscription, so every
+ * removal path (forget / clear / eviction / the layer finalizer) releases it.
+ */
+const live = (family, compute, options = {}) => effect_1.Layer.scoped(family.store, effect_1.Effect.gen(function* () {
+    const scheduler = yield* scheduler_js_1.resolveScheduler;
+    // Wired ONCE for the whole family — members share the sensing surface.
+    const sources = yield* (0, sources_js_1.wireSources)(family.inputs, options.invalidateBy);
+    const entries = new Map();
+    const evictWhenUnused = options.evictWhenUnused === true;
+    // Live subscriber count per key — maintained only when eviction is on.
+    const subscribers = new Map();
+    const dropEntry = (key) => {
+        const entry = entries.get(key);
+        if (entry !== undefined)
+            entry.unsubscribe();
+        entries.delete(key);
+        subscribers.delete(key);
+    };
+    // One member: the same memo block as `Calc.live`, with the key closed over.
+    const createMember = (key) => {
+        const body = compute(key);
+        const memo = effect_1.MutableRef.make(undefined);
+        const recompute = () => {
+            const args = sources.snapshot();
+            const memoKey = sources.keyOf(args);
+            const prev = effect_1.MutableRef.get(memo);
+            if (prev !== undefined && (0, sources_js_1.sameKey)(memoKey, prev.key))
+                return prev.output;
+            const output = body(args);
+            effect_1.MutableRef.set(memo, { key: memoKey, output });
+            return output;
+        };
+        return (0, store_js_1.makeDerivedStore)(recompute, sources.subscribe, scheduler);
+    };
+    // The `StateFamily` ref-count idiom: evict on the next microtask once a
+    // key falls idle (a same-commit re-subscribe cancels it) — here eviction
+    // also releases the member's upstream subscription via `dropEntry`.
+    const refCounted = (key, store) => ({
+        ...store,
+        subscribe: (listener) => {
+            subscribers.set(key, (subscribers.get(key) ?? 0) + 1);
+            const off = store.subscribe(listener);
+            const released = { done: false };
+            return () => {
+                if (released.done)
+                    return;
+                released.done = true;
+                off();
+                const remaining = (subscribers.get(key) ?? 1) - 1;
+                if (remaining > 0) {
+                    subscribers.set(key, remaining);
+                    return;
+                }
+                subscribers.delete(key);
+                queueMicrotask(() => {
+                    if ((subscribers.get(key) ?? 0) === 0)
+                        dropEntry(key);
+                });
+            };
+        },
+    });
+    const familyStore = {
+        at: (key) => {
+            const existing = entries.get(key);
+            if (existing !== undefined)
+                return existing.store;
+            const member = createMember(key);
+            const created = evictWhenUnused
+                ? { store: refCounted(key, member.store), unsubscribe: member.unsubscribe }
+                : member;
+            entries.set(key, created);
+            return created.store;
+        },
+        forget: dropEntry,
+        clear: () => {
+            for (const key of [...entries.keys()])
+                dropEntry(key);
+        },
+        size: () => entries.size,
+    };
+    yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => familyStore.clear()));
+    return familyStore;
+}));
+exports.live = live;

package/dist/cjs/channel/channel.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.live = exports.make = exports.channelsLayer = exports.Channels = exports.proceduresLayer = exports.Procedures = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const errors_js_1 = require("../internal/errors.js");
+class Procedures extends effect_1.Context.Tag('reform/Procedures')() {
+}
+exports.Procedures = Procedures;
+/** Get a map entry, creating and inserting it on first access (avoids `let`). */
+const getOrCreate = (map, key, make) => {
+    const existing = map.get(key);
+    if (existing !== undefined)
+        return existing;
+    const created = make();
+    map.set(key, created);
+    return created;
+};
+/** Drop an item from a `Map<K, Array>` bucket, pruning the key when it empties. */
+const dropFrom = (map, key, item) => {
+    const bucket = map.get(key);
+    if (bucket === undefined)
+        return;
+    const next = bucket.filter((value) => value !== item);
+    if (next.length === 0)
+        map.delete(key);
+    else
+        map.set(key, next);
+};
+const makeProcedureRegistry = () => {
+    const entries = [];
+    const byTag = new Map();
+    const channelsByTag = new Map();
+    const byChannelTag = new Map();
+    return {
+        entries,
+        byTag,
+        channelsByTag,
+        byChannelTag,
+        register: (entry) => {
+            entries.push(entry);
+            for (const tag of entry.handles) {
+                getOrCreate(byTag, tag, () => []).push(entry);
+                const channels = getOrCreate(channelsByTag, tag, () => []);
+                if (!channels.includes(entry.channelName))
+                    channels.push(entry.channelName);
+                getOrCreate(getOrCreate(byChannelTag, entry.channelName, () => new Map()), tag, () => []).push(entry);
+            }
+        },
+        unregister: (entry) => {
+            const index = entries.indexOf(entry);
+            if (index >= 0)
+                entries.splice(index, 1);
+            for (const tag of entry.handles) {
+                dropFrom(byTag, tag, entry);
+                const channelMap = byChannelTag.get(entry.channelName);
+                if (channelMap !== undefined) {
+                    dropFrom(channelMap, tag, entry);
+                    // If no procedure on this channel still handles the tag, drop the
+                    // channel from `channelsByTag[tag]` so the loop stops offering to it.
+                    if (channelMap.get(tag) === undefined)
+                        dropFrom(channelsByTag, tag, entry.channelName);
+                    if (channelMap.size === 0)
+                        byChannelTag.delete(entry.channelName);
+                }
+            }
+        },
+    };
+};
+exports.proceduresLayer = effect_1.Layer.sync(Procedures, makeProcedureRegistry);
+/** Registry of live channels, keyed by name. The single loop routes through it. */
+class Channels extends effect_1.Context.Tag('reform/Channels')() {
+}
+exports.Channels = Channels;
+exports.channelsLayer = effect_1.Layer.sync(Channels, () => ({ byName: new Map() }));
+/**
+ * A scheduling lane for procedures. The *definition* (`Channel.make`) is a
+ * reflectable name + policy; the *implementation* (`Channel.live`) builds the
+ * queue + fiber that applies the policy. Procedures reference a channel by value
+ * and register into it; `Channel.live` is merged into the app once per channel.
+ */
+const make = (name, config) => (0, definition_js_1.definitionClass)({
+    manifest: { kind: 'Channel', name },
+    policy: config.policy,
+});
+exports.make = make;
+/**
+ * Build and register the live machinery for a channel. Idempotent by name, so
+ * procedures sharing an `exclusive`/`latest` channel share one queue + fiber +
+ * semaphore (and therefore truly serialize / cancel across each other).
+ */
+const live = (channel) => effect_1.Layer.scopedDiscard(effect_1.Effect.gen(function* () {
+    const name = channel.manifest.name;
+    const channels = yield* Channels;
+    const existing = channels.byName.get(name);
+    if (existing !== undefined) {
+        // Idempotent for the *same* channel `.live`'d through several sub-layers
+        // (shared `exclusive`/`latest` lane). A *different* channel reusing the
+        // name is a silent footgun — the second policy would be dropped — so
+        // reject it loudly instead.
+        if (existing.policy !== channel.policy) {
+            throw new errors_js_1.DuplicateRegistration({ kind: 'Channel', name });
+        }
+        return;
+    }
+    const procedures = yield* Procedures;
+    const queue = yield* effect_1.Queue.unbounded();
+    // Run every procedure on THIS channel that handles the event. Read the live
+    // index each time so procedures registered later are still seen.
+    // A procedure is expected to model expected failures as events; a leaked
+    // defect (a bug in the body) is logged before being isolated, so one
+    // procedure's crash never tears down the channel fiber — but is observable.
+    const runMatching = (event) => effect_1.Effect.forEach(procedures.byChannelTag.get(name)?.get(event._tag) ?? [], (e) => e.run(event).pipe(effect_1.Effect.tapErrorCause((cause) => effect_1.Effect.logError(`reform: procedure on channel '${name}' failed`, cause)), effect_1.Effect.catchAllCause(() => effect_1.Effect.void)), { discard: true, concurrency: 'unbounded' });
+    // Map the policy to its scheduling stream. `Match.exhaustive` makes a new
+    // policy variant a compile error, and each arm is a self-contained const.
+    const events = effect_1.Stream.fromQueue(queue);
+    const driven = effect_1.Match.value(channel.policy).pipe(effect_1.Match.tag('merge', () => effect_1.Stream.mapEffect(events, runMatching, { concurrency: 'unbounded' })), effect_1.Match.tag('latest', () => effect_1.Stream.flatMap(events, (e) => effect_1.Stream.fromEffect(runMatching(e)), { switch: true })), effect_1.Match.tag('debounce', (policy) => events.pipe(effect_1.Stream.debounce(policy.duration), effect_1.Stream.mapEffect(runMatching, { concurrency: 'unbounded' }))), effect_1.Match.tag('throttle', (policy) => events.pipe(effect_1.Stream.throttle({
+        cost: (chunk) => effect_1.Chunk.size(chunk) * (policy.cost ?? 1),
+        units: policy.units,
+        duration: policy.duration,
+        ...(policy.burst !== undefined ? { burst: policy.burst } : {}),
+        strategy: policy.strategy ?? 'shape',
+    }), effect_1.Stream.mapEffect(runMatching, { concurrency: 'unbounded' }))), 
+    // `concurrency: 1` runs one event at a time AND in offer order — a true
+    // serialized lane. (An unbounded fork racing for a single semaphore permit
+    // would serialize but could reorder under contention.)
+    effect_1.Match.tag('exclusive', () => effect_1.Stream.mapEffect(events, runMatching, { concurrency: 1 })), effect_1.Match.exhaustive);
+    yield* effect_1.Effect.forkScoped(effect_1.Stream.runDrain(driven));
+    channels.byName.set(name, {
+        name,
+        policy: channel.policy,
+        offer: (event) => {
+            effect_1.Queue.unsafeOffer(queue, event);
+        },
+    });
+    // On scope close (a lazy feature unmounting) remove the live channel so the
+    // loop stops routing to it; the drain fiber is already torn down by
+    // `forkScoped`. Eager channels live on the root scope, so this is a no-op
+    // until app dispose.
+    yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => channels.byName.delete(name)));
+}));
+exports.live = live;