@playfast/reform 0.0.1

package/dist/dts/compose/composition.d.ts

@@ -0,0 +1,72 @@
+import { Context, Effect, Layer, type Schema } from 'effect';
+import type { YieldWrap } from 'effect/Utils';
+import { type Manifest } from '../definition/definition.js';
+import { type Ctx } from '../internal/ctx.js';
+import type { Tracker } from '../internal/track.js';
+import { type SlotHost } from './host.js';
+import type { Node, SlotClass } from './slot.js';
+import type { UiClass, UiContract } from './ui.js';
+import { Props } from './props.js';
+/** Everything the host injects per render: the instance props, the dependency tracker, and slot bindings. */
+export interface RenderEnv {
+    readonly props: unknown;
+    readonly tracker: Tracker;
+    readonly slots: SlotHost;
+}
+/** A mounted composition: given a render environment, produces the current frame's node. */
+export interface CompositionService {
+    readonly render: (env: RenderEnv) => Effect.Effect<Node, never, never>;
+}
+export interface CompositionConfig {
+    readonly title: string;
+    readonly description?: string;
+    readonly props?: Schema.Schema<any, any>;
+    readonly states?: ReadonlyArray<unknown>;
+    readonly calcs?: ReadonlyArray<unknown>;
+    readonly events?: ReadonlyArray<unknown>;
+    readonly slots?: Record<string, SlotClass>;
+    readonly ui: {
+        readonly manifest: Manifest & {
+            readonly kind: 'Ui';
+        };
+    };
+}
+type PropsOf<Config> = Config extends {
+    props: Schema.Schema<infer P, any>;
+} ? P : unknown;
+export interface CompositionClass<out P, out C extends UiContract = UiContract> {
+    new (): {};
+    readonly manifest: Manifest & {
+        readonly kind: 'Composition';
+    } & CompositionConfig;
+    /** Phantom carrying the props type for `provide(slot, composition)` checks. */
+    readonly Props: P;
+    /**
+     * Phantom carrying the resolved UI contract (props + events + slots). It lets
+     * reflection consumers — proofs, the dev tool — recover the full contract from
+     * a composition value and stay fully typed. Covariant (output only); the
+     * invariant `impl` tag is never stored here, so no variance regression.
+     */
+    readonly Contract: C;
+    readonly tag: Context.Tag<CompositionService, CompositionService>;
+}
+/**
+ * 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.
+ */
+export declare const make: <const Config extends CompositionConfig, C extends UiContract>(name: string, config: Config & {
+    readonly ui: UiClass<C>;
+}) => CompositionClass<PropsOf<Config>, C>;
+/**
+ * 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.
+ */
+export declare const live: <P, Eff extends YieldWrap<Effect.Effect<unknown, never, unknown>>>(composition: CompositionClass<P, any>, body: () => Generator<Eff, Node, never>) => Layer.Layer<CompositionService, never, Exclude<Ctx<Eff>, Props>>;
+/** Run a mounted composition for one frame, producing its node. */
+export declare const render: (service: CompositionService, env: RenderEnv) => Effect.Effect<Node, never, never>;
+export {};
+//# sourceMappingURL=composition.d.ts.map

package/dist/dts/compose/composition.d.ts.map

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

package/dist/dts/compose/host.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'effect';
+import type { Node } from './slot.js';
+/**
+ * Binds a parent's slots to concrete child renderers. The host package
+ * (`@reform/react`) builds one per composition instance from the manifest's
+ * slot map; the `ui` read consults it so `<slots.Item .../>` renders the wired
+ * child. Core stays renderer-neutral — it only defines this hole.
+ */
+export interface SlotHost {
+    slot(name: string): (props: unknown) => Node;
+}
+declare const CurrentSlots_base: Context.TagClass<CurrentSlots, "reform/Slots", SlotHost>;
+/** The active composition's slot bindings, provided per render by the host. */
+export declare class CurrentSlots extends CurrentSlots_base {
+}
+export {};
+//# sourceMappingURL=host.d.ts.map

package/dist/dts/compose/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../src/compose/host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CAC7C;;AAED,+EAA+E;AAC/E,qBAAa,YAAa,SAAQ,iBAAqD;CAAG"}

package/dist/dts/compose/props.d.ts

@@ -0,0 +1,13 @@
+import { Context } from 'effect';
+declare const Props_base: Context.TagClass<Props, "reform/Props", any>;
+/**
+ * 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.)
+ */
+export declare class Props extends Props_base {
+}
+export {};
+//# sourceMappingURL=props.d.ts.map

package/dist/dts/compose/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/compose/props.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;;AAEhC;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAAyC;CAAG"}

package/dist/dts/compose/provide.d.ts

@@ -0,0 +1,22 @@
+import { Layer } from 'effect';
+import type { CompositionClass } from './composition.js';
+import { type EngineServices, type FeatureClass, type ProvidedBy, type RequireCarrier } from '../feature/feature.js';
+import { type SlotChild, type SlotClass } from './slot.js';
+import { type UiClass, type UiContract, type ViewImpl } from './ui.js';
+/**
+ * Wire an implementation to a contract. Provides a `.make` presentation to a UI
+ * contract, a child composition into a parent's slot, or a `Feature` into a slot.
+ * The compose code never imports its implementations — they meet here.
+ */
+export declare function provide<C extends UiContract>(contract: UiClass<C>, view: ViewImpl<C>): Layer.Layer<ViewImpl<C>>;
+export declare function provide<Comp extends CompositionClass<any, any>>(hole: SlotClass<Comp>, composition: Comp): Layer.Layer<CompositionClass<unknown>>;
+/**
+ * Fill a slot with a feature. The slot's child composition type
+ * (`CompositionClass<P, C>`) must match the feature's mounted composition, so the
+ * facade/contract stays typed. The returned layer surfaces the feature's shared
+ * requirement (`EngineServices | ProvidedBy<Requires>`) as an open `RIn`, so the
+ * scene that wires it won't compile unless it provides the matching `Core` — even
+ * for a lazy feature whose own `.live` layer isn't built until mount.
+ */
+export declare function provide<Comp extends CompositionClass<any, any>, ROut, Requires extends ReadonlyArray<RequireCarrier>>(hole: SlotClass<Comp>, feature: FeatureClass<Comp extends CompositionClass<infer P, any> ? P : never, Comp extends CompositionClass<any, infer C> ? C : never, ROut, Requires>): Layer.Layer<SlotChild, never, EngineServices | ProvidedBy<Requires>>;
+//# sourceMappingURL=provide.d.ts.map

package/dist/dts/compose/provide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provide.d.ts","sourceRoot":"","sources":["../../../src/compose/provide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAU,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC/D,OAAO,EAAQ,KAAK,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,MAAM,CAAA;AAEzE;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,UAAU,EAC1C,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EACpB,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAChB,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AAC3B,wBAAgB,OAAO,CAAC,IAAI,SAAS,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EAC7D,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,EACrB,WAAW,EAAE,IAAI,GAChB,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAA;AACzC;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACrB,IAAI,SAAS,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EACvC,IAAI,EACJ,QAAQ,SAAS,aAAa,CAAC,cAAc,CAAC,EAE9C,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,EACrB,OAAO,EAAE,YAAY,CACnB,IAAI,SAAS,gBAAgB,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,EACvD,IAAI,SAAS,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,EACvD,IAAI,EACJ,QAAQ,CACT,GACA,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,cAAc,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAA"}

package/dist/dts/compose/slot.d.ts

@@ -0,0 +1,49 @@
+import { Context } from 'effect';
+import type { CompositionClass } from './composition.js';
+import type { FeatureBinding } from '../feature/feature.js';
+import type { Node } from '../ui/node.js';
+export type { Node };
+/** Any composition, used where only the slot's structural role matters. */
+type AnyComposition = CompositionClass<any, any>;
+/**
+ * What a slot can be filled with: a plain child composition (the host renders it
+ * directly), or a `FeatureBinding` from `provide(slot, Feature)` (the host drives
+ * its lazy/eager mount lifecycle). The slot's DI tag holds one of these; the host
+ * discriminates by the `FeatureBinding` brand.
+ */
+export type SlotChild = CompositionClass<unknown> | FeatureBinding;
+/**
+ * Phantom instance shape: `ItemSlot` used as a *type* denotes this. It carries
+ * the child *composition* type `Comp`, so the slot knows both the external props
+ * the parent renders it with (`Comp['Props']`) and the child's full UI contract
+ * (`Comp['Contract']` — props + events + slots) that reflection consumers, the
+ * proof facade, drive.
+ */
+export interface SlotInstance<Comp extends AnyComposition> {
+    readonly _slot: Comp;
+}
+/**
+ * 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). */
+export declare const SlotTypeId: unique symbol;
+export type SlotTypeId = typeof SlotTypeId;
+export interface SlotClass<Comp extends AnyComposition = AnyComposition> {
+    new (): SlotInstance<Comp>;
+    readonly [SlotTypeId]: SlotTypeId;
+    readonly kind: 'Slot';
+    /** Internal DI tag the filling child (composition or feature binding) is provided under. */
+    readonly tag: Context.Tag<SlotChild, SlotChild>;
+}
+/** Whether a value is a slot — discriminates a `provide` target by brand. */
+export declare const isSlot: (u: unknown) => u is SlotClass;
+/** The props a slot renders with — the child composition's external props. */
+export type SlotProps<S> = S extends SlotInstance<infer Comp> ? Comp['Props'] : never;
+export declare const slot: (name: string) => <Comp extends AnyComposition = AnyComposition>() => SlotClass<Comp>;
+//# sourceMappingURL=slot.d.ts.map

package/dist/dts/compose/slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot.d.ts","sourceRoot":"","sources":["../../../src/compose/slot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC,YAAY,EAAE,IAAI,EAAE,CAAA;AAEpB,2EAA2E;AAC3E,KAAK,cAAc,GAAG,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,CAAC,OAAO,CAAC,GAAG,cAAc,CAAA;AAElE;;;;;;GAMG;AACH,MAAM,WAAW,YAAY,CAAC,IAAI,SAAS,cAAc;IACvD,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CACrB;AAED;;;;;;;;GAQG;AACH,6EAA6E;AAC7E,eAAO,MAAM,UAAU,EAAE,OAAO,MAAkC,CAAA;AAClE,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAA;AAE1C,MAAM,WAAW,SAAS,CAAC,IAAI,SAAS,cAAc,GAAG,cAAc;IACrE,QAAQ,YAAY,CAAC,IAAI,CAAC,CAAA;IAC1B,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,UAAU,CAAA;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,4FAA4F;IAC5F,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;CAChD;AAED,6EAA6E;AAC7E,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,SAC4C,CAAA;AAErF,8EAA8E;AAC9E,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,YAAY,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,KAAK,CAAA;AAErF,eAAO,MAAM,IAAI,GACd,MAAM,MAAM,MAGZ,IAAI,SAAS,cAAc,GAAG,cAAc,OAAK,SAAS,CAAC,IAAI,CAG/D,CAAA"}

package/dist/dts/compose/ui.d.ts

@@ -0,0 +1,50 @@
+import { Context, Effect } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import type { Trigger } from '../ui/trigger.js';
+import { type Node, type SlotInstance, type SlotProps } from './slot.js';
+export interface UiContract {
+    props: unknown;
+    slots?: Record<string, SlotInstance<any>>;
+    events?: Record<string, Trigger<any>>;
+}
+type PropsOf<C extends UiContract> = C['props'];
+type EventsOf<C extends UiContract> = C extends {
+    events: infer E;
+} ? E : Record<never, never>;
+type SlotsOf<C extends UiContract> = C extends {
+    slots: infer S;
+} ? {
+    readonly [K in keyof S]: (props: SlotProps<S[K]>) => Node;
+} : Record<never, never>;
+/** What the composition logic calls: props + handlers in, a node out. Slots are bound by the renderer. */
+export type LogicView<C extends UiContract> = (props: PropsOf<C>, events?: EventsOf<C>) => Node;
+/** What `.make` authors: the pure presentation. Slots are injected by the renderer. */
+export type ViewImpl<C extends UiContract> = (props: PropsOf<C>, slots: SlotsOf<C>, events: EventsOf<C>) => Node;
+/** Nominal brand identifying a UI contract at runtime (Effect's `TypeId` idiom). */
+export declare const UiTypeId: unique symbol;
+export type UiTypeId = typeof UiTypeId;
+export interface UiClass<C extends UiContract> extends Effect.Effect<LogicView<C>, never, ViewImpl<C>> {
+    new (): {};
+    readonly [UiTypeId]: UiTypeId;
+    readonly manifest: Manifest & {
+        readonly kind: 'Ui';
+    };
+    /** Internal DI tag the `Ui.make` presentation is provided under. */
+    readonly impl: Context.Tag<ViewImpl<C>, ViewImpl<C>>;
+}
+/** Whether a value is a UI contract — discriminates a `provide` target by brand. */
+export declare const isUi: (u: unknown) => u is UiClass<UiContract>;
+/**
+ * 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.
+ */
+export declare const ui: (name: string) => <C extends UiContract>() => UiClass<C>;
+/**
+ * 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)`.
+ */
+export declare const make: <C extends UiContract>(_contract: UiClass<C>, view: ViewImpl<C>) => ViewImpl<C>;
+export {};
+//# sourceMappingURL=ui.d.ts.map

package/dist/dts/compose/ui.d.ts.map

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

package/dist/dts/definition/definition.d.ts

@@ -0,0 +1,33 @@
+import { Effect } from 'effect';
+/**
+ * The reflectable descriptor every primitive carries (principle #6). The editor
+ * and proof packages read these without running any logic.
+ */
+export type Kind = 'State' | 'StateGroup' | 'StateFamily' | 'Event' | 'EventGroup' | 'Reducer' | 'Calc' | 'CalcFamily' | 'AsyncCalc' | 'RemoteState' | 'Boundary' | 'Procedure' | 'Channel' | 'Composition' | 'Ui' | 'Slot' | 'Feature';
+export interface Manifest {
+    readonly kind: Kind;
+    readonly name: string;
+}
+/**
+ * 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.
+ */
+export declare const yieldableClass: <A, E, R, Statics extends object>(read: Effect.Effect<A, E, R>, statics: Statics) => {
+    new (): {};
+} & Effect.Effect<A, E, R> & Statics;
+/**
+ * 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`.
+ */
+export declare const definitionClass: <Class>(statics: object) => Class;
+//# sourceMappingURL=definition.d.ts.map

package/dist/dts/definition/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/definition/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAM/B;;;GAGG;AACH,MAAM,MAAM,IAAI,GACZ,OAAO,GACP,YAAY,GACZ,aAAa,GACb,OAAO,GACP,YAAY,GACZ,SAAS,GACT,MAAM,GACN,YAAY,GACZ,WAAW,GACX,aAAa,GACb,UAAU,GACV,WAAW,GACX,SAAS,GACT,aAAa,GACb,IAAI,GACJ,MAAM,GACN,SAAS,CAAA;AAEb,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,SAAS,MAAM,EAC5D,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,SAAS,OAAO,KACf;IAAE,QAAQ,EAAE,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,OAe5C,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,EAAE,SAAS,MAAM,KAAG,KACyC,CAAA"}

package/dist/dts/event/event.d.ts

@@ -0,0 +1,33 @@
+import { Effect, type Schema } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { Bus, type Tagged } from '../runtime/bus.js';
+import type { Trigger } from '../ui/trigger.js';
+/** The dispatched value of an event: `{ _tag, ...payload }`, matched with `Match.tags`. */
+export type EventOf<N extends string, P> = Tagged & {
+    readonly _tag: N;
+} & P;
+export interface EventManifest<N extends string, P> extends Manifest {
+    readonly kind: 'Event';
+    readonly name: N;
+    readonly schema: Schema.Schema<P, any>;
+}
+export interface EventClass<out N extends string, in out P> {
+    new (): {};
+    readonly manifest: EventManifest<N, P>;
+    readonly tag: N;
+    /** Carrier for `Event.construct` — builds the tagged value `{ _tag, ...payload }`. */
+    readonly build: (payload: P) => EventOf<N, P>;
+    /** Carrier for `Event.trigger` — the UI callback effect (High priority). */
+    readonly trigger: Effect.Effect<Trigger<P>, never, Bus>;
+}
+export type AnyEvent = EventClass<string, any>;
+export type EventType<E> = E extends EventClass<infer N, infer P> ? EventOf<N, P> : never;
+/** A pure data fact. Events depend on nothing — only reducers tie them to state. */
+export declare const make: <const N extends string, P>(name: N, schema: Schema.Schema<P, any>) => EventClass<N, P>;
+/** Construct the tagged value for an event (used for `boot` events). */
+export declare const construct: <N extends string, P>(event: EventClass<N, P>, payload: P) => EventOf<N, P>;
+/** Dispatch as a follow-up (Normal priority) from a procedure/effect. */
+export declare const dispatch: <N extends string, P>(event: EventClass<N, P>, payload: P) => Effect.Effect<void, never, Bus>;
+/** A callback for the UI that dispatches at High priority via the runtime. */
+export declare const trigger: <N extends string, P>(event: EventClass<N, P>) => Effect.Effect<Trigger<P>, never, Bus>;
+//# sourceMappingURL=event.d.ts.map

package/dist/dts/event/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../src/event/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAmB,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC7D,OAAO,EAAE,KAAK,QAAQ,EAAmB,MAAM,0BAA0B,CAAA;AACzE,OAAO,EAAE,GAAG,EAAW,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,2FAA2F;AAC3F,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,IAAI,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAAG,CAAC,CAAA;AAE5E,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,CAAE,SAAQ,QAAQ;IAClE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IAChB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;IACxD,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IACtC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAA;IACf,sFAAsF;IACtF,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IAC7C,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;CACxD;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAC9C,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAA;AAEzF,oFAAoF;AACpF,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAC5C,MAAM,CAAC,EACP,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,KAC5B,UAAU,CAAC,CAAC,EAAE,CAAC,CAkBjB,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,KAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAC3E,CAAA;AAEtB,yEAAyE;AACzE,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,EAC1C,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EACvB,SAAS,CAAC,KACT,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAA4C,CAAA;AAE7E,8EAA8E;AAC9E,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,EACzC,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KACtB,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAkB,CAAA"}

package/dist/dts/event/eventGroup.d.ts

@@ -0,0 +1,9 @@
+import type { AnyEvent } from './event.js';
+export interface EventGroupClass<Members extends ReadonlyArray<AnyEvent>> {
+    new (): {};
+    readonly kind: 'EventGroup';
+    readonly members: Members;
+}
+/** Compose events into a group, the same variadic shape as `StateGroup`/`RpcGroup`. */
+export declare const make: <const Members extends ReadonlyArray<AnyEvent>>(...members: Members) => EventGroupClass<Members>;
+//# sourceMappingURL=eventGroup.d.ts.map

package/dist/dts/event/eventGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventGroup.d.ts","sourceRoot":"","sources":["../../../src/event/eventGroup.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC,MAAM,WAAW,eAAe,CAAC,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC;IACtE,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,uFAAuF;AACvF,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC,EAChE,GAAG,SAAS,OAAO,KAClB,eAAe,CAAC,OAAO,CAC2D,CAAA"}

package/dist/dts/feature/feature.d.ts

@@ -0,0 +1,220 @@
+import { type Context, Effect, Layer, type Scope } from 'effect';
+import { type Engine } from '../runtime/loop.js';
+import { type StoresOf } from '../internal/sources.js';
+import { FeatureLoadFailed } from '../internal/errors.js';
+import { type Manifest } from '../definition/definition.js';
+import { type CompositionClass } from '../compose/composition.js';
+import { type UiContract } from '../compose/ui.js';
+import { type Tagged } from '../runtime/bus.js';
+/**
+ * The always-on engine services a feature builds against: the shared event `Bus`
+ * plus the reducer/channel/procedure registries. Derived from the `Engine`
+ * layer's output (`runtime/loop.ts`) so it never drifts. A feature layer may name
+ * these only as OPEN requirements (its `RIn`) and must never *provide* them — that
+ * is what keeps the engine single and shared across every lazily-mounted feature.
+ */
+export type EngineServices = Layer.Layer.Success<typeof Engine>;
+/**
+ * A shared-state carrier a feature may declare in `requires`: a `State`,
+ * `StateFamily`, `Calc`, or `AsyncCalc` (each carrying a `store` tag), or a
+ * `StateGroup` (carrying `members`, each with its own `store`). Per the design,
+ * a feature depends on shared state/calc only — never on another feature.
+ */
+export type RequireCarrier = {
+    readonly store: Context.Tag<any, any>;
+} | {
+    readonly members: ReadonlyArray<{
+        readonly store: Context.Tag<any, any>;
+    }>;
+};
+/**
+ * The Context services a `requires` tuple makes available to a feature layer: a
+ * `StateGroup` contributes its members' stores (the shared `StoresOf`); every
+ * other carrier contributes its own `store` service. This is the upper bound a
+ * feature's open `RIn` is checked against. Because `Layer`'s `RIn` is covariant
+ * (`Layer.d.ts` — `out RIn`), a layer that reads anything outside
+ * `EngineServices | ProvidedBy<requires>` is simply not assignable, so the check
+ * is ordinary assignability — no `as`, no `infer` gymnastics in user code.
+ */
+export type ProvidedBy<Requires extends ReadonlyArray<RequireCarrier>> = {
+    [I in keyof Requires]: Requires[I] extends {
+        readonly members: infer M extends ReadonlyArray<unknown>;
+    } ? StoresOf<M> : Requires[I] extends {
+        readonly store: Context.Tag<infer Svc, any>;
+    } ? Svc : never;
+}[number];
+/**
+ * A loaded feature's two artifacts. `requires` is the runtime-enumerable list the
+ * editor reads (types are erased, so the carriers are kept as values); `layer` is
+ * the heavy `.live` half. The bound on `layer`'s `RIn` —
+ * `EngineServices | ProvidedBy<Requires>` — makes the runtime list provably equal
+ * the layer's real requirement set: list too little and the layer no longer type-
+ * checks here. Built by `featureModule`, which is the one sanctioned way to publish
+ * a feature's lazy half.
+ */
+export interface FeatureModule<ROut, Requires extends ReadonlyArray<RequireCarrier>> {
+    readonly requires: Requires;
+    readonly layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires>>;
+}
+/**
+ * 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.
+ */
+export declare const featureModule: <const Requires extends ReadonlyArray<RequireCarrier>, ROut>(requires: Requires, layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires>>) => FeatureModule<ROut, Requires>;
+/**
+ * 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`.
+ */
+export declare const lazyImport: <M>(thunk: () => Promise<{
+    readonly default: M;
+}>) => Effect.Effect<M, FeatureLoadFailed>;
+/** The props the host injects into a lazy feature's `failed` placeholder. */
+export interface FailedProps {
+    readonly error: FeatureLoadFailed;
+    readonly retry: () => void;
+}
+/**
+ * The reflectable shape of a feature: its strategy, the composition it mounts,
+ * and (when lazy) its placeholder compositions — all as manifests, so the editor
+ * route-map renders the whole feature graph with no chunk loaded. `boot` is
+ * runtime data and lives on the `FeatureBinding`, not here.
+ */
+export interface FeatureManifest extends Manifest {
+    readonly kind: 'Feature';
+    readonly name: string;
+    readonly strategy: 'lazy' | 'default';
+    readonly composition: Manifest & {
+        readonly kind: 'Composition';
+    };
+    readonly placeholder?: {
+        readonly loading: Manifest & {
+            readonly kind: 'Composition';
+        };
+        readonly failed: Manifest & {
+            readonly kind: 'Composition';
+        };
+    };
+}
+/**
+ * A feature's loaded artifacts with type params erased, for the renderer-neutral,
+ * strategy-uniform host. The erasure is cast-free *into*: because `Layer`'s `ROut`
+ * is contravariant and `RIn` covariant, every `Layer<ROut, never, R>` is assignable
+ * to `Layer<never, never, unknown>`, so any `FeatureModule<…>` is a `LoadedModule`.
+ * The host re-attaches the concrete root context when it builds `layer` (one
+ * documented boundary cast there, mirroring `buildRuntime`).
+ */
+export interface LoadedModule {
+    readonly requires: ReadonlyArray<RequireCarrier>;
+    readonly layer: Layer.Layer<never, never, unknown>;
+}
+/** Nominal brand identifying the value a `provide(slot, Feature)` puts under a slot tag. */
+export declare const FeatureBindingTypeId: unique symbol;
+export type FeatureBindingTypeId = typeof FeatureBindingTypeId;
+/**
+ * What `provide(slot, Feature)` binds under the slot tag — everything the host
+ * needs to mount the feature, with types erased (the host is renderer-neutral and
+ * strategy-uniform). For `default` the host renders `composition` directly; for
+ * `lazy` it drives `load` through an `AsyncData` lifecycle, painting `placeholder`
+ * around it. The `composition`/`placeholder` here are the same `CompositionClass`
+ * values a normal slot fill carries, so the host's existing `Compose` path renders
+ * each.
+ */
+export interface FeatureBinding {
+    readonly [FeatureBindingTypeId]: FeatureBindingTypeId;
+    readonly manifest: FeatureManifest;
+    readonly composition: CompositionClass<unknown>;
+    readonly strategy: 'lazy' | 'default';
+    readonly load: Effect.Effect<LoadedModule, FeatureLoadFailed>;
+    readonly placeholder?: {
+        readonly loading: CompositionClass<unknown>;
+        readonly failed: CompositionClass<unknown>;
+    };
+    readonly boot: ReadonlyArray<Tagged>;
+}
+/** Whether a slot's bound child is a lazy/eager feature (vs a plain composition). */
+export declare const isFeatureBinding: (u: unknown) => u is FeatureBinding;
+/**
+ * A feature *definition*: a reflectable manifest (`kind: 'Feature'`) that carries
+ * the eager half (composition + placeholders) and an Effect `load` for the heavy
+ * `.live` half. `Props`/`Contract` flow from the composition; `Requires` is the
+ * shared-carrier tuple the loaded module declares. `load` is an `Effect`, never a
+ * Promise — consumers `yield* Feature.load`.
+ */
+export interface FeatureClass<P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>> {
+    new (): {};
+    readonly manifest: FeatureManifest;
+    /** Phantom carrying the mounted composition's props type (for `provide` checks). */
+    readonly Props: P;
+    /** Phantom carrying the composition's UI contract (for typed reflection consumers). */
+    readonly Contract: C;
+    /** Phantom carrying the declared shared-carrier tuple. */
+    readonly Requires: Requires;
+    /** Load the feature's module — `yield* Feature.load` → its `FeatureModule`, or `FeatureLoadFailed`. */
+    readonly load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed>;
+    /** The value `provide(slot, Feature)` binds under the slot tag. */
+    readonly binding: FeatureBinding;
+    /** The eagerly-available module — present only for `loadingStrategy: 'default'`. */
+    readonly eagerModule: FeatureModule<ROut, Requires> | undefined;
+}
+export type AnyFeature = FeatureClass<any, any, any, ReadonlyArray<RequireCarrier>>;
+/** Whether a value is a feature definition (its target shape in `provide(slot, Feature)`). */
+export declare const isFeature: (u: unknown) => u is AnyFeature;
+/**
+ * The placeholders a lazy feature must ship — both eager compositions (their
+ * `.live` is in the eager bundle, so they paint the load gap). `loading` receives
+ * the feature's props; `failed` receives `{ error, retry }`. Typed loosely
+ * (`CompositionClass<any>`) because the host injects these props directly — they
+ * are not schema-decoded inputs.
+ */
+export interface Placeholders {
+    readonly loading: CompositionClass<any, UiContract>;
+    readonly failed: CompositionClass<any, UiContract>;
+}
+type FeatureConfig<P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>> = {
+    readonly composition: CompositionClass<P, C>;
+    readonly boot?: ReadonlyArray<Tagged>;
+} & ({
+    readonly loadingStrategy?: 'default';
+    readonly module: FeatureModule<ROut, Requires>;
+} | {
+    readonly loadingStrategy: 'lazy';
+    readonly load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed>;
+    readonly placeholder: Placeholders;
+});
+/**
+ * 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.
+ */
+export declare const make: <P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>>(name: string, config: FeatureConfig<P, C, ROut, Requires>) => FeatureClass<P, C, ROut, Requires>;
+/**
+ * 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.
+ */
+export declare const mountFeature: <R>(binding: FeatureBinding, engineContext: Context.Context<R>) => Effect.Effect<Context.Context<unknown>, FeatureLoadFailed, Scope.Scope>;
+export {};
+//# sourceMappingURL=feature.d.ts.map

package/dist/dts/feature/feature.d.ts.map

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