@playfast/reform 0.0.1

package/dist/cjs/internal/queryDriver.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQueryDriver = exports.bumpRevision = exports.revisionZero = exports.RevisionSchema = exports.Revision = exports.gatedFlag = void 0;
+const effect_1 = require("effect");
+const asyncData_js_1 = require("../calc/asyncData.js");
+const reuse_js_1 = require("./reuse.js");
+const scheduler_js_1 = require("./scheduler.js");
+const sources_js_1 = require("./sources.js");
+const store_js_1 = require("./store.js");
+/** The runtime gated flag for an `alwaysOn` config, typed as its `Gated` literal. */
+const gatedFlag = (alwaysOn) => (alwaysOn !== true);
+exports.gatedFlag = gatedFlag;
+exports.Revision = effect_1.Brand.nominal();
+exports.RevisionSchema = effect_1.Schema.Number.pipe(effect_1.Schema.brand('reform/Revision'));
+exports.revisionZero = (0, exports.Revision)(0);
+const bumpRevision = (r) => (0, exports.Revision)(r + 1);
+exports.bumpRevision = bumpRevision;
+/**
+ * Build the driver: store + subscription + request queue + run fiber, all owned
+ * by the ambient scope (callers run this under `Layer.scoped`). A change to an
+ * input re-runs the query latest-wins (a new run cancels the in-flight one; or,
+ * with `coalesce: 'trailing'`, lets it finish and runs one trailing refetch);
+ * while a re-run is in flight the last `Success`/`Error` is kept with
+ * `refetching: true`.
+ */
+const makeQueryDriver = (options) => effect_1.Effect.gen(function* () {
+    const scheduler = yield* scheduler_js_1.resolveScheduler;
+    const sources = yield* (0, sources_js_1.wireSources)(options.inputs, options.invalidateBy);
+    const extraKey = options.extraKey;
+    const keyOf = (args) => extraKey === undefined ? sources.keyOf(args) : [...sources.keyOf(args), extraKey.read()];
+    const subscribeAll = (listener) => {
+        const offSources = sources.subscribe(listener);
+        const offExtra = extraKey?.subscribe(listener);
+        return () => {
+            offSources();
+            offExtra?.();
+        };
+    };
+    const disabledNow = (args = sources.snapshot()) => options.gated && options.disabled !== undefined ? options.disabled(args) : false;
+    const store = (0, store_js_1.makeStore)(disabledNow() ? asyncData_js_1.AsyncData.idle : asyncData_js_1.AsyncData.loading, scheduler);
+    // The last requested key, so a change that doesn't move it (or only churns
+    // an input `invalidateBy` ignores) doesn't re-fetch.
+    const lastKey = effect_1.MutableRef.make(undefined);
+    // The run-generation counter: bumped when a run is REQUESTED (enqueued), so
+    // `requested()` names the newest run that could possibly be in flight.
+    const generation = effect_1.MutableRef.make(0);
+    const nextGeneration = () => {
+        effect_1.MutableRef.update(generation, (n) => n + 1);
+        return effect_1.MutableRef.get(generation);
+    };
+    // Mark a re-fetch in flight without dropping the visible value (SWR).
+    const markRefetching = () => {
+        const prev = store.get();
+        if (prev._tag === 'Success')
+            store.set(asyncData_js_1.AsyncData.success(prev.value, true));
+        else if (prev._tag === 'Error')
+            store.set(asyncData_js_1.AsyncData.error(prev.error, true));
+        else
+            store.set(asyncData_js_1.AsyncData.loading);
+    };
+    // One run of the query, folded into the store. A failure becomes `Error`; an
+    // interrupt (latest-wins cancel) leaves the state untouched; a defect (a bug
+    // in the body) is logged and isolated — the driver keeps running. A `Success`
+    // additionally reports its generation through `onSettled`, after the write,
+    // so settle-driven consequences observe the converged value.
+    const runQuery = (request) => options.query(request.args).pipe(effect_1.Effect.tapDefect((defect) => effect_1.Effect.logError(`reform: ${options.label} '${options.name}' query defect`, defect)), effect_1.Effect.matchCause({
+        onSuccess: (value) => {
+            if (!disabledNow()) {
+                // `reuse`: share unchanged subtrees with the previous Success
+                // value, so a refetch that barely moved keeps identities stable.
+                const prev = store.get();
+                const shared = options.reuse === true && prev._tag === 'Success'
+                    ? (0, reuse_js_1.reuse)(prev.value, value)
+                    : value;
+                store.set(asyncData_js_1.AsyncData.success(shared, false));
+                options.onSettled?.(request.generation);
+            }
+        },
+        onFailure: (cause) => {
+            const failure = effect_1.Cause.failureOption(cause);
+            if (effect_1.Option.isSome(failure) && !disabledNow()) {
+                store.set(asyncData_js_1.AsyncData.error(failure.value, false));
+            }
+        },
+    }));
+    // The driver. `'switch'` (default): each new request cancels the in-flight
+    // run — the same latest-wins semantics a `latest` channel gives procedures.
+    // `'trailing'`: a strictly sequential consumer that, on wake, drains every
+    // request that piled up during the flight and runs the LATEST one —
+    // "exactly one trailing run after settle" by construction. The trailing
+    // run's generation is the max drained (the latest request's), so it
+    // vouches for every request it conflated.
+    const trailing = options.coalesce === 'trailing';
+    const requests = yield* effect_1.Queue.unbounded();
+    yield* effect_1.Effect.forkScoped(trailing
+        ? effect_1.Effect.forever(effect_1.Effect.gen(function* () {
+            const first = yield* effect_1.Queue.take(requests);
+            const queued = yield* effect_1.Queue.takeAll(requests);
+            const request = effect_1.Option.getOrElse(effect_1.Chunk.last(queued), () => first);
+            // A disable that landed while the request waited: skip the run.
+            if (!disabledNow())
+                yield* runQuery(request);
+            // The settle may have written a stale-key result with
+            // `refetching: false`; if a newer request is already waiting,
+            // restore the syncing flag before the next take — both writes
+            // coalesce into one scheduler flush for subscribers.
+            const pending = yield* effect_1.Queue.size(requests);
+            if (pending > 0 && !disabledNow())
+                yield* effect_1.Effect.sync(markRefetching);
+        }))
+        : effect_1.Stream.fromQueue(requests).pipe(effect_1.Stream.flatMap((request) => effect_1.Stream.fromEffect(runQuery(request)), { switch: true }), effect_1.Stream.runDrain));
+    const trigger = () => {
+        const args = sources.snapshot();
+        if (disabledNow(args)) {
+            // Switched off: show Idle and forget the key so re-enabling always re-runs.
+            effect_1.MutableRef.set(lastKey, undefined);
+            store.set(asyncData_js_1.AsyncData.idle);
+            return;
+        }
+        const key = keyOf(args);
+        const previous = effect_1.MutableRef.get(lastKey);
+        if (previous !== undefined && (0, sources_js_1.sameKey)(key, previous))
+            return;
+        effect_1.MutableRef.set(lastKey, key);
+        markRefetching();
+        effect_1.Queue.unsafeOffer(requests, { args, generation: nextGeneration() });
+    };
+    const unsubscribe = subscribeAll(trigger);
+    yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(unsubscribe));
+    // Kick off the first fetch unless the query starts disabled.
+    const initial = sources.snapshot();
+    if (!disabledNow(initial)) {
+        effect_1.MutableRef.set(lastKey, keyOf(initial));
+        effect_1.Queue.unsafeOffer(requests, { args: initial, generation: nextGeneration() });
+    }
+    return { store, requested: () => effect_1.MutableRef.get(generation) };
+});
+exports.makeQueryDriver = makeQueryDriver;

package/dist/cjs/internal/reuse.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reuse = void 0;
+const effect_1 = require("effect");
+// Structural sharing for recomputed calc outputs: reconcile a fresh output
+// against the previous one, substituting previous nodes wherever value equality
+// holds, so identities only move where values moved. Downstream memo boundaries
+// (React subtrees keyed on object identity) then skip everything that didn't
+// change. Referentially transparent: the result is value-equal to `next` — only
+// identities shift toward `previous` — and neither argument is mutated, so the
+// pass composes with the framework's Equal-based invalidation untouched.
+// Bounds the walk; calc outputs are shallow plain data by framework convention.
+const maxDepth = 16;
+const isPlainRecord = (v) => typeof v === 'object' &&
+    v !== null &&
+    (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+const go = (prev, next, depth) => {
+    if (Object.is(prev, next))
+        return prev;
+    // Data/Schema classes implement Equal+Hash: substitute wholesale on value
+    // equality. Plain objects/arrays fall through (their Equal is referential).
+    if (effect_1.Equal.equals(prev, next))
+        return prev;
+    if (depth <= 0)
+        return next;
+    if (Array.isArray(prev) && Array.isArray(next)) {
+        const out = next.map((item, i) => (i < prev.length ? go(prev[i], item, depth - 1) : item));
+        return prev.length === next.length && out.every((v, i) => Object.is(v, prev[i]))
+            ? prev
+            : out;
+    }
+    if (isPlainRecord(prev) && isPlainRecord(next)) {
+        const keys = Object.keys(next);
+        const out = {};
+        for (const key of keys)
+            out[key] = key in prev ? go(prev[key], next[key], depth - 1) : next[key];
+        const allPrev = keys.length === Object.keys(prev).length &&
+            keys.every((key) => key in prev && Object.is(out[key], prev[key]));
+        return allPrev ? prev : out;
+    }
+    // Data/Schema class instances that DIFFER still get walked: their Equal is
+    // fieldwise over own enumerable fields, so a reconstruction over reconciled
+    // fields (same prototype; the constructor is bypassed, but every leaf is a
+    // validated value out of `prev` or `next`) stays value-equal to `next` while
+    // unchanged children — e.g. one untouched element inside a class-typed
+    // container — keep their `prev` identity.
+    if (effect_1.Equal.isEqual(prev) &&
+        effect_1.Equal.isEqual(next) &&
+        Object.getPrototypeOf(prev) === Object.getPrototypeOf(next)) {
+        const prevFields = Object.fromEntries(Object.entries(prev));
+        const nextFields = Object.entries(next);
+        const out = {};
+        for (const [key, value] of nextFields)
+            out[key] = key in prevFields ? go(prevFields[key], value, depth - 1) : value;
+        const allPrev = nextFields.length === Object.keys(prevFields).length &&
+            nextFields.every(([key]) => key in prevFields && Object.is(out[key], prevFields[key]));
+        return allPrev ? prev : Object.assign(Object.create(Object.getPrototypeOf(next)), out);
+    }
+    // Class instances without Equal (Date, Map, …) are opaque leaves.
+    return next;
+};
+/**
+ * Substitute `previous` nodes into `next` wherever they are value-equal. The
+ * walker only ever returns `previous`, `next`, or a key/index-wise
+ * reconstruction of `next` whose every leaf came from one of them, so the
+ * result is value-equal to `next` and the type is preserved by construction —
+ * the single cast below is that argument, in the style of `wireSources` /
+ * `narrowStore`.
+ */
+const reuse = (previous, next) => go(previous, next, maxDepth);
+exports.reuse = reuse;

package/dist/cjs/internal/scheduler.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveScheduler = exports.notificationsLayer = exports.Notifications = exports.defaultScheduler = exports.makeScheduler = void 0;
+const effect_1 = require("effect");
+const makeScheduler = () => {
+    const pending = new Set();
+    const armed = effect_1.MutableRef.make(false);
+    const flush = () => {
+        effect_1.MutableRef.set(armed, false);
+        // Drain to a fixpoint within ONE microtask. A derived store's `onChange`
+        // re-schedules during the pass (it is itself a listener of its upstream), so
+        // resolving the whole dependency graph here — instead of re-arming a fresh
+        // microtask per layer — collapses a depth-N propagation into a single flush
+        // and wakes each leaf subscriber once at its final value. Converges because
+        // a derived store schedules only when its output actually moves (Equal).
+        while (pending.size > 0) {
+            const due = [...pending];
+            pending.clear();
+            for (const listener of due) {
+                // One listener's throw (a defect in a user calc body) must not abandon
+                // the rest of the flush; surface it to the host's global handler on a
+                // fresh microtask instead of unwinding this loop.
+                try {
+                    listener();
+                }
+                catch (error) {
+                    queueMicrotask(() => {
+                        throw error;
+                    });
+                }
+            }
+        }
+    };
+    const schedule = (listeners) => {
+        for (const listener of listeners)
+            pending.add(listener);
+        if (pending.size > 0 && !effect_1.MutableRef.get(armed)) {
+            effect_1.MutableRef.set(armed, true);
+            queueMicrotask(flush);
+        }
+    };
+    return { schedule };
+};
+exports.makeScheduler = makeScheduler;
+/**
+ * The process-wide scheduler, used by any store created outside a runtime that
+ * provides its own `Notifications`. Fine for a single client app (microtask
+ * ordering is global anyway); a runtime that needs isolation — concurrent SSR,
+ * multiple mounted roots — provides `Notifications` upstream of its stores.
+ */
+exports.defaultScheduler = (0, exports.makeScheduler)();
+/**
+ * Optional per-runtime scheduler. When a runtime provides it upstream of its
+ * state/calc layers, those stores coalesce on it instead of the global default,
+ * isolating their notification timing from other runtimes in the same process.
+ */
+class Notifications extends effect_1.Context.Tag('reform/Notifications')() {
+}
+exports.Notifications = Notifications;
+/**
+ * A fresh per-runtime scheduler. Merged into `Engine`, so a runtime that wires
+ * its state/calc layers *downstream* of `Engine` gets isolated notification
+ * timing; the common sibling wiring falls back to `defaultScheduler` (still
+ * correct, just process-shared).
+ */
+exports.notificationsLayer = effect_1.Layer.sync(Notifications, exports.makeScheduler);
+/**
+ * Resolve the scheduler a store should use: the runtime's `Notifications` if one
+ * is in context, else the global default. Uses `serviceOption` so it imposes no
+ * hard requirement — a store layer wired as a sibling of the runtime (the common
+ * pattern) simply falls back to the default.
+ */
+exports.resolveScheduler = effect_1.Effect.map(effect_1.Effect.serviceOption(Notifications), effect_1.Option.getOrElse(() => exports.defaultScheduler));

package/dist/cjs/internal/seeds.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentSeedOverrides = void 0;
+const effect_1 = require("effect");
+/**
+ * The sanctioned tooling/test seam for seeding CLOSED scenes. A scene's layers
+ * are pre-composed (each state group seeds its own live store), so an outer
+ * layer cannot override an inner store — but a FiberRef set via
+ * `Layer.locally(ref, value)(layer)` IS visible inside the construction effects
+ * of nested layers. `State.live` consults this ref at store-construction time:
+ * if the state's member name is present, the (schema-validated) value replaces
+ * the authored seed; otherwise the authored seed wins.
+ *
+ * Empty by default — production wiring never touches it. The dev-tool inspector
+ * (`Scene.seedScene`) and proofs are the only intended writers. `globalValue`
+ * keeps a single ref instance even if the module is loaded twice (duplicated
+ * bundles, HMR), so the writer and the reader always agree.
+ */
+exports.CurrentSeedOverrides = effect_1.GlobalValue.globalValue(Symbol.for('reform/CurrentSeedOverrides'), () => effect_1.FiberRef.unsafeMake({}));

package/dist/cjs/internal/sources.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireSources = exports.sameKey = void 0;
+const effect_1 = require("effect");
+/**
+ * The runtime key an input contributes to the inputs object. Prefer the
+ * explicit `manifest.name` — the string handed to `make` — over the structural
+ * `name`: a `Calc`/`AsyncCalc` *class* satisfies `Source` through its static
+ * `name`, and a user subclass declaration (`class Feed extends Calc.make(…)`)
+ * defines its OWN `name` from the class binding, shadowing the explicit one.
+ * That binding is what minifiers rename, so keying the snapshot by `input.name`
+ * made every subclassed calc input `undefined` in production builds (and would
+ * silently mis-key in dev whenever the binding differs from the `make` name —
+ * the type-level key, `SourceName<S>`, is always the `make` string). The
+ * manifest is inherited through the static prototype chain and never shadowed.
+ * `StateToken`s carry no manifest; their `name` is an instance field holding
+ * the explicit member key, so the fallback is always the declared string.
+ */
+const inputKey = (input) => effect_1.Predicate.hasProperty(input, 'manifest') &&
+    effect_1.Predicate.isRecord(input.manifest) &&
+    effect_1.Predicate.isString(input.manifest.name)
+    ? input.manifest.name
+    : input.name;
+/** Element-wise value equality of two invalidation keys. */
+const sameKey = (a, b) => a.length === b.length && a.every((value, i) => effect_1.Equal.equals(value, b[i]));
+exports.sameKey = sameKey;
+/**
+ * Read each input's backing store and return the shared sensing surface. The
+ * caller owns lifecycle: register the `subscribe` result's unsubscribe as a
+ * scope finalizer (both live bodies run under `Layer.scoped`).
+ */
+const wireSources = (inputs, invalidateBy) => effect_1.Effect.gen(function* () {
+    const sources = [];
+    for (const input of inputs)
+        sources.push(yield* input.store);
+    const snapshot = () => {
+        const args = {};
+        inputs.forEach((input, i) => {
+            // `noUncheckedIndexedAccess`: `sources` is built 1:1 with `inputs`, but
+            // guard the index so the read is honestly total.
+            const source = sources[i];
+            if (source !== undefined)
+                args[inputKey(input)] = source.getSnapshot();
+        });
+        return args;
+    };
+    const keyOf = (args) => invalidateBy ? invalidateBy(args) : Object.values(args);
+    const subscribe = (listener) => {
+        const unsubscribes = sources.map((source) => source.subscribe(listener));
+        return () => {
+            for (const unsubscribe of unsubscribes)
+                unsubscribe();
+        };
+    };
+    return { snapshot, keyOf, subscribe };
+    // Yielding each `input.store` (a `Context.Tag<Store<unknown>>`) widens the
+    // inferred requirement to `Store<unknown>`; restate the precise per-input
+    // `InputStores<Inputs>` union the signature promises. This is the single
+    // place that cast lives — `Calc.live`/`AsyncCalc.live` inherit it.
+});
+exports.wireSources = wireSources;

package/dist/cjs/internal/store.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDerivedStore = exports.makeStore = void 0;
+const effect_1 = require("effect");
+const inspect_js_1 = require("./inspect.js");
+const scheduler_js_1 = require("./scheduler.js");
+const makeStore = (initial, scheduler = scheduler_js_1.defaultScheduler) => {
+    // The store is a mutable reactive slot by design, so its value lives in a
+    // `MutableRef` we update in place (no reassigned binding).
+    const value = effect_1.MutableRef.make(initial);
+    const version = effect_1.MutableRef.make(0);
+    const listeners = new Set();
+    return {
+        get: () => effect_1.MutableRef.get(value),
+        getSnapshot: () => effect_1.MutableRef.get(value),
+        getVersion: () => effect_1.MutableRef.get(version),
+        set: (next) => {
+            if (effect_1.Equal.equals(effect_1.MutableRef.get(value), next))
+                return;
+            effect_1.MutableRef.set(value, next);
+            effect_1.MutableRef.update(version, (n) => n + 1);
+            scheduler.schedule(listeners);
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        ...(0, inspect_js_1.inspectable)(() => ({ _id: 'reform/Store', value: effect_1.MutableRef.get(value) })),
+    };
+};
+exports.makeStore = makeStore;
+/**
+ * A read-only `Store` whose value is computed from upstream sources.
+ *
+ * Reads are pull-fresh: `get`/`getSnapshot` call `compute` directly, so a
+ * headless snapshot always reflects the current source state without waiting for
+ * a notification (`compute` must memoize so an unchanged read returns a stable
+ * reference — `useSyncExternalStore` requires it). *Notifications*, by contrast,
+ * run through the same coalescing scheduler as `makeStore`: an upstream change
+ * recomputes once and wakes subscribers only when the output actually moves (by
+ * `Equal.equals`), so every store kind shares one notification timing. `set` is
+ * a no-op — the only writer is the upstream subscription.
+ */
+const makeDerivedStore = (compute, subscribeUpstream, scheduler = scheduler_js_1.defaultScheduler) => {
+    const listeners = new Set();
+    const version = effect_1.MutableRef.make(0);
+    // The last output we notified against — tracked only here, never touched by
+    // reads, so a `get` racing ahead of `onChange` can't suppress a notification.
+    const seen = effect_1.MutableRef.make({ value: compute() });
+    const onChange = () => {
+        const previous = effect_1.MutableRef.get(seen);
+        const next = compute();
+        effect_1.MutableRef.set(seen, { value: next });
+        if (previous === undefined || !effect_1.Equal.equals(previous.value, next)) {
+            effect_1.MutableRef.update(version, (n) => n + 1);
+            scheduler.schedule(listeners);
+        }
+    };
+    const unsubscribe = subscribeUpstream(onChange);
+    const store = {
+        get: compute,
+        getSnapshot: compute,
+        getVersion: () => effect_1.MutableRef.get(version),
+        set: () => { },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        ...(0, inspect_js_1.inspectable)(() => ({ _id: 'reform/Store', value: compute() })),
+    };
+    return { store, unsubscribe };
+};
+exports.makeDerivedStore = makeDerivedStore;

package/dist/cjs/internal/track.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTracked = exports.CurrentTracker = void 0;
+const effect_1 = require("effect");
+/**
+ * The active render's dependency tracker (D5). Present only while a composition
+ * is rendering under `@reform/react`; absent in procedures and headless reads.
+ */
+class CurrentTracker extends effect_1.Context.Tag('reform/Tracker')() {
+}
+exports.CurrentTracker = CurrentTracker;
+/**
+ * Read a store's current snapshot and, if a tracker is active, record the store
+ * as a dependency of the current render. One read API, two behaviors by context
+ * (D5): inside a render it subscribes the slice; elsewhere it just snapshots.
+ */
+const readTracked = (store) => effect_1.Effect.map(effect_1.Effect.serviceOption(CurrentTracker), (tracker) => {
+    if (effect_1.Option.isSome(tracker))
+        tracker.value.add(store);
+    return store.getSnapshot();
+});
+exports.readTracked = readTracked;

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "sideEffects": []
+}

package/dist/cjs/procedure/procedure.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.live = exports.make = void 0;
+const effect_1 = require("effect");
+const channel_js_1 = require("../channel/channel.js");
+const definition_js_1 = require("../definition/definition.js");
+const bus_js_1 = require("../runtime/bus.js");
+/**
+ * A cross-event-loop flow. The *definition* declares its trigger events and the
+ * channel it runs on; the *implementation* is the effectful body. Procedures no
+ * longer subscribe to the bus themselves — the single drain loop routes events
+ * to the channel, which runs the registered bodies under its policy.
+ */
+const make = (name, config) => (0, definition_js_1.definitionClass)({
+    manifest: { kind: 'Procedure', name },
+    events: config.events,
+    channel: config.channel,
+});
+exports.make = make;
+/**
+ * Register the flow body into its channel. The body may read state and dispatch
+ * events, but never writes state (the core invariant); its context requirements
+ * (RPC clients, etc.) are captured here so the channel fiber can run it with no
+ * outstanding R.
+ */
+const live = (procedure, body) => {
+    const name = procedure.manifest.name;
+    const channelName = procedure.channel.manifest.name;
+    const handles = new Set(procedure.events.map((e) => e.tag));
+    // Scoped registration (see `Reducer.live`): an eager procedure's scope is the
+    // root runtime's, so behavior is unchanged; a lazy feature's procedure registers
+    // on mount and unregisters on unmount, so it stops running and is reclaimed.
+    return effect_1.Layer.scopedDiscard(effect_1.Effect.gen(function* () {
+        const procedures = yield* channel_js_1.Procedures;
+        if (procedures.entries.some((e) => e.name === name)) {
+            yield* effect_1.Effect.logWarning(`reform: duplicate procedure name '${name}' registered`);
+        }
+        // Snapshot the body's full context (Bus + RPC clients) so `run` is total.
+        const runtime = yield* effect_1.Effect.runtime();
+        const entry = {
+            name,
+            channelName,
+            // The channel only routes events whose tag is in `handles`, so at runtime
+            // `event` is always one of `Events`; `narrowHandled` restores the body's
+            // declared event union from the erased `Tagged` envelope.
+            handles,
+            run: (event) => effect_1.Effect.provide(effect_1.Effect.gen(() => body((0, bus_js_1.narrowHandled)(event))), runtime),
+        };
+        yield* effect_1.Effect.acquireRelease(effect_1.Effect.sync(() => procedures.register(entry)), () => effect_1.Effect.sync(() => procedures.unregister(entry)));
+    }));
+};
+exports.live = live;

package/dist/cjs/reducer/reducer.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.make = make;
+exports.live = live;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const errors_js_1 = require("../internal/errors.js");
+const stateFamily_js_1 = require("../state/stateFamily.js");
+const bus_js_1 = require("../runtime/bus.js");
+const loop_js_1 = require("../runtime/loop.js");
+function make(name, config) {
+    return (0, definition_js_1.definitionClass)({
+        manifest: { kind: 'Reducer', name },
+        config,
+        handles: new Set(config.events.map((e) => e.tag)),
+    });
+}
+/** Reject an accidentally-async fold up front: a reducer must be a pure sync write. */
+const sync = (value) => {
+    // Loose `!= null` so a reducer returning `undefined` doesn't crash the guard.
+    if (value != null && typeof value.then === 'function') {
+        throw new errors_js_1.AsyncReducer();
+    }
+    return value;
+};
+function live(reducer, fold) {
+    const { config, handles } = reducer;
+    const name = reducer.manifest.name;
+    // Scoped registration: register on build, unregister on scope close. For an eager
+    // app the scope is the root runtime's (closes only at dispose), so behavior is
+    // unchanged; for a lazy feature the scope is the feature's, so unmount removes the
+    // entry — it stops folding and is reclaimed instead of leaking onto a dead store.
+    return effect_1.Layer.scopedDiscard(effect_1.Effect.gen(function* () {
+        const reducers = yield* loop_js_1.Reducers;
+        if (reducers.entries.some((e) => e.name === name)) {
+            yield* effect_1.Effect.logWarning(`reform: duplicate reducer name '${name}' registered`);
+        }
+        const entry = yield* effect_1.Effect.gen(function* () {
+            if ('family' in config) {
+                const family = yield* config.family.store;
+                return {
+                    name,
+                    handles,
+                    apply: (event) => {
+                        // The loop only invokes `apply` for events in `handles`, so `event`
+                        // is one of this reducer's declared events; `narrowHandled` restores
+                        // that typed view from the erased `Tagged` envelope `keyOf` is fed.
+                        const key = config.keyOf((0, bus_js_1.narrowHandled)(event));
+                        const next = fold(family.at(key).get(), event);
+                        // A fold may return the eviction sentinel to drop the key's store
+                        // (bounding an otherwise-unbounded family) instead of a new value.
+                        if (next === stateFamily_js_1.Tombstone)
+                            family.forget(key);
+                        else
+                            family.at(key).set(sync(next));
+                    },
+                };
+            }
+            const store = yield* config.states[0].store;
+            return { name, handles, apply: (event) => store.set(sync(fold(store.get(), event))) };
+        });
+        yield* effect_1.Effect.acquireRelease(effect_1.Effect.sync(() => reducers.register(entry)), () => effect_1.Effect.sync(() => reducers.unregister(entry)));
+    }));
+}