@playfast/reform 0.0.1

package/dist/cjs/state/stateGroup.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.live = exports.select = exports.make = void 0;
+const effect_1 = require("effect");
+const definition_js_1 = require("../definition/definition.js");
+const errors_js_1 = require("../internal/errors.js");
+const state_js_1 = require("./state.js");
+const token_js_1 = require("./token.js");
+/** Compose atomic States into a group provided (and addressed) as a unit. */
+const make = (...members) => (0, definition_js_1.definitionClass)({
+    kind: 'StateGroup',
+    members,
+    byName: new Map(members.map((m) => [m.manifest.name, m])),
+});
+exports.make = make;
+/**
+ * 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.
+ */
+const select = (group, name) => {
+    const member = group.byName.get(name);
+    if (member === undefined)
+        throw new errors_js_1.UnknownGroupState({ name });
+    return new token_js_1.StateToken(name, member.store);
+};
+exports.select = select;
+/**
+ * Allocate every member's store as one merged layer, each seeded from `seeds`
+ * keyed by member name — `StateGroup.live(BoardStates, { board: { _tag: 'Idle' } })`.
+ */
+const live = (group, seeds) => {
+    // Index the typed seed record by the member's runtime name — a genuine
+    // reflection boundary (string key into a mapped type). Each member's store
+    // layer is then merged; the union of stores is exactly `StoresOf<Members>`,
+    // which `reduce`'s single-layer accumulator can't express, so restate it.
+    const seedRecord = seeds;
+    return group.members
+        .map((m) => (0, state_js_1.live)(m, seedRecord[m.manifest.name]))
+        .reduce((a, b) => effect_1.Layer.merge(a, b));
+};
+exports.live = live;

package/dist/cjs/state/token.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateToken = void 0;
+const effect_1 = require("effect");
+const track_js_1 = require("../internal/track.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)`.
+ */
+class StateToken extends effect_1.Effectable.Class {
+    name;
+    store;
+    constructor(name, store) {
+        super();
+        this.name = name;
+        this.store = store;
+    }
+    commit() {
+        return effect_1.Effect.flatMap(this.store, track_js_1.readTracked);
+    }
+}
+exports.StateToken = StateToken;

package/dist/cjs/ui/node.js

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

package/dist/cjs/ui/trigger.js

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

package/dist/dts/boundary/boundary.d.ts

@@ -0,0 +1,72 @@
+import { Context, Effect, Layer } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { type InputStores } from '../internal/sources.js';
+import { type Store } from '../internal/store.js';
+import { type Source } from '../state/token.js';
+/** Some covered source is still on its FIRST load — show the fallback. */
+export interface BoundaryPending {
+    readonly _tag: 'Pending';
+}
+/** Some covered source failed before its first value. */
+export interface BoundaryErrored {
+    readonly _tag: 'Errored';
+    /** The failures, in `over` order (heterogeneous — display via `String`). */
+    readonly errors: ReadonlyArray<unknown>;
+}
+/** Every covered source has settled (or is deliberately gated off). */
+export interface BoundaryReady {
+    readonly _tag: 'Ready';
+}
+export type BoundaryState = BoundaryPending | BoundaryErrored | BoundaryReady;
+/**
+ * Anything a boundary can cover: a `Source` whose value is an async lifecycle —
+ * an `AsyncCalc`, or anything lifecycle-valued built over one (e.g. a
+ * `RemoteState` overlay). The constraint is the same erased `Source` every calc
+ * input uses (store invariance rules out a fixed lifecycle value type — each
+ * definition's union carries its own `Gated`/`E` arms); the captured `const`
+ * tuple keeps each member's precise store requirement, and the runtime merge
+ * reads arms through structural guards, so a non-lifecycle source simply
+ * counts as settled.
+ */
+export type AnyLifecycleSource = Source<string, any>;
+export interface BoundaryManifest<N extends string> extends Manifest {
+    readonly kind: 'Boundary';
+    readonly name: N;
+}
+export interface BoundaryClass<out N extends string, out Over extends ReadonlyArray<AnyLifecycleSource>> extends Effect.Effect<BoundaryState, never, Store<BoundaryState>> {
+    new (): {};
+    readonly manifest: BoundaryManifest<N>;
+    readonly store: Context.Tag<Store<BoundaryState>, Store<BoundaryState>>;
+    /** The boundary's name, so it doubles as a `Source` input to a calc. */
+    readonly name: N;
+    /** The covered lifecycle sources — read by `live` and the editor's graph. */
+    readonly over: Over;
+}
+export interface BoundaryConfig<Over extends ReadonlyArray<AnyLifecycleSource>> {
+    readonly over: Over;
+}
+export interface BoundaryOptions {
+    /**
+     * Latch: once Ready, stay Ready. A BOOT boundary wants this — a covered
+     * route-gated query that first enables on a later navigation (Idle →
+     * Loading) must not re-splash the whole shell; its own screen owns that
+     * loading state. Without the latch the boundary re-pends on any covered
+     * first load, which is what a per-screen boundary wants.
+     */
+    readonly once?: boolean;
+}
+/**
+ * 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 declare const make: <const N extends string, const Over extends ReadonlyArray<AnyLifecycleSource>>(name: N, config: BoundaryConfig<Over>) => BoundaryClass<N, Over>;
+/**
+ * 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 declare const live: <N extends string, Over extends ReadonlyArray<AnyLifecycleSource>>(boundary: BoundaryClass<N, Over>, options?: BoundaryOptions) => Layer.Layer<Store<BoundaryState>, never, InputStores<Over>>;
+//# sourceMappingURL=boundary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../../src/boundary/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAyB,MAAM,QAAQ,CAAA;AAC5E,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,0BAA0B,CAAA;AAExE,OAAO,EAAE,KAAK,WAAW,EAAwB,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAoB,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEhE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAA;AA8B5C,0EAA0E;AAC1E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CACzB;AAED,yDAAyD;AACzD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CACxC;AAED,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,eAAe,GAAG,aAAa,CAAA;AAW7E;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAEpD,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,QAAQ;IAClE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CACjB;AAED,MAAM,WAAW,aAAa,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,CAAC,IAAI,SAAS,aAAa,CAAC,kBAAkB,CAAC,CACrG,SAAQ,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IACjE,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAA;IACtC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAA;IACvE,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IAChB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,cAAc,CAAC,IAAI,SAAS,aAAa,CAAC,kBAAkB,CAAC;IAC5E,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,IAAI,SAAS,aAAa,CAAC,kBAAkB,CAAC,EAC/F,MAAM,CAAC,EACP,QAAQ,cAAc,CAAC,IAAI,CAAC,KAC3B,aAAa,CAAC,CAAC,EAAE,IAAI,CAOvB,CAAA;AAUD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,EAAE,IAAI,SAAS,aAAa,CAAC,kBAAkB,CAAC,EACnF,UAAU,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,EAChC,UAAS,eAAoB,KAC5B,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,CAiD1D,CAAA"}

package/dist/dts/calc/asyncCalc.d.ts

@@ -0,0 +1,91 @@
+import { Context, Effect, Layer, Schema } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { type AnyEvent } from '../event/event.js';
+import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources.js';
+import { type GatedOf } from '../internal/queryDriver.js';
+import { type Store } from '../internal/store.js';
+import { Reducers } from '../runtime/loop.js';
+import { type AnySource } from '../state/token.js';
+import { type AsyncData } from './asyncData.js';
+export interface AsyncCalcManifest<N extends string, A, E> extends Manifest {
+    readonly kind: 'AsyncCalc';
+    readonly name: N;
+    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;
+}
+export interface AsyncCalcClass<out N extends string, out Inputs extends ReadonlyArray<AnySource>, 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: AsyncCalcManifest<N, A, E>;
+    readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>;
+    /** The calc's name, so it doubles as a `Source` input to another (async) calc. */
+    readonly name: N;
+    /** Marker data read by `AsyncCalc.live`. */
+    readonly inputs: Inputs;
+    /** Runtime mirror of `Gated`: whether `disabled` is honored / `Idle` can occur. */
+    readonly gated: Gated;
+}
+export interface AsyncCalcConfig<Inputs extends ReadonlyArray<AnySource>, A, E, AlwaysOn extends boolean> {
+    readonly inputs: Inputs;
+    /** Schema of the `Success` value. */
+    readonly output: Schema.Schema<A, any>;
+    /** Schema of the failure. Omitted ⇒ the query is infallible and there is 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 `.live` config: the effect plus the reactive logic. `disabled` is only
+ * accepted for a gateable query (no `alwaysOn`); `invalidateBy` is the same
+ * `queryKey` projection `Calc` uses.
+ */
+export type AsyncCalcLive<Inputs extends ReadonlyArray<AnySource>, A, E, Gated extends boolean, R> = {
+    readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>;
+    readonly invalidateBy?: InvalidateBy<Inputs>;
+    /**
+     * Refetch conciliation. `'switch'` (default): a new key cancels the in-flight
+     * run (latest-wins). `'trailing'`: the in-flight run completes; key changes
+     * that arrive meanwhile conflate to the latest, and exactly ONE trailing
+     * refetch runs after it settles — a burst of N invalidations during one
+     * flight costs 2 fetches, not N cancel-restarts.
+     */
+    readonly coalesce?: 'switch' | 'trailing';
+    /**
+     * Structural sharing for `Success` values: reconcile each refetch result
+     * against the previous one, substituting previous nodes wherever value
+     * equality holds — refetches returning mostly-identical data keep unchanged
+     * subtree identities, so downstream memo boundaries skip them. Same pass as
+     * `Calc`'s `reuse`; opt-in (one O(result) walk per settle).
+     */
+    readonly reuse?: boolean;
+} & (Gated extends true ? {
+    readonly disabled?: (inputs: InputsObject<Inputs>) => boolean;
+} : {
+    readonly disabled?: never;
+});
+/**
+ * Define an async derived value. `output`/`error` schemas and `alwaysOn` shape
+ * the value type, so `yield* MyQuery` is typed to exactly the arms that can
+ * occur. The query effect itself is supplied by `AsyncCalc.live`.
+ */
+export declare const make: <const N extends string, const Inputs extends ReadonlyArray<AnySource>, A, E = never, const AlwaysOn extends boolean = false>(name: N, config: AsyncCalcConfig<Inputs, A, E, AlwaysOn>) => AsyncCalcClass<N, Inputs, A, E, GatedOf<AlwaysOn>>;
+/**
+ * Wire the query and its reactive logic. The query runs on the runtime (its `R`
+ * — RPC clients, etc. — is captured from the layer context). A change to an
+ * input re-runs it 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`.
+ * Re-runs are driven by inputs / `invalidateBy` / `disabled` — and, with
+ * `invalidateOn`, by listed events: pure sugar that generates a hidden revision
+ * state + reducer (the sole writer) and appends the revision to the calc's key,
+ * so an event-driven refetch is still just key movement under `Equal.equals`.
+ * The hidden pair stays internal — the user's `query`/`invalidateBy` see exactly
+ * the declared inputs — and costs the layer one extra requirement: the
+ * `Reducers` registry (the `Engine`).
+ */
+export declare function live<N extends string, Inputs extends ReadonlyArray<AnySource>, A, E, Gated extends boolean, R>(calc: AsyncCalcClass<N, Inputs, A, E, Gated>, config: AsyncCalcLive<Inputs, A, E, Gated, R> & {
+    readonly invalidateOn: ReadonlyArray<AnyEvent>;
+}): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, InputStores<Inputs> | R | Reducers>;
+export declare function live<N extends string, Inputs extends ReadonlyArray<AnySource>, A, E, Gated extends boolean, R>(calc: AsyncCalcClass<N, Inputs, A, E, Gated>, config: AsyncCalcLive<Inputs, A, E, Gated, R>): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, InputStores<Inputs> | R>;
+//# sourceMappingURL=asyncCalc.d.ts.map

package/dist/dts/calc/asyncCalc.d.ts.map

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

package/dist/dts/calc/asyncData.d.ts

@@ -0,0 +1,55 @@
+import { type Store } from '../internal/store.js';
+/** A gated query that is currently switched off (only when not `alwaysOn`). */
+export interface AsyncIdle {
+    readonly _tag: 'Idle';
+}
+/** The first fetch, before any value exists. */
+export interface AsyncLoading {
+    readonly _tag: 'Loading';
+}
+/** A resolved value; `refetching` is true while a background re-fetch runs. */
+export interface AsyncSuccess<A> {
+    readonly _tag: 'Success';
+    readonly value: A;
+    readonly refetching: boolean;
+}
+/** A failed query; `refetching` is true while a background re-fetch runs. */
+export interface AsyncError<E> {
+    readonly _tag: 'Error';
+    readonly error: E;
+    readonly refetching: boolean;
+}
+/**
+ * The query lifecycle. `Gated` adds the `Idle` arm (a disable-able query); a
+ * non-`never` `E` adds the `Error` arm. Both are decided at `AsyncCalc.make`, so
+ * `yield* MyQuery` is typed to exactly the arms that can occur.
+ */
+export type AsyncData<A, E = never, Gated extends boolean = false> = (Gated extends true ? AsyncIdle : never) | AsyncLoading | AsyncSuccess<A> | ([E] extends [never] ? never : AsyncError<E>);
+/** The full (un-narrowed) union — used internally by the live store. */
+export type AnyAsyncData<A, E> = AsyncIdle | AsyncLoading | AsyncSuccess<A> | AsyncError<E>;
+/**
+ * Constructors for the arms, namespaced under the same name as the type so call
+ * sites read `AsyncData.success(v)` / `AsyncData.error(e)` — no `error` import
+ * shadowing the keyword and one obvious home for every arm.
+ */
+export declare const AsyncData: {
+    readonly idle: AsyncIdle;
+    readonly loading: AsyncLoading;
+    readonly success: <A>(value: A, refetching?: boolean) => AsyncSuccess<A>;
+    readonly error: <E>(err: E, refetching?: boolean) => AsyncError<E>;
+};
+/**
+ * Narrow the live store (which holds the full `AnyAsyncData` union) to the arms
+ * the definition actually permits (`Gated`/`E`). The single documented home for
+ * that narrowing, so `AsyncCalc.live` returns it without an inline cast.
+ */
+export declare const narrowStore: <A, E, Gated extends boolean>(store: Store<AnyAsyncData<A, E>>) => Store<AsyncData<A, E, Gated>>;
+/**
+ * The read-only inverse of `narrowStore`: widen a definition-narrowed store back
+ * to the full union, so a consumer (the `RemoteState` overlay) can dispatch on the
+ * lifecycle arms without carrying the definition's `Gated`/`E` conditionals.
+ * Sound for reads only — every narrowed value IS an `AnyAsyncData` — so callers
+ * must never `set` through the widened view (derived stores ignore `set` anyway).
+ */
+export declare const widenStore: <A, E, Gated extends boolean>(store: Store<AsyncData<A, E, Gated>>) => Store<AnyAsyncData<A, E>>;
+//# sourceMappingURL=asyncData.d.ts.map

package/dist/dts/calc/asyncData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncData.d.ts","sourceRoot":"","sources":["../../../src/calc/asyncData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAW9C,+EAA+E;AAC/E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CACzB;AAED,+EAA+E;AAC/E,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;IACjB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B;AAED,6EAA6E;AAC7E,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;IACjB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,KAAK,SAAS,OAAO,GAAG,KAAK,IAC7D,CAAC,KAAK,SAAS,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,GACxC,YAAY,GACZ,YAAY,CAAC,CAAC,CAAC,GACf,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;AAEjD,wEAAwE;AACxE,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA;AAe3F;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;uBAhBL,CAAC,SAAS,CAAC,2BAAuB,YAAY,CAAC,CAAC,CAAC;qBAKnD,CAAC,OAAO,CAAC,2BAAuB,UAAU,CAAC,CAAC,CAAC;CAWO,CAAA;AAEnE;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,KAAK,SAAS,OAAO,EACrD,OAAO,KAAK,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAC/B,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAsD,CAAA;AAErF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAAE,KAAK,SAAS,OAAO,EACpD,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,KACnC,KAAK,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAkD,CAAA"}

package/dist/dts/calc/calc.d.ts

@@ -0,0 +1,57 @@
+import { Context, Effect, Layer, type Schema } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources.js';
+import { type Store } from '../internal/store.js';
+import { type AnySource } from '../state/token.js';
+export { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources.js';
+export interface CalcOptions<Inputs extends ReadonlyArray<AnySource>> {
+    /**
+     * Custom invalidation: recompute only when the projected key changes by value
+     * equality (React-Query's `queryKey`). Omitted ⇒ recompute when any input
+     * value changes. Shared with `AsyncCalc`.
+     */
+    readonly invalidateBy?: InvalidateBy<Inputs>;
+    /**
+     * Structural sharing: reconcile each recomputed output against the previous
+     * one, substituting previous nodes wherever value equality holds — so
+     * identities only move where values moved and downstream memo boundaries
+     * (React subtrees) skip unchanged regions. Referentially transparent (the
+     * result is value-equal to the fresh output); costs one O(output) walk per
+     * recompute, so opt in for large projections.
+     */
+    readonly reuse?: boolean;
+}
+export interface CalcManifest<N extends string, Out> extends Manifest {
+    readonly kind: 'Calc';
+    readonly name: N;
+    readonly output: Schema.Schema<Out, any>;
+}
+export interface CalcClass<out N extends string, out Inputs extends ReadonlyArray<AnySource>, in out Out> extends Effect.Effect<Out, never, Store<Out>> {
+    new (): {};
+    readonly manifest: CalcManifest<N, Out>;
+    readonly store: Context.Tag<Store<Out>, Store<Out>>;
+    /** The calc's name, so it doubles as a `Source` input to another calc. */
+    readonly name: N;
+    /** Marker data read by `Calc.live`. */
+    readonly inputs: Inputs;
+}
+export interface CalcConfig<Inputs extends ReadonlyArray<AnySource>, Out> {
+    readonly inputs: Inputs;
+    readonly output: Schema.Schema<Out, any>;
+}
+/**
+ * A derived, memoized value over explicit inputs (state members, other calcs, or
+ * async calcs). The *definition* fixes the inputs and the output schema; the
+ * *implementation* is the pure projection. Recomputes only when an input changes;
+ * `yield* Calc` reads the memoized value.
+ */
+export declare const make: <const N extends string, const Inputs extends ReadonlyArray<AnySource>, Out>(name: N, config: CalcConfig<Inputs, Out>) => CalcClass<N, Inputs, Out>;
+/**
+ * Wire the pure projection for a calc. Recomputes only when its invalidation key
+ * changes (by default every input value; override with `invalidateBy`), memoized
+ * on that key; `yield* Calc` reads the memoized value. The derived store reuses
+ * the shared coalescing scheduler, so a recompute that yields an equal value
+ * wakes no subscriber.
+ */
+export declare const live: <N extends string, Inputs extends ReadonlyArray<AnySource>, Out>(calc: CalcClass<N, Inputs, Out>, compute: (inputs: InputsObject<Inputs>) => Out, options?: CalcOptions<Inputs>) => Layer.Layer<Store<Out>, never, InputStores<Inputs>>;
+//# sourceMappingURL=calc.d.ts.map

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

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

package/dist/dts/calc/calcFamily.d.ts

@@ -0,0 +1,57 @@
+import { Context, Effect, Layer, type Schema } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources.js';
+import { type FamilyOptions, type FamilyStore } from '../state/stateFamily.js';
+import { type AnySource } from '../state/token.js';
+export interface CalcFamilyManifest<N extends string, K, Out> extends Manifest {
+    readonly kind: 'CalcFamily';
+    readonly name: N;
+    readonly key: Schema.Schema<K, any>;
+    readonly output: Schema.Schema<Out, any>;
+}
+export interface CalcFamilyClass<out N extends string, out Inputs extends ReadonlyArray<AnySource>, in out K, in out Out> {
+    /** Instance carries the key phantom so `Family['Key']` resolves in key types. */
+    new (): {
+        readonly Key: K;
+    };
+    readonly manifest: CalcFamilyManifest<N, K, Out>;
+    readonly store: Context.Tag<FamilyStore<K, Out>, FamilyStore<K, Out>>;
+    /** Marker data read by `CalcFamily.live` and the editor's graph builder. */
+    readonly inputs: Inputs;
+}
+export interface CalcFamilyConfig<Inputs extends ReadonlyArray<AnySource>, K, Out> {
+    readonly key: Schema.Schema<K, any>;
+    readonly inputs: Inputs;
+    readonly output: Schema.Schema<Out, any>;
+}
+/**
+ * Define a keyed derived value: per-key memoized projections over shared
+ * inputs. The *definition* fixes the key/output schemas and the inputs; the
+ * *implementation* (the per-key projection) is supplied by `CalcFamily.live`.
+ */
+export declare const make: <const N extends string, const Inputs extends ReadonlyArray<AnySource>, K, Out>(name: N, config: CalcFamilyConfig<Inputs, K, Out>) => CalcFamilyClass<N, Inputs, K, Out>;
+/**
+ * Read one member by key — `CalcFamily.read(GroupProjection, id)`. Inside a
+ * render it subscribes exactly that member's store (unrelated members never
+ * wake the subtree); elsewhere it just snapshots — the same one-read-API
+ * contract as `StateFamily.read`.
+ */
+export declare const read: <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(family: CalcFamilyClass<N, Inputs, K, Out>, key: K) => Effect.Effect<Out, never, FamilyStore<K, Out>>;
+export interface CalcFamilyLiveOptions<Inputs extends ReadonlyArray<AnySource>> extends FamilyOptions {
+    /**
+     * Family-wide invalidation key over the SHARED inputs (the member key plays
+     * no part — it is fixed per member). Same contract as `Calc`'s.
+     */
+    readonly invalidateBy?: InvalidateBy<Inputs>;
+}
+/**
+ * Wire the per-key projection. `compute` is curried — `(key) => (inputs) =>
+ * Out` — so per-key construction (closing over key-derived constants) runs once
+ * per member while the inner projection runs per recompute. Each member is a
+ * lazy derived store over the shared wired sources: memoized on the family's
+ * invalidation key, notifying only when its own output moves. Unlike a
+ * `StateFamily` entry, a member holds an upstream subscription, so every
+ * removal path (forget / clear / eviction / the layer finalizer) releases it.
+ */
+export declare const live: <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(family: CalcFamilyClass<N, Inputs, K, Out>, compute: (key: K) => (inputs: InputsObject<Inputs>) => Out, options?: CalcFamilyLiveOptions<Inputs>) => Layer.Layer<FamilyStore<K, Out>, never, InputStores<Inputs>>;
+//# sourceMappingURL=calcFamily.d.ts.map

package/dist/dts/calc/calcFamily.d.ts.map

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

package/dist/dts/channel/channel.d.ts

@@ -0,0 +1,115 @@
+import { Context, type Duration, Effect, Layer } from 'effect';
+import { type Manifest } from '../definition/definition.js';
+import type { Tagged } from '../runtime/bus.js';
+/**
+ * How a channel schedules the procedure work routed to it. Channels generalize
+ * the old per-procedure `concurrency`: a named lane with one policy, shared by
+ * every procedure that declares it.
+ *
+ * - `merge`     run every routed event concurrently (the default).
+ * - `latest`    a new event cancels the in-flight run (switch).
+ * - `debounce`  collapse a burst, run only after `duration` of quiet.
+ * - `throttle`  rate-limit to `units` per `duration` (shape or enforce).
+ * - `exclusive` one run at a time across the whole channel (mutual exclusion).
+ */
+export type ChannelPolicy = {
+    readonly _tag: 'merge';
+} | {
+    readonly _tag: 'latest';
+} | {
+    readonly _tag: 'debounce';
+    readonly duration: Duration.DurationInput;
+} | {
+    readonly _tag: 'throttle';
+    readonly units: number;
+    readonly duration: Duration.DurationInput;
+    readonly cost?: number;
+    readonly burst?: number;
+    readonly strategy?: 'enforce' | 'shape';
+} | {
+    readonly _tag: 'exclusive';
+};
+/** The reflectable descriptor a channel carries. */
+export interface ChannelManifest extends Manifest {
+    readonly kind: 'Channel';
+}
+export interface ChannelClass {
+    new (): {};
+    readonly manifest: ChannelManifest;
+    readonly policy: ChannelPolicy;
+}
+export interface ChannelConfig {
+    readonly policy: ChannelPolicy;
+}
+/**
+ * A registered procedure body, with its trigger events and the channel it runs
+ * on. `run`'s context (RPC clients, etc.) is already provided at registration
+ * (see `Procedure.live`), so the channel fiber can run it with no R.
+ */
+export interface ProcedureEntry {
+    /** The procedure's name — used only to warn on duplicate registration. */
+    readonly name: string;
+    readonly channelName: string;
+    readonly handles: ReadonlySet<string>;
+    readonly run: (event: Tagged) => Effect.Effect<unknown, unknown, never>;
+}
+/**
+ * Mutable collector procedures register into; channels read it to find their
+ * bodies. `byTag` indexes entries by trigger tag, so a channel routes an event
+ * to O(procedures handling it) rather than scanning every registered procedure.
+ */
+export interface ProcedureRegistry {
+    readonly entries: Array<ProcedureEntry>;
+    readonly byTag: Map<string, Array<ProcedureEntry>>;
+    /**
+     * Distinct channel names per event tag. The drain loop routes through this so
+     * it offers each event to each channel exactly once — not once per matching
+     * procedure, which would re-run every procedure on a shared channel per offer.
+     */
+    readonly channelsByTag: Map<string, Array<string>>;
+    /**
+     * Procedures keyed by (channel, tag), so a channel's `runMatching` is a direct
+     * lookup instead of scanning `byTag` and re-filtering by channel per event.
+     */
+    readonly byChannelTag: Map<string, Map<string, Array<ProcedureEntry>>>;
+    readonly register: (entry: ProcedureEntry) => void;
+    /**
+     * Remove a previously-registered entry — the inverse of `register`, used when a
+     * lazy feature unmounts (scope close) so its procedures stop running and their
+     * index entries are reclaimed. Eager procedures (root scope) never call it.
+     */
+    readonly unregister: (entry: ProcedureEntry) => void;
+}
+declare const Procedures_base: Context.TagClass<Procedures, "reform/Procedures", ProcedureRegistry>;
+export declare class Procedures extends Procedures_base {
+}
+export declare const proceduresLayer: Layer.Layer<Procedures, never, never>;
+/** A live channel: the single loop offers events here; the channel drives them. */
+export interface ChannelRuntime {
+    readonly name: string;
+    /** The policy this channel was built with — used to reject a name clash. */
+    readonly policy: ChannelPolicy;
+    readonly offer: (event: Tagged) => void;
+}
+declare const Channels_base: Context.TagClass<Channels, "reform/Channels", {
+    readonly byName: Map<string, ChannelRuntime>;
+}>;
+/** Registry of live channels, keyed by name. The single loop routes through it. */
+export declare class Channels extends Channels_base {
+}
+export declare const channelsLayer: Layer.Layer<Channels, never, never>;
+/**
+ * A scheduling lane for procedures. The *definition* (`Channel.make`) is a
+ * reflectable name + policy; the *implementation* (`Channel.live`) builds the
+ * queue + fiber that applies the policy. Procedures reference a channel by value
+ * and register into it; `Channel.live` is merged into the app once per channel.
+ */
+export declare const make: (name: string, config: ChannelConfig) => ChannelClass;
+/**
+ * Build and register the live machinery for a channel. Idempotent by name, so
+ * procedures sharing an `exclusive`/`latest` channel share one queue + fiber +
+ * semaphore (and therefore truly serialize / cancel across each other).
+ */
+export declare const live: (channel: ChannelClass) => Layer.Layer<never, never, Channels | Procedures>;
+export {};
+//# sourceMappingURL=channel.d.ts.map

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

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