@playfast/reform 0.0.1

package/dist/dts/index.d.ts

@@ -0,0 +1,43 @@
+export * as State from './state/state.js';
+export * as StateGroup from './state/stateGroup.js';
+export * as StateFamily from './state/stateFamily.js';
+export { StateToken } from './state/token.js';
+export type { AnySource, Source } from './state/token.js';
+export * as Event from './event/event.js';
+export type { EventOf } from './event/event.js';
+export * as EventGroup from './event/eventGroup.js';
+export * as Reducer from './reducer/reducer.js';
+export * as Calc from './calc/calc.js';
+export * as CalcFamily from './calc/calcFamily.js';
+export * as AsyncCalc from './calc/asyncCalc.js';
+export type { InputsObject, InputStores, InvalidateBy } from './internal/sources.js';
+export { type AsyncData, type AsyncError, type AsyncIdle, type AsyncLoading, type AsyncSuccess, } from './calc/asyncData.js';
+export * as RemoteState from './remote/remoteState.js';
+export type { FailedIntent, PendingIntent, RemoteStateClass } from './remote/remoteState.js';
+export * as Boundary from './boundary/boundary.js';
+export type { BoundaryErrored, BoundaryPending, BoundaryReady, BoundaryState, } from './boundary/boundary.js';
+export * as Procedure from './procedure/procedure.js';
+export * as Channel from './channel/channel.js';
+export * as Composition from './compose/composition.js';
+export type { CompositionClass, CompositionService, RenderEnv, } from './compose/composition.js';
+export { Props } from './compose/props.js';
+export { isSlot, type Node, slot, type SlotClass, type SlotInstance, type SlotProps, SlotTypeId, } from './compose/slot.js';
+export { CurrentSlots, type SlotHost } from './compose/host.js';
+export * as Ui from './compose/ui.js';
+export { isUi, type LogicView, ui, type UiClass, type UiContract, UiTypeId, type ViewImpl, } from './compose/ui.js';
+export { provide } from './compose/provide.js';
+export type { Trigger } from './ui/trigger.js';
+export * as Feature from './feature/feature.js';
+export { type EngineServices, type FailedProps, type FeatureBinding, FeatureBindingTypeId, type FeatureClass, type FeatureManifest, featureModule, type FeatureModule, isFeature, isFeatureBinding, lazyImport, type LoadedModule, mountFeature, type Placeholders, type ProvidedBy, type RequireCarrier, } from './feature/feature.js';
+export { type SlotChild } from './compose/slot.js';
+export { isScene, type MountedServices, type Scene, scene, seedScene } from './scene/scene.js';
+export { Bus, type Envelope, type Priority, publish, type Tagged } from './runtime/bus.js';
+export { Engine, type ReducerEntry, Reducers } from './runtime/loop.js';
+export { type ChannelClass, type ChannelPolicy, type ChannelRuntime, Channels, type ProcedureEntry, Procedures, } from './channel/channel.js';
+export { CurrentTracker, type Subscribable, type Tracker } from './internal/track.js';
+export { CaptureSink, type CaptureSinkApi, type UiCapture } from './internal/capture.js';
+export { AsyncReducer, DuplicateRegistration, FeatureLoadFailed, InvalidProvideTarget, SlotRenderingUnavailable, UnknownGroupState, } from './internal/errors.js';
+export { defaultScheduler, makeScheduler, Notifications, notificationsLayer, type Scheduler, } from './internal/scheduler.js';
+export type { Store } from './internal/store.js';
+export type { FamilyStore } from './state/stateFamily.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,eAAe,CAAA;AACtC,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEtD,OAAO,KAAK,KAAK,MAAM,eAAe,CAAA;AAItC,YAAY,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAA;AAEhD,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAA;AAC5C,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAA;AAI7C,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjF,OAAO,EACL,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,WAAW,MAAM,sBAAsB,CAAA;AAInD,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACzF,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAG/C,YAAY,EACV,eAAe,EACf,eAAe,EACf,aAAa,EACb,aAAa,GACd,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,SAAS,MAAM,uBAAuB,CAAA;AAClD,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAA;AAE5C,OAAO,KAAK,WAAW,MAAM,uBAAuB,CAAA;AACpD,YAAY,EACV,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,GACV,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EACL,MAAM,EACN,KAAK,IAAI,EACT,IAAI,EACJ,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,UAAU,GACX,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,KAAK,EAAE,MAAM,cAAc,CAAA;AAClC,OAAO,EACL,IAAI,EACJ,KAAK,SAAS,EACd,EAAE,EACF,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,QAAQ,EACR,KAAK,QAAQ,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3C,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAI3C,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAA;AAC5C,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,aAAa,EACb,KAAK,aAAa,EAClB,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,KAAK,YAAY,EACjB,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,cAAc,GACpB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAI/C,OAAO,EAAE,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAG3F,OAAO,EAAE,GAAG,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AACvF,OAAO,EAAE,MAAM,EAAE,KAAK,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACpE,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,QAAQ,EACR,KAAK,cAAc,EACnB,UAAU,GACX,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAClF,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACrF,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,wBAAwB,EACxB,iBAAiB,GAClB,MAAM,mBAAmB,CAAA;AAI1B,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,KAAK,SAAS,GACf,MAAM,sBAAsB,CAAA;AAC7B,YAAY,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC7C,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/dts/internal/capture.d.ts

@@ -0,0 +1,28 @@
+import { Context } from 'effect';
+import type { Trigger } from '../ui/trigger.js';
+/**
+ * A single rendered UI node's observable surface: which contract rendered, the
+ * props it received, and the event triggers it was handed. This is exactly what
+ * a headless inspector (the proof facade, the dev tool) needs — no DOM, no JSX.
+ */
+export interface UiCapture {
+    readonly name: string;
+    readonly props: unknown;
+    readonly events: Record<string, Trigger<unknown>>;
+}
+/** Where captured renders are reported, when a capturing host is present. */
+export interface CaptureSinkApi {
+    record(capture: UiCapture): void;
+}
+declare const CaptureSink_base: Context.TagClass<CaptureSink, "reform/internal/CaptureSink", CaptureSinkApi>;
+/**
+ * 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.
+ */
+export declare class CaptureSink extends CaptureSink_base {
+}
+export {};
+//# sourceMappingURL=capture.d.ts.map

package/dist/dts/internal/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../../src/internal/capture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;CAClD;AAED,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;CACjC;;AAED;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,gBAG9B;CAAG"}

package/dist/dts/internal/ctx.d.ts

@@ -0,0 +1,12 @@
+import type { Effect } from 'effect';
+import type { YieldWrap } from 'effect/Utils';
+/**
+ * The context (`R`) a generator body requires, recovered from the effects it
+ * yields. Shared by `Composition.live` and `Procedure.live`, whose bodies are
+ * both `Generator`s whose requirements must surface as their layer's `RIn`.
+ *
+ * A body that never yields (`Eff = never`) requires nothing — guard that case
+ * first, or `infer R` resolves to `unknown` and leaks into the layer's `RIn`.
+ */
+export type Ctx<Eff> = [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<any, any, infer R>>] ? R : never;
+//# sourceMappingURL=ctx.d.ts.map

package/dist/dts/internal/ctx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctx.d.ts","sourceRoot":"","sources":["../../../src/internal/ctx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C;;;;;;;GAOG;AACH,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,GACxC,KAAK,GACL,CAAC,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GACzD,CAAC,GACD,KAAK,CAAA"}

package/dist/dts/internal/errors.d.ts

@@ -0,0 +1,69 @@
+declare const SlotRenderingUnavailable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/SlotRenderingUnavailable";
+} & Readonly<A>;
+/**
+ * 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. */
+export declare class SlotRenderingUnavailable extends SlotRenderingUnavailable_base<{
+    readonly slot: string;
+}> {
+    get message(): string;
+}
+declare const InvalidProvideTarget_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/InvalidProvideTarget";
+} & Readonly<A>;
+/** `provide(target, …)` was handed something that is neither a ui contract nor a slot. */
+export declare class InvalidProvideTarget extends InvalidProvideTarget_base<{}> {
+    get message(): string;
+}
+declare const UnknownGroupState_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/UnknownGroupState";
+} & Readonly<A>;
+/** `StateGroup.select(group, name)` named a state the group does not contain. */
+export declare class UnknownGroupState extends UnknownGroupState_base<{
+    readonly name: string;
+}> {
+    get message(): string;
+}
+declare const FeatureLoadFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/FeatureLoadFailed";
+} & Readonly<A>;
+/**
+ * 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.
+ */
+export declare class FeatureLoadFailed extends FeatureLoadFailed_base<{
+    readonly cause: unknown;
+}> {
+    get message(): string;
+}
+declare const AsyncReducer_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/AsyncReducer";
+} & Readonly<A>;
+/** A reducer fold returned a thenable — folds must be pure synchronous writes. */
+export declare class AsyncReducer extends AsyncReducer_base<{}> {
+    get message(): string;
+}
+declare const DuplicateRegistration_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/DuplicateRegistration";
+} & Readonly<A>;
+/**
+ * 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.
+ */
+export declare class DuplicateRegistration extends DuplicateRegistration_base<{
+    readonly kind: string;
+    readonly name: string;
+}> {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/dts/internal/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/internal/errors.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AAEH,8EAA8E;AAC9E,qBAAa,wBAAyB,SAAQ,8BAAoD;IAChG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,0FAA0F;AAC1F,qBAAa,oBAAqB,SAAQ,0BAAgD,EAAE,CAAC;IAC3F,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,iFAAiF;AACjF,qBAAa,iBAAkB,SAAQ,uBAA6C;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,uBAA6C;IAClF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,kFAAkF;AAClF,qBAAa,YAAa,SAAQ,kBAAwC,EAAE,CAAC;IAC3E,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,2BAAiD;IAC1F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/dts/internal/inspect.d.ts

@@ -0,0 +1,17 @@
+import { type Inspectable, NodeInspectSymbol } from 'effect/Inspectable';
+export { type Inspectable, 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`).
+ */
+export declare const inspectable: (toJSON: () => unknown) => 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.
+ */
+export declare const attachInspectable: <T extends object>(target: T, toJSON: () => unknown) => T;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/dts/internal/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/internal/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAEhF,OAAO,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,OAAO,KAAG,WAIlD,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,MAAM,OAAO,KAAG,CAWtF,CAAA"}

package/dist/dts/internal/queryDriver.d.ts

@@ -0,0 +1,65 @@
+import { Brand, Effect, Schema, type Scope } from 'effect';
+import { type AnyAsyncData } from '../calc/asyncData.js';
+import { type InputsObject, type InputStores, type InvalidateBy } from './sources.js';
+import { type Store } from './store.js';
+import { type AnySource } from '../state/token.js';
+/** `Gated` (whether the `Idle` arm exists) is the inverse of `alwaysOn`. */
+export type GatedOf<AlwaysOn extends boolean> = AlwaysOn extends true ? false : true;
+/** The runtime gated flag for an `alwaysOn` config, typed as its `Gated` literal. */
+export declare const gatedFlag: <AlwaysOn extends boolean>(alwaysOn: AlwaysOn | undefined) => GatedOf<AlwaysOn>;
+export type Revision = number & Brand.Brand<'reform/Revision'>;
+export declare const Revision: Brand.Brand.Constructor<Revision>;
+export declare const RevisionSchema: Schema.Schema<Revision, number>;
+export declare const revisionZero: Revision;
+export declare const bumpRevision: (r: Revision) => Revision;
+export interface QueryDriverOptions<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
+    /** The owning definition's name — only for the defect log line. */
+    readonly name: string;
+    /** The owning primitive's kind label — only for the defect log line. */
+    readonly label: string;
+    /** Whether `disabled` is honored / the `Idle` arm can occur. */
+    readonly gated: boolean;
+    readonly inputs: Inputs;
+    readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>;
+    readonly invalidateBy?: InvalidateBy<Inputs> | undefined;
+    readonly disabled?: ((inputs: InputsObject<Inputs>) => boolean) | undefined;
+    readonly coalesce?: 'switch' | 'trailing' | undefined;
+    readonly reuse?: boolean | undefined;
+    /**
+     * An extra key segment + wake source beyond the declared inputs — the hidden
+     * `invalidateOn` revision. Kept out of `wireSources` so the user's `query`
+     * and `invalidateBy` see exactly the declared inputs.
+     */
+    readonly extraKey?: {
+        readonly read: () => unknown;
+        readonly subscribe: (listener: () => void) => () => void;
+    } | undefined;
+    /**
+     * Fired when a run's `Success` value has landed in the store (same scheduler
+     * flush — never before the converged value is readable), with the run's
+     * generation. Not fired on `Error`, interrupt, or while disabled. The seam
+     * `RemoteState` settles pending intents through.
+     */
+    readonly onSettled?: ((generation: number) => void) | undefined;
+}
+export interface QueryDriver<A, E> {
+    /** The lifecycle store (the full union — callers narrow to their arms). */
+    readonly store: Store<AnyAsyncData<A, E>>;
+    /**
+     * The highest generation requested so far (0 before the first kick).
+     * Generations are assigned when a run is REQUESTED (enqueued), so a waiter
+     * registered as `requested() + 1` is satisfied only by a run that began
+     * after registration — the settle-ordering rule `RemoteState` builds on.
+     */
+    readonly requested: () => number;
+}
+/**
+ * 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`.
+ */
+export declare const makeQueryDriver: <Inputs extends ReadonlyArray<AnySource>, A, E, R>(options: QueryDriverOptions<Inputs, A, E, R>) => Effect.Effect<QueryDriver<A, E>, never, InputStores<Inputs> | R | Scope.Scope>;
+//# sourceMappingURL=queryDriver.d.ts.map

package/dist/dts/internal/queryDriver.d.ts.map

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

package/dist/dts/internal/reuse.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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`.
+ */
+export declare const reuse: <A>(previous: A, next: A) => A;
+//# sourceMappingURL=reuse.d.ts.map

package/dist/dts/internal/reuse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reuse.d.ts","sourceRoot":"","sources":["../../../src/internal/reuse.ts"],"names":[],"mappings":"AAgEA;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,KAAG,CAAsC,CAAA"}

package/dist/dts/internal/scheduler.d.ts

@@ -0,0 +1,47 @@
+import { Context, Effect, Layer } from 'effect';
+/**
+ * Coalesces store notifications into a single microtask flush so a batch of
+ * writes wakes each subscriber at most once (RESEARCH #3). React owns frame
+ * timing; we only collapse the notifications.
+ *
+ * One scheduler is shared by every store in a runtime, so writes across
+ * different stores in the same tick batch into one flush. The instance is
+ * resolved per store at creation: `Notifications` when a runtime provides it
+ * (per-runtime isolation — see `resolveScheduler`), else the process-wide
+ * `defaultScheduler`.
+ */
+export interface Scheduler {
+    readonly schedule: (listeners: Iterable<() => void>) => void;
+}
+export declare const makeScheduler: () => Scheduler;
+/**
+ * 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.
+ */
+export declare const defaultScheduler: Scheduler;
+declare const Notifications_base: Context.TagClass<Notifications, "reform/Notifications", Scheduler>;
+/**
+ * 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.
+ */
+export declare class Notifications extends Notifications_base {
+}
+/**
+ * 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).
+ */
+export declare const notificationsLayer: Layer.Layer<Notifications>;
+/**
+ * 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.
+ */
+export declare const resolveScheduler: Effect.Effect<Scheduler>;
+export {};
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/dts/internal/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/internal/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAsB,MAAM,QAAQ,CAAA;AAEnE;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,IAAI,CAAC,KAAK,IAAI,CAAA;CAC7D;AAED,eAAO,MAAM,aAAa,QAAO,SAuChC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAA2B,CAAA;;AAE1D;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,kBAA+D;CAAG;AAErG;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,KAAK,CAAC,aAAa,CAA4C,CAAA;AAEtG;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,SAAS,CAGrD,CAAA"}

package/dist/dts/internal/seeds.d.ts

@@ -0,0 +1,17 @@
+import { FiberRef } from '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.
+ */
+export declare const CurrentSeedOverrides: FiberRef.FiberRef<Readonly<Record<string, unknown>>>;
+//# sourceMappingURL=seeds.d.ts.map

package/dist/dts/internal/seeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeds.d.ts","sourceRoot":"","sources":["../../../src/internal/seeds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,QAAQ,CAAA;AAE9C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAGnF,CAAA"}

package/dist/dts/internal/sources.d.ts

@@ -0,0 +1,39 @@
+import { type Context, Effect } from 'effect';
+import { type AnySource, type SourceName, type SourceValue } from '../state/token.js';
+/** The decoded inputs handed to a calc body, keyed by each source's name. */
+export type InputsObject<Inputs extends ReadonlyArray<AnySource>> = {
+    readonly [S in Inputs[number] as SourceName<S>]: SourceValue<S>;
+};
+/**
+ * The store services a list of store-carriers requires, as a *union of distinct*
+ * stores (each carrier has its own backing tag), not a single store of a union.
+ * Structural over the `store` tag, so it serves both calc inputs (`Source`s) and
+ * state-group members (`StateClass`es) — anything carrying a `store` tag.
+ */
+export type StoresOf<Items extends ReadonlyArray<unknown>> = {
+    [I in keyof Items]: Items[I] extends {
+        readonly store: Context.Tag<infer Svc, any>;
+    } ? Svc : never;
+}[number];
+/** The store requirement a calc's inputs impose. */
+export type InputStores<Inputs extends ReadonlyArray<AnySource>> = StoresOf<Inputs>;
+/** Project inputs into a comparable key; the calc reacts only when it moves. */
+export type InvalidateBy<Inputs extends ReadonlyArray<AnySource>> = (inputs: InputsObject<Inputs>) => ReadonlyArray<unknown>;
+/** Element-wise value equality of two invalidation keys. */
+export declare const sameKey: (a: ReadonlyArray<unknown>, b: ReadonlyArray<unknown>) => boolean;
+/** The sensing surface both `Calc.live` and `AsyncCalc.live` build on. */
+export interface WiredSources<Inputs extends ReadonlyArray<AnySource>> {
+    /** Snapshot every input by name — the decoded inputs object a calc body sees. */
+    readonly snapshot: () => InputsObject<Inputs>;
+    /** The invalidation key for an inputs object: the projection, or all input values. */
+    readonly keyOf: (inputs: InputsObject<Inputs>) => ReadonlyArray<unknown>;
+    /** Subscribe to every source at once; the returned thunk unsubscribes from all. */
+    readonly subscribe: (listener: () => void) => () => void;
+}
+/**
+ * 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`).
+ */
+export declare const wireSources: <Inputs extends ReadonlyArray<AnySource>>(inputs: Inputs, invalidateBy?: InvalidateBy<Inputs>) => Effect.Effect<WiredSources<Inputs>, never, InputStores<Inputs>>;
+//# sourceMappingURL=sources.d.ts.map

package/dist/dts/internal/sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sources.d.ts","sourceRoot":"","sources":["../../../src/internal/sources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,EAAoB,MAAM,QAAQ,CAAA;AAC/D,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAQlF,6EAA6E;AAC7E,MAAM,MAAM,YAAY,CAAC,MAAM,SAAS,aAAa,CAAC,SAAS,CAAC,IAAI;IAClE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;CAChE,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,aAAa,CAAC,OAAO,CAAC,IAAI;KAC1D,CAAC,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,EAAE,GAAG,CAAC,CAAA;KAAE,GAAG,GAAG,GAAG,KAAK;CACnG,CAAC,MAAM,CAAC,CAAA;AAET,oDAAoD;AACpD,MAAM,MAAM,WAAW,CAAC,MAAM,SAAS,aAAa,CAAC,SAAS,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAA;AAEnF,gFAAgF;AAChF,MAAM,MAAM,YAAY,CAAC,MAAM,SAAS,aAAa,CAAC,SAAS,CAAC,IAAI,CAClE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,KACzB,aAAa,CAAC,OAAO,CAAC,CAAA;AAuB3B,4DAA4D;AAC5D,eAAO,MAAM,OAAO,GAAI,GAAG,aAAa,CAAC,OAAO,CAAC,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,KAAG,OACJ,CAAA;AAE3E,0EAA0E;AAC1E,MAAM,WAAW,YAAY,CAAC,MAAM,SAAS,aAAa,CAAC,SAAS,CAAC;IACnE,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,YAAY,CAAC,MAAM,CAAC,CAAA;IAC7C,sFAAsF;IACtF,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,aAAa,CAAC,OAAO,CAAC,CAAA;IACxE,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CACzD;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,aAAa,CAAC,SAAS,CAAC,EACjE,QAAQ,MAAM,EACd,eAAe,YAAY,CAAC,MAAM,CAAC,KAClC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CA4BM,CAAA"}

package/dist/dts/internal/store.d.ts

@@ -0,0 +1,47 @@
+import { type Inspectable } from './inspect.js';
+import { type Scheduler } from './scheduler.js';
+/**
+ * A reactive cell living outside Effect. The single source of truth for one
+ * slice of state. `set` is internal: only the reduce loop ever holds a Store
+ * (reducers return values, the loop writes them), which is how "state changes
+ * only in the reduce loop" is enforced structurally — there is no public writer.
+ *
+ * This is the synchronous, React-facing analog of Effect's `SubscriptionRef`
+ * (a `Ref` + `PubSub` + a `changes` `Stream`). We don't use `SubscriptionRef`
+ * directly because `useSyncExternalStore` requires a *synchronous* `getSnapshot`
+ * and a *synchronous* `subscribe` returning an unsubscribe thunk, whereas
+ * `SubscriptionRef.get` is an `Effect` and its `changes` is a `Stream` (a fiber
+ * per subscription). Mutable state is held in a `MutableRef` (Effect's mutable
+ * cell), so there is no reassigned binding.
+ *
+ * `getSnapshot` + `subscribe` are the stable pair the React bridge binds to;
+ * `getSnapshot` returns the same reference until the value actually changes.
+ * `getVersion` returns a monotonic counter bumped on every real change — the
+ * host sums it across a render's tracked stores for a `useSyncExternalStore`
+ * snapshot, which closes the tear/dropped-update window a value snapshot can't.
+ */
+export interface Store<in out A> extends Inspectable {
+    get(): A;
+    set(value: A): void;
+    getSnapshot(): A;
+    getVersion(): number;
+    subscribe(listener: () => void): () => void;
+}
+export declare const makeStore: <A>(initial: A, scheduler?: Scheduler) => Store<A>;
+/**
+ * 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.
+ */
+export declare const makeDerivedStore: <A>(compute: () => A, subscribeUpstream: (onChange: () => void) => () => void, scheduler?: Scheduler) => {
+    readonly store: Store<A>;
+    readonly unsubscribe: () => void;
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/dts/internal/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/internal/store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,WAAW,CAAA;AACzD,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAE,SAAQ,WAAW;IAClD,GAAG,IAAI,CAAC,CAAA;IACR,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAA;IACnB,WAAW,IAAI,CAAC,CAAA;IAChB,UAAU,IAAI,MAAM,CAAA;IACpB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;CAC5C;AAED,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,SAAS,CAAC,EAAE,YAAW,SAA4B,KAAG,KAAK,CAAC,CAAC,CAwBzF,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAChC,SAAS,MAAM,CAAC,EAChB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,EACvD,YAAW,SAA4B,KACtC;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,IAAI,CAAA;CA8B9D,CAAA"}

package/dist/dts/internal/track.d.ts

@@ -0,0 +1,33 @@
+import { Context, Effect } from 'effect';
+import type { Store } from './store.js';
+/**
+ * Anything a render can depend on: a source it can subscribe to for changes and
+ * snapshot a monotonic version from. `Store` (and the calc/family stores)
+ * structurally satisfy this. The host sums `getVersion()` across a render's
+ * tracked sources for its `useSyncExternalStore` snapshot — a value that moves
+ * whenever any dependency changes, which is what closes the tear/dropped-update
+ * window a per-store value snapshot cannot.
+ */
+export interface Subscribable {
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+}
+/** A per-render dependency sink. The renderer provides one; reads record into it. */
+export interface Tracker {
+    add(source: Subscribable): void;
+}
+declare const CurrentTracker_base: Context.TagClass<CurrentTracker, "reform/Tracker", Tracker>;
+/**
+ * The active render's dependency tracker (D5). Present only while a composition
+ * is rendering under `@reform/react`; absent in procedures and headless reads.
+ */
+export declare class CurrentTracker extends CurrentTracker_base {
+}
+/**
+ * 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.
+ */
+export declare const readTracked: <A>(store: Store<A>) => Effect.Effect<A>;
+export {};
+//# sourceMappingURL=track.d.ts.map

package/dist/dts/internal/track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["../../../src/internal/track.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;IAC3C,UAAU,IAAI,MAAM,CAAA;CACrB;AAED,qFAAqF;AACrF,MAAM,WAAW,OAAO;IACtB,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;CAChC;;AAED;;;GAGG;AACH,qBAAa,cAAe,SAAQ,mBAAwD;CAAG;AAE/F;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAI5D,CAAA"}

package/dist/dts/procedure/procedure.d.ts

@@ -0,0 +1,40 @@
+import { Effect, Layer } from 'effect';
+import type { YieldWrap } from 'effect/Utils';
+import { type ChannelClass, Procedures } from '../channel/channel.js';
+import { type Manifest } from '../definition/definition.js';
+import { type AnyEvent, type EventType } from '../event/event.js';
+import { type Ctx } from '../internal/ctx.js';
+import { Bus } from '../runtime/bus.js';
+/** The reflectable descriptor a procedure carries. */
+export interface ProcedureManifest extends Manifest {
+    readonly kind: 'Procedure';
+}
+export interface ProcedureClass<Events extends ReadonlyArray<AnyEvent>> {
+    new (): {};
+    readonly manifest: ProcedureManifest;
+    /** The trigger events (marker data; read by `Procedure.live`). */
+    readonly events: Events;
+    /** The channel this procedure's runs are scheduled on (marker data). */
+    readonly channel: ChannelClass;
+}
+export interface ProcedureConfig<Events extends ReadonlyArray<AnyEvent>> {
+    readonly events: Events;
+    /** The scheduling lane. Replaces the old `concurrency` option. */
+    readonly channel: ChannelClass;
+}
+export type AnyProcedure = ProcedureClass<ReadonlyArray<AnyEvent>>;
+/**
+ * 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.
+ */
+export declare const make: <const Events extends ReadonlyArray<AnyEvent>>(name: string, config: ProcedureConfig<Events>) => ProcedureClass<Events>;
+/**
+ * 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.
+ */
+export declare const live: <Events extends ReadonlyArray<AnyEvent>, Eff extends YieldWrap<Effect.Effect<any, any, any>>, Done>(procedure: ProcedureClass<Events>, body: (event: EventType<Events[number]>) => Generator<Eff, Done, never>) => Layer.Layer<never, never, Procedures | Bus | Ctx<Eff>>;
+//# sourceMappingURL=procedure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"procedure.d.ts","sourceRoot":"","sources":["../../../src/procedure/procedure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,KAAK,YAAY,EAAuB,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACvF,OAAO,EAAE,KAAK,QAAQ,EAAmB,MAAM,0BAA0B,CAAA;AACzE,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAC1C,OAAO,EAAE,GAAG,EAAiB,MAAM,gBAAgB,CAAA;AAEnD,sDAAsD;AACtD,MAAM,WAAW,iBAAkB,SAAQ,QAAQ;IACjD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAC3B;AAED,MAAM,WAAW,cAAc,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC;IACpE,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;IACpC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAC/B;AAED,MAAM,WAAW,eAAe,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAC/B;AAED,MAAM,MAAM,YAAY,GAAG,cAAc,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAA;AAElE;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAC/D,MAAM,MAAM,EACZ,QAAQ,eAAe,CAAC,MAAM,CAAC,KAC9B,cAAc,CAAC,MAAM,CAKpB,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GACf,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EACtC,GAAG,SAAS,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EACnD,IAAI,EAEJ,WAAW,cAAc,CAAC,MAAM,CAAC,EACjC,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,KACtE,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,GAAG,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CA6BvD,CAAA"}

package/dist/dts/reducer/reducer.d.ts

@@ -0,0 +1,44 @@
+import { Layer } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { type AnyEvent, type EventType } from '../event/event.js';
+import type { Store } from '../internal/store.js';
+import { type AnyState, type StateValue } from '../state/state.js';
+import { type AnyFamily, type FamilyKey, type FamilyStore, type FamilyValue, Tombstone } from '../state/stateFamily.js';
+import { Reducers } from '../runtime/loop.js';
+/** The reflectable descriptor a reducer carries, like every other primitive's `*Manifest`. */
+export interface ReducerManifest extends Manifest {
+    readonly kind: 'Reducer';
+}
+export interface StateReducerConfig<S extends AnyState, Events extends ReadonlyArray<AnyEvent>> {
+    readonly states: readonly [S];
+    readonly events: Events;
+}
+export interface FamilyReducerConfig<F extends AnyFamily, Events extends ReadonlyArray<AnyEvent>> {
+    readonly family: F;
+    readonly keyOf: (event: EventType<Events[number]>) => FamilyKey<F>;
+    readonly events: Events;
+}
+export interface StateReducerClass<S extends AnyState, Events extends ReadonlyArray<AnyEvent>> {
+    new (): {};
+    readonly manifest: ReducerManifest;
+    /** Marker data read by `Reducer.live`. */
+    readonly config: StateReducerConfig<S, Events>;
+    readonly handles: ReadonlySet<string>;
+}
+export interface FamilyReducerClass<F extends AnyFamily, Events extends ReadonlyArray<AnyEvent>> {
+    new (): {};
+    readonly manifest: ReducerManifest;
+    readonly config: FamilyReducerConfig<F, Events>;
+    readonly handles: ReadonlySet<string>;
+}
+/**
+ * Reducers are the only writers of state. The *definition* (`Reducer.make`)
+ * declares which state and events it touches; the *implementation*
+ * (`Reducer.live`) is the pure fold. An unhandled event is a no-op because
+ * it is never in `handles`.
+ */
+export declare function make<S extends AnyState, const Events extends ReadonlyArray<AnyEvent>>(name: string, config: StateReducerConfig<S, Events>): StateReducerClass<S, Events>;
+export declare function make<F extends AnyFamily, const Events extends ReadonlyArray<AnyEvent>>(name: string, config: FamilyReducerConfig<F, Events>): FamilyReducerClass<F, Events>;
+export declare function live<S extends AnyState, Events extends ReadonlyArray<AnyEvent>>(reducer: StateReducerClass<S, Events>, fold: (value: StateValue<S>, event: EventType<Events[number]>) => StateValue<S>): Layer.Layer<never, never, Reducers | Store<StateValue<S>>>;
+export declare function live<F extends AnyFamily, Events extends ReadonlyArray<AnyEvent>>(reducer: FamilyReducerClass<F, Events>, fold: (entry: FamilyValue<F>, event: EventType<Events[number]>) => FamilyValue<F> | Tombstone): Layer.Layer<never, never, Reducers | FamilyStore<FamilyKey<F>, FamilyValue<F>>>;
+//# sourceMappingURL=reducer.d.ts.map

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

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