@playfast/reform 0.0.1

package/dist/cjs/compose/composition.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = exports.live = exports.make = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const track_js_1 = require("../internal/track.js");
+const host_js_1 = require("./host.js");
+const props_js_1 = require("./props.js");
+/**
+ * A component's logic. The *definition* (`Composition.make`) is a reflectable
+ * manifest that doubles as a requirement/tag; the *implementation*
+ * (`Composition.live`) is the synchronous body, provided separately and
+ * checked against it.
+ */
+const make = (name, 
+// Constrain `ui` to the full `UiClass<C>` so `C` is inferred here; the stored
+// manifest still sees only the erased `{ manifest }` carrier (CompositionConfig),
+// so the manifest type — and its variance — is unchanged.
+config) => {
+    const tag = effect_1.Context.GenericTag(`reform/composition/${name}`);
+    const manifest = { kind: 'Composition', name, ...config };
+    return (0, definition_js_1.definitionClass)({ manifest, tag });
+};
+exports.make = make;
+/**
+ * Wire a composition's synchronous logic (D2): read state, acquire triggers,
+ * resolve the UI, return the view. Its requirements (minus `Props`, which the
+ * host injects per render) surface as the Layer's `RIn`; the runtime runs the
+ * body per render within the captured context.
+ */
+const live = (
+// `live` doesn't use the contract type; accept any composition.
+composition, body) => {
+    const logic = effect_1.Effect.gen(body);
+    return effect_1.Layer.effect(composition.tag, effect_1.Effect.gen(function* () {
+        // Capture the build-time context (state stores, calc, ui, bus). `Props`,
+        // the tracker, and slots are injected per render below.
+        const context = yield* effect_1.Effect.context();
+        const render = (env) => 
+        // Total once fully provided: the body is synchronous, reads can't fail,
+        // and every requirement is now satisfied (D2). `Effect.gen` widens the
+        // error channel to `unknown` for a generic body, so we restate it.
+        logic.pipe(effect_1.Effect.provideService(props_js_1.Props, env.props), effect_1.Effect.provideService(track_js_1.CurrentTracker, env.tracker), effect_1.Effect.provideService(host_js_1.CurrentSlots, env.slots), effect_1.Effect.provide(context));
+        return { render };
+    }));
+};
+exports.live = live;
+/** Run a mounted composition for one frame, producing its node. */
+const render = (service, env) => service.render(env);
+exports.render = render;

package/dist/cjs/compose/host.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentSlots = void 0;
+const effect_1 = require("effect");
+/** The active composition's slot bindings, provided per render by the host. */
+class CurrentSlots extends effect_1.Context.Tag('reform/Slots')() {
+}
+exports.CurrentSlots = CurrentSlots;

package/dist/cjs/compose/props.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Props = void 0;
+const effect_1 = require("effect");
+/**
+ * The current composition instance's props. Bound per render by the runtime; a
+ * composition body reads them with `const { todo } = yield* Props`.
+ *
+ * (Per-instance typing of Props is DESIGN #26 — for now the value is opaque and
+ * narrowed at the use site against the composition's declared props schema.)
+ */
+class Props extends effect_1.Context.Tag('reform/Props')() {
+}
+exports.Props = Props;

package/dist/cjs/compose/provide.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provide = provide;
+const effect_1 = require("effect");
+const errors_js_1 = require("../internal/errors.js");
+const feature_js_1 = require("../feature/feature.js");
+const slot_js_1 = require("./slot.js");
+const ui_js_1 = require("./ui.js");
+function provide(target, impl) {
+    // Discriminate the target by its nominal brand, not by which DI-hole property
+    // happens to exist: a UI contract provides under its `impl` tag, a slot under
+    // its `tag`. Anything else is a wiring mistake. The overloads above pair
+    // `impl` with the chosen tag; this implementation sees both erased, so view
+    // the tag loosely (the one documented cast) to provide the service under it.
+    const tag = ((0, ui_js_1.isUi)(target) ? target.impl : (0, slot_js_1.isSlot)(target) ? target.tag : undefined);
+    if (tag === undefined)
+        throw new errors_js_1.InvalidProvideTarget();
+    if ((0, feature_js_1.isFeature)(impl)) {
+        const eager = impl.eagerModule;
+        // Lazy: bind the `FeatureBinding`; the host drives load → mount, painting the
+        // placeholders. Default: bind the composition (so the existing `Compose` path
+        // renders it, no host, no flash) and merge the eager `.live` layer, whose `RIn`
+        // surfaces to the scene. Either way the overload's return type carries the
+        // shared `RIn`, so the scene still type-demands `Core`.
+        return eager === undefined
+            ? effect_1.Layer.succeed(tag, impl.binding)
+            : effect_1.Layer.merge(effect_1.Layer.succeed(tag, impl.binding.composition), eager.layer);
+    }
+    return effect_1.Layer.succeed(tag, impl);
+}

package/dist/cjs/compose/slot.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slot = exports.isSlot = exports.SlotTypeId = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+/**
+ * A DI hole for a child composition. The parent declares
+ * `slot('Item')<typeof TodoItem>()` and renders through it; the concrete child
+ * is wired with `provide(Item, TodoItem)`, so the parent never imports the
+ * child's *implementation* (the `typeof` is a type-only reference to the
+ * definition). `Comp` lives only in the phantom instance (so `SlotClass` is
+ * covariant and a `{ Item: ItemSlot }` map is well-typed); the match is enforced
+ * by `provide`'s signature, not the (invariant) tag.
+ */
+/** Nominal brand identifying a slot at runtime (Effect's `TypeId` idiom). */
+exports.SlotTypeId = Symbol.for('reform/Slot');
+/** Whether a value is a slot — discriminates a `provide` target by brand. */
+const isSlot = (u) => (typeof u === 'function' || typeof u === 'object') && u !== null && exports.SlotTypeId in u;
+exports.isSlot = isSlot;
+const slot = (name) => 
+// Defaulted so a slot whose child carries no meaningful props/contract can be
+// declared bare (`slot('Tree')()`); pass `typeof Child` to type the facade.
+() => {
+    const tag = effect_1.Context.GenericTag(`reform/slot/${name}`);
+    return (0, definition_js_1.definitionClass)({ [exports.SlotTypeId]: exports.SlotTypeId, kind: 'Slot', tag });
+};
+exports.slot = slot;

package/dist/cjs/compose/ui.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.make = exports.ui = exports.isUi = exports.UiTypeId = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const capture_js_1 = require("../internal/capture.js");
+const errors_js_1 = require("../internal/errors.js");
+const host_js_1 = require("./host.js");
+/** Nominal brand identifying a UI contract at runtime (Effect's `TypeId` idiom). */
+exports.UiTypeId = Symbol.for('reform/Ui');
+/** Whether a value is a UI contract — discriminates a `provide` target by brand. */
+const isUi = (u) => (typeof u === 'function' || typeof u === 'object') && u !== null && exports.UiTypeId in u;
+exports.isUi = isUi;
+/**
+ * A renderer-neutral UI contract. The logic resolves it (`yield* TodoAppUi`) to
+ * a `(props, events) => node` view with slots already bound; `.make` authors the
+ * presentation. Core defines the contract; `@reform/react` does the rendering.
+ */
+const ui = (name) => () => {
+    const impl = effect_1.Context.GenericTag(`reform/ui/${name}`);
+    const read = effect_1.Effect.gen(function* () {
+        const render = yield* impl;
+        // Slots are bound by the host (`@reform/react`) per composition instance.
+        // Core has no renderer, so without a host every slot access throws.
+        const host = yield* effect_1.Effect.serviceOption(host_js_1.CurrentSlots);
+        const slots = new Proxy({}, {
+            get(_t, key) {
+                if (effect_1.Option.isNone(host)) {
+                    throw new errors_js_1.SlotRenderingUnavailable({ slot: String(key) });
+                }
+                return host.value.slot(String(key));
+            },
+        });
+        // A capturing host (proofs, the dev tool) reports each render's observable
+        // surface without replacing the presentation. Absent in production.
+        const sink = yield* effect_1.Effect.serviceOption(capture_js_1.CaptureSink);
+        return (props, events) => {
+            if (effect_1.Option.isSome(sink)) {
+                sink.value.record({
+                    name,
+                    props,
+                    events: (events ?? {}),
+                });
+            }
+            return render(props, slots, (events ?? {}));
+        };
+    });
+    return (0, definition_js_1.yieldableClass)(read, {
+        [exports.UiTypeId]: exports.UiTypeId,
+        manifest: { kind: 'Ui', name },
+        impl,
+    });
+};
+exports.ui = ui;
+/**
+ * Author the pure presentation for a contract — `Ui.make(TodoAppUi, (props,
+ * slots, events) => node)`. The contract argument fixes the view's types; wire
+ * the result with `provide(contract, view)`.
+ */
+const make = (_contract, view) => view;
+exports.make = make;

package/dist/cjs/definition/definition.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitionClass = exports.yieldableClass = void 0;
+const effect_1 = require("effect");
+const inspect_js_1 = require("../internal/inspect.js");
+/** A definition's `toJSON`: its reflectable manifest, else its raw statics. */
+const describe = (statics) => statics.manifest ?? statics;
+/**
+ * Build a class whose *static* side is itself an Effect, so `yield* TheClass`
+ * runs `read` and returns its value (the same mechanism `Context.Tag` uses).
+ * Subclasses inherit the protocol through the prototype chain, so the user's
+ * `class FeedState extends State.make(...) {}` is yieldable too.
+ *
+ * `statics` (manifest, `.live`, tag, …) are attached as own properties
+ * and likewise inherited by the subclass.
+ */
+const yieldableClass = (read, statics) => {
+    class Base {
+    }
+    Object.setPrototypeOf(Base, read);
+    // `defineProperty` over `Reflect.ownKeys`, not `Object.assign` over
+    // `Object.entries`: a static can shadow a non-writable own property of the
+    // class function (notably `name`, which a `Source`-shaped definition like a
+    // Calc carries) and `assign` would throw on those; and `ownKeys` (unlike
+    // `entries`) carries symbol-keyed statics — the `TypeId` brands.
+    for (const key of Reflect.ownKeys(statics)) {
+        const value = statics[key];
+        Object.defineProperty(Base, key, { value, writable: true, enumerable: true, configurable: true });
+    }
+    // Print like an Effect value (the manifest), not `[object Object]`.
+    (0, inspect_js_1.attachInspectable)(Base, () => describe(statics));
+    return Base;
+};
+exports.yieldableClass = yieldableClass;
+/**
+ * Build a *definition class*: an empty constructible carrying static marker data
+ * (manifest, tag, policy, members, …) that the editor and proof packages reflect
+ * on. Definition interfaces declare phantom, type-only fields — a composition's
+ * `Props`, a family instance's `Key` — that exist purely for inference and have
+ * no runtime value, so the assembled object cannot *structurally* satisfy the
+ * interface. The one assertion to `Class` lives here, documented, instead of a
+ * scattered `as never` / `as unknown as` at every `*.make`.
+ */
+const definitionClass = (statics) => (0, inspect_js_1.attachInspectable)(Object.assign(class {
+}, statics), () => describe(statics));
+exports.definitionClass = definitionClass;

package/dist/cjs/event/event.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigger = exports.dispatch = exports.construct = exports.make = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const bus_js_1 = require("../runtime/bus.js");
+/** A pure data fact. Events depend on nothing — only reducers tie them to state. */
+const make = (name, schema) => {
+    const build = (payload) => ({ _tag: name, ...payload });
+    const trigger = effect_1.Effect.gen(function* () {
+        const bus = yield* bus_js_1.Bus;
+        const runtime = yield* effect_1.Effect.runtime();
+        // Dispatch synchronously: on the unbounded bus `publish` only enqueues and
+        // returns, so `runSync` never suspends and no fiber is forked per UI event.
+        // The drain loop still folds reducers on its own fiber — publish is pure offer.
+        return (payload) => {
+            effect_1.Runtime.runSync(runtime)(effect_1.PubSub.publish(bus, { priority: 'High', event: build(payload) }));
+        };
+    });
+    return (0, definition_js_1.definitionClass)({
+        manifest: { kind: 'Event', name, schema },
+        tag: name,
+        build,
+        trigger,
+    });
+};
+exports.make = make;
+/** Construct the tagged value for an event (used for `boot` events). */
+const construct = (event, payload) => event.build(payload);
+exports.construct = construct;
+/** Dispatch as a follow-up (Normal priority) from a procedure/effect. */
+const dispatch = (event, payload) => (0, bus_js_1.publish)('Normal', event.build(payload));
+exports.dispatch = dispatch;
+/** A callback for the UI that dispatches at High priority via the runtime. */
+const trigger = (event) => event.trigger;
+exports.trigger = trigger;

package/dist/cjs/event/eventGroup.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.make = void 0;
+const definition_js_1 = require("../definition/definition.js");
+/** Compose events into a group, the same variadic shape as `StateGroup`/`RpcGroup`. */
+const make = (...members) => (0, definition_js_1.definitionClass)({ kind: 'EventGroup', members });
+exports.make = make;

package/dist/cjs/feature/feature.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountFeature = exports.make = exports.isFeature = exports.isFeatureBinding = exports.FeatureBindingTypeId = exports.lazyImport = exports.featureModule = void 0;
+const effect_1 = require("effect");
+const errors_js_1 = require("../internal/errors.js");
+const definition_js_1 = require("../definition/definition.js");
+const bus_js_1 = require("../runtime/bus.js");
+/**
+ * Publish a feature's lazy half: pair its `requires` (a runtime tuple of shared
+ * carriers) with its `layer`. The covariant `RIn` bound does the checking — a
+ * layer that reaches for any service outside `EngineServices | ProvidedBy<requires>`
+ * is not assignable, so it fails to compile right here, next to the layer, with no
+ * cast. Listing an unused carrier is harmless; omitting a needed one is a type error.
+ *
+ * The bound also forbids a feature from *providing* `EngineServices` (they may only
+ * be open `RIn`), structurally enforcing the liveness rule: a feature can never
+ * bundle its own engine — it always shares the root's bus and registries.
+ */
+const featureModule = (requires, layer) => ({ requires, layer });
+exports.featureModule = featureModule;
+/**
+ * Wrap a dynamic `import()` of a feature's `.live` module as an `Effect` — Reform
+ * never exposes a Promise/`await` on the feature surface. The unavoidable thenable
+ * is sealed here; a rejected import (missing chunk, network failure, module-eval
+ * throw) surfaces as a typed `FeatureLoadFailed` the host hands to
+ * `placeholder.failed`. The module's default export is its `FeatureModule`.
+ */
+const lazyImport = (thunk) => effect_1.Effect.tryPromise({
+    try: thunk,
+    catch: (cause) => new errors_js_1.FeatureLoadFailed({ cause }),
+}).pipe(effect_1.Effect.map((module) => module.default));
+exports.lazyImport = lazyImport;
+/** Nominal brand identifying the value a `provide(slot, Feature)` puts under a slot tag. */
+exports.FeatureBindingTypeId = Symbol.for('reform/FeatureBinding');
+/** Whether a slot's bound child is a lazy/eager feature (vs a plain composition). */
+const isFeatureBinding = (u) => typeof u === 'object' && u !== null && exports.FeatureBindingTypeId in u;
+exports.isFeatureBinding = isFeatureBinding;
+/** Whether a value is a feature definition (its target shape in `provide(slot, Feature)`). */
+const isFeature = (u) => (typeof u === 'function' || typeof u === 'object') &&
+    u !== null &&
+    'manifest' in u &&
+    u.manifest?.kind === 'Feature';
+exports.isFeature = isFeature;
+/**
+ * Define a feature. The whole-app shape (this manifest, the composition, the
+ * placeholders) stays eager and reflectable; the `.live` layer in `module`/`load`
+ * is the deferred chunk. Flip `loadingStrategy` from `'default'` to `'lazy'` and
+ * the discriminated config *requires* `placeholder` — the compiler walks you to a
+ * complete code-split feature.
+ */
+const make = (name, config) => {
+    const strategy = config.loadingStrategy ?? 'default';
+    const load = 'load' in config ? config.load : effect_1.Effect.succeed(config.module);
+    const eagerModule = 'module' in config ? config.module : undefined;
+    const placeholder = 'placeholder' in config ? config.placeholder : undefined;
+    const manifest = {
+        kind: 'Feature',
+        name,
+        strategy,
+        composition: config.composition.manifest,
+        ...(placeholder
+            ? { placeholder: { loading: placeholder.loading.manifest, failed: placeholder.failed.manifest } }
+            : {}),
+    };
+    const binding = {
+        [exports.FeatureBindingTypeId]: exports.FeatureBindingTypeId,
+        manifest,
+        composition: config.composition,
+        strategy,
+        // The host is strategy-uniform: `default`'s `load` resolves immediately. The
+        // assignment to the erased `LoadedModule` needs no cast — see `LoadedModule`.
+        load,
+        ...(placeholder ? { placeholder: { loading: placeholder.loading, failed: placeholder.failed } } : {}),
+        boot: config.boot ?? [],
+    };
+    return (0, definition_js_1.definitionClass)({ manifest, load, binding, eagerModule });
+};
+exports.make = make;
+/**
+ * Mount a feature against a live engine. The renderer-neutral lifecycle, run on a
+ * per-feature `Scope`: load the module (an Effect — lazy = dynamic import; default
+ * = immediate), build its `.live` layer against the host's live `engineContext`
+ * (so its reducers/procedures register into the SHARED registries and its fibers
+ * fork onto this scope), then dispatch the feature's `boot`. Returns the merged
+ * context — engine services + the feature's own services — for the host to read
+ * the feature's composition and stores. Closing the scope disposes exactly this
+ * feature: its fibers stop and its stores are reclaimed.
+ *
+ * The single boundary cast (mirroring `buildRuntime`): `module.layer` is erased to
+ * `LoadedModule` so the host stays strategy- and type-uniform. The feature's real
+ * `RIn` was verified cast-free at `provide(slot, Feature)` and scene wiring; here
+ * we re-attach the concrete `engineContext` it builds against. `R` is the engine
+ * context's service set, supplied by the host.
+ */
+const mountFeature = (binding, engineContext) => effect_1.Effect.gen(function* () {
+    const { layer } = yield* binding.load;
+    const featureLayer = layer;
+    const context = yield* effect_1.Layer.build(effect_1.Layer.provideMerge(featureLayer, effect_1.Layer.succeedContext(engineContext)));
+    yield* effect_1.Effect.forEach(binding.boot, (event) => (0, bus_js_1.publish)('High', event), { discard: true }).pipe(effect_1.Effect.provide(context));
+    return context;
+});
+exports.mountFeature = mountFeature;

package/dist/cjs/index.js

@@ -0,0 +1,116 @@
+"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.defaultScheduler = exports.UnknownGroupState = exports.SlotRenderingUnavailable = exports.InvalidProvideTarget = exports.FeatureLoadFailed = exports.DuplicateRegistration = exports.AsyncReducer = exports.CaptureSink = exports.CurrentTracker = exports.Procedures = exports.Channels = exports.Reducers = exports.Engine = exports.publish = exports.Bus = exports.seedScene = exports.scene = exports.isScene = exports.mountFeature = exports.lazyImport = exports.isFeatureBinding = exports.isFeature = exports.featureModule = exports.FeatureBindingTypeId = exports.Feature = exports.provide = exports.UiTypeId = exports.ui = exports.isUi = exports.Ui = exports.CurrentSlots = exports.SlotTypeId = exports.slot = exports.isSlot = exports.Props = exports.Composition = exports.Channel = exports.Procedure = exports.Boundary = exports.RemoteState = exports.AsyncCalc = exports.CalcFamily = exports.Calc = exports.Reducer = exports.EventGroup = exports.Event = exports.StateToken = exports.StateFamily = exports.StateGroup = exports.State = void 0;
+exports.notificationsLayer = exports.Notifications = exports.makeScheduler = void 0;
+// Reform core — the renderer-neutral primitives and runtime.
+// Definitions (`X.make`) are separate from implementations (`.live`)
+// throughout, and nothing self-registers on import (principle #1, #6).
+exports.State = __importStar(require("./state/state.js"));
+exports.StateGroup = __importStar(require("./state/stateGroup.js"));
+exports.StateFamily = __importStar(require("./state/stateFamily.js"));
+var token_js_1 = require("./state/token.js");
+Object.defineProperty(exports, "StateToken", { enumerable: true, get: function () { return token_js_1.StateToken; } });
+exports.Event = __importStar(require("./event/event.js"));
+exports.EventGroup = __importStar(require("./event/eventGroup.js"));
+exports.Reducer = __importStar(require("./reducer/reducer.js"));
+exports.Calc = __importStar(require("./calc/calc.js"));
+exports.CalcFamily = __importStar(require("./calc/calcFamily.js"));
+exports.AsyncCalc = __importStar(require("./calc/asyncCalc.js"));
+exports.RemoteState = __importStar(require("./remote/remoteState.js"));
+exports.Boundary = __importStar(require("./boundary/boundary.js"));
+exports.Procedure = __importStar(require("./procedure/procedure.js"));
+exports.Channel = __importStar(require("./channel/channel.js"));
+exports.Composition = __importStar(require("./compose/composition.js"));
+var props_js_1 = require("./compose/props.js");
+Object.defineProperty(exports, "Props", { enumerable: true, get: function () { return props_js_1.Props; } });
+var slot_js_1 = require("./compose/slot.js");
+Object.defineProperty(exports, "isSlot", { enumerable: true, get: function () { return slot_js_1.isSlot; } });
+Object.defineProperty(exports, "slot", { enumerable: true, get: function () { return slot_js_1.slot; } });
+Object.defineProperty(exports, "SlotTypeId", { enumerable: true, get: function () { return slot_js_1.SlotTypeId; } });
+var host_js_1 = require("./compose/host.js");
+Object.defineProperty(exports, "CurrentSlots", { enumerable: true, get: function () { return host_js_1.CurrentSlots; } });
+exports.Ui = __importStar(require("./compose/ui.js"));
+var ui_js_1 = require("./compose/ui.js");
+Object.defineProperty(exports, "isUi", { enumerable: true, get: function () { return ui_js_1.isUi; } });
+Object.defineProperty(exports, "ui", { enumerable: true, get: function () { return ui_js_1.ui; } });
+Object.defineProperty(exports, "UiTypeId", { enumerable: true, get: function () { return ui_js_1.UiTypeId; } });
+var provide_js_1 = require("./compose/provide.js");
+Object.defineProperty(exports, "provide", { enumerable: true, get: function () { return provide_js_1.provide; } });
+// Feature: the lazy/eager code-split unit. Definitions stay eager and reflectable;
+// the heavy `.live` layer loads on demand (an Effect, never a Promise). See LAZY.md.
+exports.Feature = __importStar(require("./feature/feature.js"));
+var feature_js_1 = require("./feature/feature.js");
+Object.defineProperty(exports, "FeatureBindingTypeId", { enumerable: true, get: function () { return feature_js_1.FeatureBindingTypeId; } });
+Object.defineProperty(exports, "featureModule", { enumerable: true, get: function () { return feature_js_1.featureModule; } });
+Object.defineProperty(exports, "isFeature", { enumerable: true, get: function () { return feature_js_1.isFeature; } });
+Object.defineProperty(exports, "isFeatureBinding", { enumerable: true, get: function () { return feature_js_1.isFeatureBinding; } });
+Object.defineProperty(exports, "lazyImport", { enumerable: true, get: function () { return feature_js_1.lazyImport; } });
+Object.defineProperty(exports, "mountFeature", { enumerable: true, get: function () { return feature_js_1.mountFeature; } });
+// A scene bundles a composition with the closed wiring that runs it — the single
+// handle the react host, proofs, and the dev tool all consume.
+var scene_js_1 = require("./scene/scene.js");
+Object.defineProperty(exports, "isScene", { enumerable: true, get: function () { return scene_js_1.isScene; } });
+Object.defineProperty(exports, "scene", { enumerable: true, get: function () { return scene_js_1.scene; } });
+Object.defineProperty(exports, "seedScene", { enumerable: true, get: function () { return scene_js_1.seedScene; } });
+// Runtime surface for hosts (`@reform/react`) and headless tests.
+var bus_js_1 = require("./runtime/bus.js");
+Object.defineProperty(exports, "Bus", { enumerable: true, get: function () { return bus_js_1.Bus; } });
+Object.defineProperty(exports, "publish", { enumerable: true, get: function () { return bus_js_1.publish; } });
+var loop_js_1 = require("./runtime/loop.js");
+Object.defineProperty(exports, "Engine", { enumerable: true, get: function () { return loop_js_1.Engine; } });
+Object.defineProperty(exports, "Reducers", { enumerable: true, get: function () { return loop_js_1.Reducers; } });
+var channel_js_1 = require("./channel/channel.js");
+Object.defineProperty(exports, "Channels", { enumerable: true, get: function () { return channel_js_1.Channels; } });
+Object.defineProperty(exports, "Procedures", { enumerable: true, get: function () { return channel_js_1.Procedures; } });
+var track_js_1 = require("./internal/track.js");
+Object.defineProperty(exports, "CurrentTracker", { enumerable: true, get: function () { return track_js_1.CurrentTracker; } });
+var capture_js_1 = require("./internal/capture.js");
+Object.defineProperty(exports, "CaptureSink", { enumerable: true, get: function () { return capture_js_1.CaptureSink; } });
+var errors_js_1 = require("./internal/errors.js");
+Object.defineProperty(exports, "AsyncReducer", { enumerable: true, get: function () { return errors_js_1.AsyncReducer; } });
+Object.defineProperty(exports, "DuplicateRegistration", { enumerable: true, get: function () { return errors_js_1.DuplicateRegistration; } });
+Object.defineProperty(exports, "FeatureLoadFailed", { enumerable: true, get: function () { return errors_js_1.FeatureLoadFailed; } });
+Object.defineProperty(exports, "InvalidProvideTarget", { enumerable: true, get: function () { return errors_js_1.InvalidProvideTarget; } });
+Object.defineProperty(exports, "SlotRenderingUnavailable", { enumerable: true, get: function () { return errors_js_1.SlotRenderingUnavailable; } });
+Object.defineProperty(exports, "UnknownGroupState", { enumerable: true, get: function () { return errors_js_1.UnknownGroupState; } });
+// Notification scheduler: hosts that need per-runtime isolation (concurrent SSR,
+// multiple mounted roots) provide `Notifications` upstream of their state layers;
+// everything else coalesces on the process-wide default.
+var scheduler_js_1 = require("./internal/scheduler.js");
+Object.defineProperty(exports, "defaultScheduler", { enumerable: true, get: function () { return scheduler_js_1.defaultScheduler; } });
+Object.defineProperty(exports, "makeScheduler", { enumerable: true, get: function () { return scheduler_js_1.makeScheduler; } });
+Object.defineProperty(exports, "Notifications", { enumerable: true, get: function () { return scheduler_js_1.Notifications; } });
+Object.defineProperty(exports, "notificationsLayer", { enumerable: true, get: function () { return scheduler_js_1.notificationsLayer; } });

package/dist/cjs/internal/capture.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptureSink = void 0;
+const effect_1 = require("effect");
+/**
+ * An OPTIONAL service. Core's `ui` read consults it via `serviceOption`: when a
+ * capturing host provides it (proofs, the dev tool), every resolved view reports
+ * its `(props, events)` before rendering, giving a faithful tree without
+ * replacing any presentation. Production never provides it, so nothing is
+ * recorded and there is no cost beyond one `serviceOption` lookup per render.
+ */
+class CaptureSink extends effect_1.Context.Tag('reform/internal/CaptureSink')() {
+}
+exports.CaptureSink = CaptureSink;

package/dist/cjs/internal/ctx.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/internal/errors.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateRegistration = exports.AsyncReducer = exports.FeatureLoadFailed = exports.UnknownGroupState = exports.InvalidProvideTarget = exports.SlotRenderingUnavailable = void 0;
+const effect_1 = require("effect");
+/**
+ * Tagged errors for the framework's synchronous boundaries. Even when thrown
+ * (React render, layer build, reflection), an error carries a `_tag` and its
+ * structured fields — never a bare `Error` — so callers and tooling can match on
+ * it. `Data.TaggedError` subclasses are real `Error`s, so `throw` still works.
+ */
+/** A `<slots.X/>` was rendered without a render-target host to realize it. */
+class SlotRenderingUnavailable extends effect_1.Data.TaggedError('reform/SlotRenderingUnavailable') {
+    get message() {
+        return `reform: rendering slot '${this.slot}' requires @reform/react`;
+    }
+}
+exports.SlotRenderingUnavailable = SlotRenderingUnavailable;
+/** `provide(target, …)` was handed something that is neither a ui contract nor a slot. */
+class InvalidProvideTarget extends effect_1.Data.TaggedError('reform/InvalidProvideTarget') {
+    get message() {
+        return 'reform: provide target is neither a ui contract nor a slot';
+    }
+}
+exports.InvalidProvideTarget = InvalidProvideTarget;
+/** `StateGroup.select(group, name)` named a state the group does not contain. */
+class UnknownGroupState extends effect_1.Data.TaggedError('reform/UnknownGroupState') {
+    get message() {
+        return `reform: unknown state '${this.name}' in group`;
+    }
+}
+exports.UnknownGroupState = UnknownGroupState;
+/**
+ * A lazy `Feature`'s `load` Effect failed — the dynamic `import()` rejected (a
+ * missing chunk, a network failure, a module-eval throw). Surfaced as a typed
+ * failure the host hands to the feature's `placeholder.failed`, never a bare
+ * rejection. `cause` is the original rejection value.
+ */
+class FeatureLoadFailed extends effect_1.Data.TaggedError('reform/FeatureLoadFailed') {
+    get message() {
+        return `reform: a feature failed to load (${String(this.cause)})`;
+    }
+}
+exports.FeatureLoadFailed = FeatureLoadFailed;
+/** A reducer fold returned a thenable — folds must be pure synchronous writes. */
+class AsyncReducer extends effect_1.Data.TaggedError('reform/AsyncReducer') {
+    get message() {
+        return 'reform: a reducer fold must be synchronous (it returned a Promise)';
+    }
+}
+exports.AsyncReducer = AsyncReducer;
+/**
+ * Two distinct primitives were registered under one name into the same runtime —
+ * a silent footgun, since names key DI tags and channel lanes. Thrown for a
+ * channel name reused with a different policy (the second would otherwise be
+ * dropped). Reducer/procedure name clashes are warned (logged), not thrown.
+ */
+class DuplicateRegistration extends effect_1.Data.TaggedError('reform/DuplicateRegistration') {
+    get message() {
+        return `reform: duplicate ${this.kind} registered under name '${this.name}'`;
+    }
+}
+exports.DuplicateRegistration = DuplicateRegistration;

package/dist/cjs/internal/inspect.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachInspectable = exports.inspectable = exports.NodeInspectSymbol = void 0;
+const Inspectable_1 = require("effect/Inspectable");
+Object.defineProperty(exports, "NodeInspectSymbol", { enumerable: true, get: function () { return Inspectable_1.NodeInspectSymbol; } });
+/**
+ * The `Inspectable` trio built around a `toJSON`, so every reform value prints
+ * like an Effect value — `_id`-tagged JSON under `console.log`, Node's
+ * inspector, `JSON.stringify`, and `String(...)` — instead of `[object Object]`.
+ * Mirrors Effect's `BaseProto` / `Inspectable.Class` (`Inspectable.ts:170`).
+ */
+const inspectable = (toJSON) => ({
+    toJSON,
+    toString: () => (0, Inspectable_1.format)(toJSON()),
+    [Inspectable_1.NodeInspectSymbol]: () => toJSON(),
+});
+exports.inspectable = inspectable;
+/**
+ * Attach the `Inspectable` trio to an existing object as *non-enumerable* own
+ * properties (so they don't show up in `Object.keys`/`for…in` over a definition
+ * class). Used where the value is built by other means — the definition classes,
+ * whose statics are merged in separately.
+ */
+const attachInspectable = (target, toJSON) => {
+    const trio = (0, exports.inspectable)(toJSON);
+    for (const key of Reflect.ownKeys(trio)) {
+        Object.defineProperty(target, key, {
+            value: trio[key],
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return target;
+};
+exports.attachInspectable = attachInspectable;