@playfast/reform 0.0.1

package/dist/dts/remote/remoteState.d.ts

@@ -0,0 +1,119 @@
+import { Context, Effect, Layer, Schema } from 'effect';
+import { AsyncData } from '../calc/asyncData.js';
+import * as Channel from '../channel/channel.js';
+import { type Manifest } from '../definition/definition.js';
+import * as Event from '../event/event.js';
+import { type GatedOf } from '../internal/queryDriver.js';
+import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources.js';
+import { type Store } from '../internal/store.js';
+import { Bus } from '../runtime/bus.js';
+import { Reducers } from '../runtime/loop.js';
+import { type AnySource, StateToken } from '../state/token.js';
+/** One queued intent: the dispatched event value plus the lifecycle metadata. */
+export interface PendingIntent<I> {
+    readonly opId: string;
+    /** The dispatched intent event (`{ _tag, ...payload }`). */
+    readonly intent: I;
+    /** `'sending'` until the RPC acks; `'confirmed'` until the post-ack refetch lands. */
+    readonly status: 'sending' | 'confirmed';
+}
+/** The payload of the public `Failed` event: which intent, and what `send` raised. */
+export interface FailedIntent<I> {
+    readonly intent: I;
+    readonly error: unknown;
+}
+export interface RemoteStateManifest<N extends string, A, E> extends Manifest {
+    readonly kind: 'RemoteState';
+    readonly name: N;
+    /** Schema of the server value (`Success` arm / `apply`'s domain). */
+    readonly output: Schema.Schema<A, any>;
+    readonly error?: Schema.Schema<E, any>;
+    /** Whether the query can be disabled (drives the `Idle` arm). */
+    readonly gated: boolean;
+    /** The mutation vocabulary — intent event tags, reflectable without running logic. */
+    readonly intents: ReadonlyArray<string>;
+}
+export interface RemoteStateClass<out N extends string, out Inputs extends ReadonlyArray<AnySource>, in out Intents extends ReadonlyArray<Event.AnyEvent>, in out A, in out E, in out Gated extends boolean> extends Effect.Effect<AsyncData<A, E, Gated>, never, Store<AsyncData<A, E, Gated>>> {
+    new (): {};
+    readonly manifest: RemoteStateManifest<N, A, E>;
+    /** The OVERLAID view (`pending.reduce(apply, truth)`) — what `yield*` reads. */
+    readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>;
+    /** The name, so the class doubles as a `Source` input to another calc. */
+    readonly name: N;
+    /** Marker data read by `RemoteState.live`. */
+    readonly inputs: Inputs;
+    /** The intent event definitions (marker data; read by `RemoteState.live`). */
+    readonly intents: Intents;
+    /** Runtime mirror of `Gated`: whether `disabled` is honored / `Idle` can occur. */
+    readonly gated: Gated;
+    /** The un-overlaid query lifecycle — for chrome that must show server truth. */
+    readonly truth: StateToken<`${N}/truth`, AsyncData<A, E, Gated>>;
+    /**
+     * The pending queue as a read-only `Source` (badges, "saving…" chrome). Not a
+     * `StateClass`, so no user reducer can target it — the hidden queue reducer
+     * is its sole writer.
+     */
+    readonly pending: StateToken<`${N}/pending`, ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>>;
+    /** Public fact: a send failed; its intent left the queue and the view reverted. */
+    readonly Failed: Event.EventClass<`${N}/Failed`, FailedIntent<Event.EventType<Intents[number]>>>;
+}
+export interface RemoteStateConfig<Inputs extends ReadonlyArray<AnySource>, Intents extends ReadonlyArray<Event.AnyEvent>, A, E, AlwaysOn extends boolean> {
+    readonly inputs: Inputs;
+    /** Schema of the server value. */
+    readonly output: Schema.Schema<A, any>;
+    /** Schema of the query failure. Omitted ⇒ infallible query, no `Error` arm. */
+    readonly error?: Schema.Schema<E, any>;
+    /** `true` ⇒ the query is always on: no `Idle` arm and `disabled` is rejected on `.live`. */
+    readonly alwaysOn?: AlwaysOn;
+    /** The mutation vocabulary: ordinary `Event.make` definitions. */
+    readonly intents: Intents;
+}
+/**
+ * Define a remote state: a query (like `AsyncCalc.make`) plus the intent
+ * events that mutate it. `yield* TheClass` reads the overlaid view;
+ * `TheClass.truth` / `TheClass.pending` / `TheClass.Failed` expose the rest of
+ * the surface. The query/send/apply logic is supplied by `RemoteState.live`.
+ */
+export declare const make: <const N extends string, const Inputs extends ReadonlyArray<AnySource>, const Intents extends ReadonlyArray<Event.AnyEvent>, A, E = never, const AlwaysOn extends boolean = false>(name: N, config: RemoteStateConfig<Inputs, Intents, A, E, AlwaysOn>) => RemoteStateClass<N, Inputs, Intents, A, E, GatedOf<AlwaysOn>>;
+/**
+ * The `.live` config: the query (same contract as `AsyncCalc.live`), the
+ * delivery effect, and the pure per-intent fold.
+ */
+export type RemoteStateLive<Inputs extends ReadonlyArray<AnySource>, Intents extends ReadonlyArray<Event.AnyEvent>, A, E, Gated extends boolean, R, R2> = {
+    readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>;
+    /**
+     * Deliver one intent to the server. ANY failure (typed failure or defect)
+     * settles the intent and dispatches `Failed`; the result value is ignored —
+     * truth comes back through the invalidated query, never through the response.
+     */
+    readonly send: (intent: Event.EventType<Intents[number]>) => Effect.Effect<unknown, unknown, R2>;
+    /**
+     * The pure per-intent fold over the server value (typically one
+     * `Match.exhaustive` over the intent union). MUST be idempotent against
+     * truth that already carries the intent — see the module doc.
+     */
+    readonly apply: (value: A, intent: Event.EventType<Intents[number]>) => A;
+    /** The send lane. Default: a generated `${name}/sends` merge channel. */
+    readonly channel?: Channel.ChannelClass;
+    readonly invalidateBy?: InvalidateBy<Inputs>;
+    /** Extra refetch triggers (realtime pushes, unrelated mutations) — `AsyncCalc`'s sugar. */
+    readonly invalidateOn?: ReadonlyArray<Event.AnyEvent>;
+    /** Refetch conciliation — see `AsyncCalc.live`. Mutation bursts favor `'trailing'`. */
+    readonly coalesce?: 'switch' | 'trailing';
+    /** Structural sharing across refetches AND overlay recomputes — see `AsyncCalc.live`. */
+    readonly reuse?: boolean;
+} & (Gated extends true ? {
+    readonly disabled?: (inputs: InputsObject<Inputs>) => boolean;
+} : {
+    readonly disabled?: never;
+});
+/**
+ * Wire a remote state: the query driver (truth), the overlay (visible view),
+ * the hidden queue reducer, the send procedure, and the settle link between
+ * them — one layer. Hidden names minted per call, namespaced by the remote
+ * state's name: events `…/Queued`/`…/Acked`/`…/Settled`/`…/Invalidated`, state
+ * `…/revision`, reducers `…/pending`/`…/revision`, procedure `…/send`, default
+ * channel `…/sends`.
+ */
+export declare const live: <N extends string, Inputs extends ReadonlyArray<AnySource>, Intents extends ReadonlyArray<Event.AnyEvent>, A, E, Gated extends boolean, R, R2>(remote: RemoteStateClass<N, Inputs, Intents, A, E, Gated>, config: RemoteStateLive<Inputs, Intents, A, E, Gated, R, R2>) => Layer.Layer<Store<AsyncData<A, E, Gated>> | Store<ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>>, never, InputStores<Inputs> | R | R2 | Reducers | Channel.Procedures | Channel.Channels | Bus>;
+//# sourceMappingURL=remoteState.d.ts.map

package/dist/dts/remote/remoteState.d.ts.map

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

package/dist/dts/runtime/bus.d.ts

@@ -0,0 +1,27 @@
+import { Context, Effect, Layer, PubSub } from 'effect';
+/** A dispatched event: a tagged data record (`{ _tag, ...payload }`). */
+export interface Tagged {
+    readonly _tag: string;
+}
+/**
+ * Re-narrow an erased `Tagged` envelope to a handler's declared event union. The
+ * loop and channels only route events whose tag is in a handler's `handles`, so
+ * at runtime the envelope IS one of those events; the registries store it as the
+ * generic `Tagged`, and this restores the typed view. The one documented home
+ * for that boundary cast, shared by `Reducer.live` and `Procedure.live`.
+ */
+export declare const narrowHandled: <E>(event: Tagged) => E;
+/** UI-originated events are High; procedure-emitted follow-ups are Normal (DESIGN #46). */
+export type Priority = 'High' | 'Normal';
+export interface Envelope {
+    readonly priority: Priority;
+    readonly event: Tagged;
+}
+declare const Bus_base: Context.TagClass<Bus, "reform/Bus", PubSub.PubSub<Envelope>>;
+/** The single dispatch bus: an unbounded PubSub fanned out to the loop and procedures. */
+export declare class Bus extends Bus_base {
+}
+export declare const busLayer: Layer.Layer<Bus, never, never>;
+export declare const publish: (priority: Priority, event: Tagged) => Effect.Effect<void, never, Bus>;
+export {};
+//# sourceMappingURL=bus.d.ts.map

package/dist/dts/runtime/bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus.d.ts","sourceRoot":"","sources":["../../../src/runtime/bus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvD,yEAAyE;AACzE,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,OAAO,MAAM,KAAG,CAAmB,CAAA;AAEpE,2FAA2F;AAC3F,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAA;AAExC,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;;AAED,0FAA0F;AAC1F,qBAAa,GAAI,SAAQ,QAAyD;CAAG;AAOrF,eAAO,MAAM,QAAQ,gCAAkD,CAAA;AAEvE,eAAO,MAAM,OAAO,GAAI,UAAU,QAAQ,EAAE,OAAO,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAClB,CAAA"}

package/dist/dts/runtime/loop.d.ts

@@ -0,0 +1,45 @@
+import { Context, Layer } from 'effect';
+import { Channels, Procedures } from '../channel/channel.js';
+import { Bus, type Tagged } from './bus.js';
+/**
+ * A registered reducer, with its target store(s) already captured at
+ * registration. `apply` is a pure synchronous write, so the loop needs no
+ * state services in its own context — it just routes events to writers.
+ */
+export interface ReducerEntry {
+    /** The reducer's name — used only to warn on duplicate registration. */
+    readonly name: string;
+    readonly handles: ReadonlySet<string>;
+    readonly apply: (event: Tagged) => void;
+}
+/**
+ * Mutable collector the central loop drains; reducer `.live` layers register
+ * here. `byTag` indexes entries by the event tags they handle, so dispatch is
+ * O(matching reducers) per event rather than O(all reducers) — the difference
+ * that matters once an app has hundreds of reducers.
+ */
+export interface ReducerRegistry {
+    readonly entries: Array<ReducerEntry>;
+    readonly byTag: Map<string, Array<ReducerEntry>>;
+    readonly register: (entry: ReducerEntry) => void;
+    /**
+     * Remove a previously-registered entry. Eager reducers (built on the root scope)
+     * never call this; a lazy feature's `Reducer.live` registers on mount and
+     * unregisters on unmount (scope close), so an unmounted feature stops folding and
+     * its entry is reclaimed instead of leaking + writing to an orphaned store.
+     */
+    readonly unregister: (entry: ReducerEntry) => void;
+}
+declare const Reducers_base: Context.TagClass<Reducers, "reform/Reducers", ReducerRegistry>;
+export declare class Reducers extends Reducers_base {
+}
+export declare const reducersLayer: Layer.Layer<Reducers, never, never>;
+/**
+ * The reform engine: provides the bus + reducer/channel/procedure registries +
+ * the per-runtime notification scheduler to the application and forks the single
+ * drain loop. Registration mutates the live collections, so reducers/procedures/
+ * channels merged alongside are picked up before the first dispatch (boot).
+ */
+export declare const Engine: Layer.Layer<Bus | Reducers | Channels | Procedures>;
+export {};
+//# sourceMappingURL=loop.d.ts.map

package/dist/dts/runtime/loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../../src/runtime/loop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,OAAO,EAAU,KAAK,EAAiB,MAAM,QAAQ,CAAA;AACrE,OAAO,EACL,QAAQ,EAER,UAAU,EAEX,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,GAAG,EAA2B,KAAK,MAAM,EAAE,MAAM,OAAO,CAAA;AAEjE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IACrC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAA;IAChD,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAChD;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CACnD;;AAED,qBAAa,QAAS,SAAQ,aAA2D;CAAG;AAiC5F,eAAO,MAAM,aAAa,qCAA4C,CAAA;AAkFtE;;;;;GAKG;AACH,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAMtE,CAAA"}

package/dist/dts/scene/scene.d.ts

@@ -0,0 +1,44 @@
+import { Layer } from 'effect';
+import type { CompositionClass, CompositionService } from '../compose/composition.js';
+import type { UiContract } from '../compose/ui.js';
+import type { Bus, Tagged } from '../runtime/bus.js';
+/**
+ * The services a built reform runtime exposes to its host: every composition's
+ * logic and the event `Bus`. A scene's `provide` must close to these (a fully
+ * wired app layer provides far more; this is the subset hosts read directly).
+ */
+export type MountedServices = CompositionService | Bus;
+export interface Scene<C extends UiContract = UiContract> {
+    readonly kind: 'Scene';
+    /** The composition to run, with its contract preserved for typed consumers. */
+    readonly composition: CompositionClass<unknown, C>;
+    /** Closed wiring (logic + views), each layer seeding its own live state. */
+    readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>;
+    /** Events dispatched once the runtime is live (e.g. `RequestedTodos`). */
+    readonly boot?: ReadonlyArray<Tagged>;
+}
+/**
+ * Define a scene — `scene(TodoApp, { provide: [makeTestApp(client, seeds)] })`.
+ * The composition's contract flows through `C`, so consumers stay typed.
+ */
+export declare const scene: <C extends UiContract>(composition: CompositionClass<unknown, C>, config: {
+    readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>;
+    readonly boot?: ReadonlyArray<Tagged>;
+}) => Scene<C>;
+/**
+ * Overlay seed values onto a CLOSED scene — the tooling/test seam (dev-tool
+ * inspector overrides, proofs). Scenes stay closed for authors: this does not
+ * reopen `provide`, it wraps each layer with `Layer.locally(CurrentSeedOverrides,
+ * seeds)` so `State.live` boots matching stores from the override instead of
+ * the authored seed.
+ *
+ * Keys are state MEMBER NAMES as reflected in `manifest.states` (e.g. `count`),
+ * not group names. If two groups in one scene share a member name, both receive
+ * the override (documented limitation). Values are schema-validated at build:
+ * an invalid value silently falls back to the authored seed. `StateFamily`
+ * entries are not covered.
+ */
+export declare const seedScene: <C extends UiContract>(base: Scene<C>, seeds: Readonly<Record<string, unknown>>) => Scene<C>;
+/** Reflection guard: is this exported value a scene? */
+export declare const isScene: (v: unknown) => v is Scene;
+//# sourceMappingURL=scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../src/scene/scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE/C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAcjD;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG,GAAG,CAAA;AAEtD,MAAM,WAAW,KAAK,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IACtD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IAClD,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,eAAe,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IAC3E,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACtC;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,UAAU,EACxC,aAAa,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,EACzC,QAAQ;IACN,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,eAAe,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IAC3E,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACtC,KACA,KAAK,CAAC,CAAC,CAKR,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,UAAU,EAC5C,MAAM,KAAK,CAAC,CAAC,CAAC,EACd,OAAO,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KACvC,KAAK,CAAC,CAAC,CAG8E,CAAA;AAExF,wDAAwD;AACxD,eAAO,MAAM,OAAO,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,KACkD,CAAA"}

package/dist/dts/state/state.d.ts

@@ -0,0 +1,37 @@
+import { Context, Effect, Layer, Schema } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { type Store } from '../internal/store.js';
+export interface StateOptions {
+    readonly title?: string;
+    readonly description?: string;
+}
+export interface StateManifest<N extends string, A> extends Manifest {
+    readonly kind: 'State';
+    readonly name: N;
+    readonly schema: Schema.Schema<A, any>;
+    readonly title?: string;
+    readonly description?: string;
+}
+export interface StateClass<out N extends string, in out A> extends Effect.Effect<A, never, Store<A>> {
+    new (): {};
+    readonly manifest: StateManifest<N, A>;
+    /** Internal DI tag holding the live store. The loop reads/writes through it. */
+    readonly store: Context.Tag<Store<A>, Store<A>>;
+}
+export type AnyState = StateClass<string, any>;
+export type StateValue<S> = S extends StateClass<string, infer A> ? A : never;
+export type StateName<S> = S extends StateClass<infer N, any> ? N : never;
+/**
+ * Atomic reactive state. `State.make` is the *definition* (a reflectable
+ * manifest + an internal store tag); it carries no starting value — the seed is
+ * an implementation detail supplied at create-time by `State.live(state, seed)`.
+ * Composed into a `StateGroup` exactly as `@effect/rpc` composes rpcs.
+ */
+export declare const make: <const N extends string, A>(name: N, schema: Schema.Schema<A, any>, options?: StateOptions) => StateClass<N, A>;
+/**
+ * Allocate a state's store, seeded with `initial` — `State.live(Feed, seed)`.
+ * The seed lives here (implementation), not on the definition, so the same
+ * definition can boot from different values in app vs. test wiring.
+ */
+export declare const live: <S extends AnyState>(state: S, initial: StateValue<S>) => Layer.Layer<Store<StateValue<S>>>;
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/state/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAY,KAAK,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzE,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,0BAA0B,CAAA;AAGxE,OAAO,EAAa,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGzD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,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;IACtC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,MAAM,WAAW,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACnG,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IACtC,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;CAChD;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAC9C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAC7E,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAC5C,MAAM,CAAC,EACP,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAS,YAAiB,KACzB,UAAU,CAAC,CAAC,EAAE,CAAC,CAWjB,CAAA;AAwBD;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,QAAQ,EACrC,OAAO,CAAC,EACR,SAAS,UAAU,CAAC,CAAC,CAAC,KACrB,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAMhC,CAAA"}

package/dist/dts/state/stateFamily.d.ts

@@ -0,0 +1,79 @@
+import { Context, Effect, Layer, type Schema } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { type Store } from '../internal/store.js';
+/**
+ * A reducer fold returns this to evict the key it folded over, instead of a new
+ * value. The loop drops the entry's store from the family, so a normalized
+ * collection (chat messages, search hits, transient rows) does not grow without
+ * bound — the one fix for the otherwise-unbounded per-key `Map`.
+ */
+export declare const Tombstone: unique symbol;
+export type Tombstone = typeof Tombstone;
+/** Per-key stores, created lazily so a write to one key wakes only its subscribers. */
+export interface FamilyStore<K, V> {
+    at(key: K): Store<V>;
+    /**
+     * Drop a key's store so it stops occupying memory. A live subscriber keeps its
+     * own closure over the previous store, so eviction is for keys whose entity is
+     * gone (the component is unmounting) — re-`at`-ing the key allocates a fresh,
+     * reseeded store.
+     */
+    forget(key: K): void;
+    /** Drop every key's store — a wholesale reset of the family. */
+    clear(): void;
+    /** Number of live keys — for tests/diagnostics. */
+    size(): number;
+}
+/** Options for a family's keyed store. */
+export interface FamilyOptions {
+    /**
+     * Drop a key's store automatically once it has no live subscribers (checked on
+     * the next microtask, so a same-commit re-subscribe — e.g. a key that just moved
+     * position in a list — cancels the eviction). This bounds an otherwise-unbounded
+     * family without explicit `Tombstone`s, but it also DISCARDS the key's value —
+     * re-`at`-ing a dropped key reseeds from `initial`. Use only for keys whose value
+     * is disposable when nothing renders them (search hits, transient rows); for a
+     * source-of-truth entity that may be temporarily off-screen (a virtualized list),
+     * keep this off and reclaim with an explicit reducer `Tombstone`. Default: off.
+     */
+    readonly evictWhenUnused?: boolean;
+}
+export interface StateFamilyManifest<N extends string, K, V> extends Manifest {
+    readonly kind: 'StateFamily';
+    readonly name: N;
+    readonly key: Schema.Schema<K, any>;
+    readonly value: Schema.Schema<V, any>;
+    readonly title?: string;
+    readonly description?: string;
+}
+export interface StateFamilyClass<out N extends string, in out K, in out V> {
+    /** Instance carries the key phantom so `Family['Key']` resolves in `keyOf` types. */
+    new (): {
+        readonly Key: K;
+    };
+    readonly manifest: StateFamilyManifest<N, K, V>;
+    readonly store: Context.Tag<FamilyStore<K, V>, FamilyStore<K, V>>;
+}
+export type AnyFamily = StateFamilyClass<string, any, any>;
+export type FamilyKey<F> = F extends StateFamilyClass<any, infer K, any> ? K : never;
+export type FamilyValue<F> = F extends StateFamilyClass<any, any, infer V> ? V : never;
+/**
+ * Normalized keyed state: one logical State per key, backed by a single family
+ * store. Scales with the collection without re-rendering unrelated entries.
+ */
+export declare const make: <const N extends string, K, V>(name: N, key: Schema.Schema<K, any>, value: Schema.Schema<V, any>, options?: {
+    readonly title?: string;
+    readonly description?: string;
+}) => StateFamilyClass<N, K, V>;
+/**
+ * Read one entry by key — `StateFamily.read(ItemUi, id)`. Inside a render it
+ * subscribes that key's slice; elsewhere it just snapshots (D5).
+ */
+export declare const read: <N extends string, K, V>(family: StateFamilyClass<N, K, V>, key: K) => Effect.Effect<V, never, FamilyStore<K, V>>;
+/**
+ * Allocate a family's keyed store — `StateFamily.live(ItemUi, seed)`. The seed
+ * is a plain value or a factory; a factory receives the key, so a new entry can
+ * derive its starting value from its own id (`(id) => ({ ...blank, id }))`).
+ */
+export declare const live: <N extends string, K, V>(family: StateFamilyClass<N, K, V>, initial: V | ((key: K) => V), options?: FamilyOptions) => Layer.Layer<FamilyStore<K, V>>;
+//# sourceMappingURL=stateFamily.d.ts.map

package/dist/dts/state/stateFamily.d.ts.map

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

package/dist/dts/state/stateGroup.d.ts

@@ -0,0 +1,36 @@
+import { Layer } from 'effect';
+import { type StoresOf } from '../internal/sources.js';
+import { type AnyState, type StateClass, type StateName } from './state.js';
+import { StateToken } from './token.js';
+type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> = Extract<Members[number], StateClass<N, any>> extends StateClass<any, infer A> ? A : never;
+export interface StateGroupClass<Members extends ReadonlyArray<AnyState>> {
+    new (): {};
+    readonly kind: 'StateGroup';
+    readonly members: Members;
+    /** Members indexed by name, so `select` is an O(1) lookup instead of a scan. */
+    readonly byName: ReadonlyMap<string, AnyState>;
+}
+export type AnyStateGroup = StateGroupClass<ReadonlyArray<AnyState>>;
+export type GroupSeeds<G extends AnyStateGroup> = G extends StateGroupClass<infer Members> ? {
+    readonly [N in StateName<Members[number]>]: ValueForName<Members, N>;
+} : never;
+/** Compose atomic States into a group provided (and addressed) as a unit. */
+export declare const make: <const Members extends ReadonlyArray<AnyState>>(...members: Members) => StateGroupClass<Members>;
+/**
+ * Address a member by its tag — `StateGroup.select(TodosStates, 'feed')` —
+ * yielding a `StateToken` for reads and calc inputs (still `yield*`-able).
+ *
+ * Data-first only (not `dual`): the member name's type depends on the group, and
+ * a group is not `Pipeable`, so a data-last form would be both more verbose and
+ * harder to type than the direct call. Effect reserves `dual` for operators on a
+ * `Pipeable` self with an independent value arg (e.g. `ref.pipe(Ref.set(v))`);
+ * this is not that shape.
+ */
+export declare const select: <Members extends ReadonlyArray<AnyState>, N extends StateName<Members[number]>>(group: StateGroupClass<Members>, name: N) => StateToken<N, ValueForName<Members, N>>;
+/**
+ * Allocate every member's store as one merged layer, each seeded from `seeds`
+ * keyed by member name — `StateGroup.live(BoardStates, { board: { _tag: 'Idle' } })`.
+ */
+export declare const live: <Members extends ReadonlyArray<AnyState>>(group: StateGroupClass<Members>, seeds: GroupSeeds<StateGroupClass<Members>>) => Layer.Layer<StoresOf<Members>>;
+export {};
+//# sourceMappingURL=stateGroup.d.ts.map

package/dist/dts/state/stateGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateGroup.d.ts","sourceRoot":"","sources":["../../../src/state/stateGroup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAM9B,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,KAAK,QAAQ,EAAqB,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AAC3F,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEpC,KAAK,YAAY,CAAC,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,MAAM,IACzE,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,SAAS,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE3F,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;IACzB,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CAC/C;AAED,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAA;AAMpE,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,aAAa,IAC5C,CAAC,SAAS,eAAe,CAAC,MAAM,OAAO,CAAC,GACpC;IAAE,QAAQ,EAAE,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC;CAAE,GACxE,KAAK,CAAA;AAEX,6EAA6E;AAC7E,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC,EAChE,GAAG,SAAS,OAAO,KAClB,eAAe,CAAC,OAAO,CAKtB,CAAA;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAClG,OAAO,eAAe,CAAC,OAAO,CAAC,EAC/B,MAAM,CAAC,KACN,UAAU,CAAC,CAAC,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC,CAIxC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC,EAC1D,OAAO,eAAe,CAAC,OAAO,CAAC,EAC/B,OAAO,UAAU,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,KAC1C,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAS/B,CAAA"}

package/dist/dts/state/token.d.ts

@@ -0,0 +1,30 @@
+import { Context, Effect, Effectable } from 'effect';
+import type { Store } from '../internal/store.js';
+/**
+ * A reference to one slice of state: yieldable to its current value (`yield*`
+ * reads + — under React — subscribes) and carrying the metadata calcs need
+ * (its `name` and backing store tag). Returned by `StateGroup.select(group, name)`.
+ */
+export declare class StateToken<out N extends string, in out A> extends Effectable.Class<A, never, Store<A>> {
+    readonly name: N;
+    readonly store: Context.Tag<Store<A>, Store<A>>;
+    constructor(name: N, store: Context.Tag<Store<A>, Store<A>>);
+    commit(): Effect.Effect<A, never, Store<A>>;
+}
+/**
+ * Anything a derived value can read and depend on: a named slice backed by a
+ * subscribable store tag. A `StateToken` (group member), a `Calc`, and an
+ * `AsyncCalc` all structurally satisfy this — so a `Calc`/`AsyncCalc` can take
+ * any of them as an input. The `name` becomes the key in the inputs object.
+ *
+ * `StateToken` is the one concrete, *yieldable* `Source`; `Calc`/`AsyncCalc`
+ * satisfy the same shape so the three are interchangeable as calc inputs.
+ */
+export interface Source<out N extends string, in out A> {
+    readonly name: N;
+    readonly store: Context.Tag<Store<A>, Store<A>>;
+}
+export type AnySource = Source<string, any>;
+export type SourceName<S> = S extends Source<infer N, any> ? N : never;
+export type SourceValue<S> = S extends Source<any, infer A> ? A : never;
+//# sourceMappingURL=token.d.ts.map

package/dist/dts/state/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../../src/state/token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAG9C;;;;GAIG;AACH,qBAAa,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAEhG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAChB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;gBADtC,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAIjD,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;CAG5C;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IAChB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;CAChD;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAC3C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AACtE,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA"}

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

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+/**
+ * What a view renders. Reform targets React, so a node is a `ReactNode` — this
+ * is a *type-only* dependency: core never imports the React runtime nor renders
+ * anything itself (that is `@reform/react`). Typing it precisely lets the `.ui`
+ * presentations author real JSX and lets slots be valid components.
+ */
+export type Node = ReactNode;
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/ui/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,SAAS,CAAA"}

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

@@ -0,0 +1,7 @@
+/**
+ * A handler handed to the UI: a plain callback. Calling it dispatches the event
+ * (High priority) through the runtime. The UI never sees Effect — it just calls
+ * `events.submit({ text })`.
+ */
+export type Trigger<P> = (payload: P) => void;
+//# sourceMappingURL=trigger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../../src/ui/trigger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAA"}

package/dist/esm/boundary/boundary.js

@@ -0,0 +1,83 @@
+import { Context, Data, Effect, Layer, MutableRef, Predicate } from 'effect';
+import { yieldableClass } from '../definition/definition.js';
+import { resolveScheduler } from '../internal/scheduler.js';
+import { sameKey, wireSources } from '../internal/sources.js';
+import { makeDerivedStore } from '../internal/store.js';
+import { readTracked } from '../internal/track.js';
+import {} from '../state/token.js';
+// Stable arm references: repeated recomputes return the same object, so the
+// derived store's Equal gate (and `useSyncExternalStore`'s stable-snapshot
+// contract) hold without a wrapper. `Errored` carries data, so it is a `Data`
+// struct — value-equal failures coalesce the same way.
+const pendingArm = { _tag: 'Pending' };
+const readyArm = { _tag: 'Ready' };
+const erroredArm = (errors) => Data.struct({ _tag: 'Errored', errors: Data.array(errors) });
+/**
+ * Define a boundary over async sources. `yield* MyBoundary` reads the merged
+ * `Pending | Errored | Ready` lifecycle; the consuming view renders ONE
+ * fallback on Pending and its content slot on Ready — content reveals
+ * together, with data already present (fetching never waited on rendering).
+ */
+export const make = (name, config) => {
+    const store = Context.GenericTag(`reform/boundary/${name}`);
+    const manifest = { kind: 'Boundary', name };
+    const read = Effect.flatMap(store, readTracked);
+    return yieldableClass(read, { manifest, store, name, over: config.over });
+};
+// The snapshot values arrive through `wireSources`' erased key projection
+// (`ReadonlyArray<unknown>`), so read the two facts the merge needs through
+// honest structural guards — no cast back to `AnyAsyncData`.
+const tagOf = (arm) => Predicate.hasProperty(arm, '_tag') && Predicate.isString(arm._tag) ? arm._tag : '';
+const errorOf = (arm) => Predicate.hasProperty(arm, 'error') && tagOf(arm) === 'Error' ? [arm.error] : [];
+/**
+ * Wire the merge. A derived store over the covered stores (sensed through the
+ * same `wireSources` plumbing every calc uses): recomputes are memoized on the
+ * input snapshots and the arms are stable references, so input churn that does
+ * not move the merged arm wakes nobody.
+ */
+export const live = (boundary, options = {}) => 
+// Scoped so the source subscriptions are released with the layer's scope.
+Layer.scoped(boundary.store, Effect.gen(function* () {
+    const scheduler = yield* resolveScheduler;
+    const sources = yield* wireSources(boundary.over);
+    const latched = MutableRef.make(false);
+    const memo = MutableRef.make(undefined);
+    const recompute = () => {
+        if (options.once === true && MutableRef.get(latched))
+            return readyArm;
+        const arms = sources.keyOf(sources.snapshot());
+        const prev = MutableRef.get(memo);
+        if (prev !== undefined && sameKey(arms, prev.key))
+            return prev.value;
+        const errors = arms.flatMap(errorOf);
+        const value = errors.length > 0
+            ? erroredArm(errors)
+            : arms.some((arm) => tagOf(arm) === 'Loading')
+                ? pendingArm
+                : readyArm;
+        MutableRef.set(memo, { key: arms, value });
+        return value;
+    };
+    const derived = makeDerivedStore(recompute, sources.subscribe, scheduler);
+    yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe));
+    if (options.once === true) {
+        // Latch on CONVERGED values only — at build and on (coalesced,
+        // post-fixpoint) notifications — never inside `recompute`. A chained
+        // gate with a plain Calc hop between the async stores (bootstrap →
+        // current-workspace → boards) propagates over TWO flush rounds, so a
+        // mid-flush recompute can observe the frame where the downstream
+        // driver has not yet flipped its query to Loading. That intermediate
+        // Ready self-corrects within the flush for readers, but a latch taken
+        // there would freeze it; a subscriber runs only after the fixpoint,
+        // where the value is converged.
+        if (recompute()._tag === 'Ready')
+            MutableRef.set(latched, true);
+        const offSelf = derived.store.subscribe(() => {
+            if (derived.store.get()._tag === 'Ready')
+                MutableRef.set(latched, true);
+        });
+        yield* Effect.addFinalizer(() => Effect.sync(offSelf));
+    }
+    return derived.store;
+}));
+//# sourceMappingURL=boundary.js.map

package/dist/esm/boundary/boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.js","sourceRoot":"","sources":["../../../src/boundary/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC5E,OAAO,EAAiB,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAoB,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAE,gBAAgB,EAAc,MAAM,mBAAmB,CAAA;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAe,MAAM,gBAAgB,CAAA;AAiD5C,4EAA4E;AAC5E,2EAA2E;AAC3E,8EAA8E;AAC9E,uDAAuD;AACvD,MAAM,UAAU,GAAkB,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AACrD,MAAM,QAAQ,GAAkB,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;AACjD,MAAM,UAAU,GAAG,CAAC,MAA8B,EAAiB,EAAE,CACnE,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAkB,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AA6CvE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,IAAO,EACP,MAA4B,EACJ,EAAE;IAC1B,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAC9B,mBAAmB,IAAI,EAAE,CAC1B,CAAA;IACD,MAAM,QAAQ,GAAwB,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAA;IAChE,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,CAAA;IAC/C,OAAO,cAAc,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAA;AAC3E,CAAC,CAAA;AAED,0EAA0E;AAC1E,4EAA4E;AAC5E,6DAA6D;AAC7D,MAAM,KAAK,GAAG,CAAC,GAAY,EAAU,EAAE,CACrC,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;AACpF,MAAM,OAAO,GAAG,CAAC,GAAY,EAA0B,EAAE,CACvD,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;AAElF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,QAAgC,EAChC,UAA2B,EAAE,EACgC,EAAE;AAC/D,0EAA0E;AAC1E,KAAK,CAAC,MAAM,CACV,QAAQ,CAAC,KAAK,EACd,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,gBAAgB,CAAA;IACzC,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;IAEjD,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACtC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAE1B,SAAS,CAAC,CAAA;IACZ,MAAM,SAAS,GAAG,GAAkB,EAAE;QACpC,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,IAAI,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC;YAAE,OAAO,QAAQ,CAAA;QACrE,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAA;QAC9C,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACjC,IAAI,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC,KAAK,CAAA;QACpE,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QACpC,MAAM,KAAK,GACT,MAAM,CAAC,MAAM,GAAG,CAAC;YACf,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;YACpB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;gBAC5C,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,QAAQ,CAAA;QAChB,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;QAC1C,OAAO,KAAK,CAAA;IACd,CAAC,CAAA;IAED,MAAM,OAAO,GAAG,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IACzE,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAA;IAElE,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAC1B,+DAA+D;QAC/D,qEAAqE;QACrE,mEAAmE;QACnE,qEAAqE;QACrE,iEAAiE;QACjE,qEAAqE;QACrE,sEAAsE;QACtE,oEAAoE;QACpE,gCAAgC;QAChC,IAAI,SAAS,EAAE,CAAC,IAAI,KAAK,OAAO;YAAE,UAAU,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;QAC/D,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE;YAC3C,IAAI,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,OAAO;gBAAE,UAAU,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;QACzE,CAAC,CAAC,CAAA;QACF,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;IACxD,CAAC;IACD,OAAO,OAAO,CAAC,KAAK,CAAA;AACtB,CAAC,CAAC,CACH,CAAA"}