@playfast/reform 0.0.4 → 0.0.7

package/dist/boundary/boundary.d.ts

@@ -0,0 +1,72 @@
+import { Context, Effect, Layer } from 'effect';
+import { type Manifest } from '../definition/definition';
+import { type InputStores } from '../internal/sources';
+import { type Store } from '../internal/store';
+import { type Source } from '../state/token';
+/** 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/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/boundary/boundary.js

@@ -0,0 +1,83 @@
+import { Context, Data, Effect, Layer, MutableRef, Predicate } from 'effect';
+import { yieldableClass } from '../definition/definition';
+import { resolveScheduler } from '../internal/scheduler';
+import { sameKey, wireSources } from '../internal/sources';
+import { makeDerivedStore } from '../internal/store';
+import { readTracked } from '../internal/track';
+import {} from '../state/token';
+// 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/boundary/boundary.js.map

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

package/dist/calc/asyncCalc.d.ts

@@ -0,0 +1,91 @@
+import { Context, Effect, Layer, Schema } from 'effect';
+import { type Manifest } from '../definition/definition';
+import { type AnyEvent } from '../event/event';
+import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources';
+import { type GatedOf } from '../internal/queryDriver';
+import { type Store } from '../internal/store';
+import { Reducers } from '../runtime/loop';
+import { type AnySource } from '../state/token';
+import { type AsyncData } from './asyncData';
+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/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/calc/asyncCalc.js

@@ -0,0 +1,95 @@
+import { Context, Effect, Layer, Option, Schema } from 'effect';
+import { yieldableClass } from '../definition/definition';
+import {} from '../event/event';
+import {} from '../internal/sources';
+import { bumpRevision, gatedFlag, makeQueryDriver, RevisionSchema, revisionZero, } from '../internal/queryDriver';
+import {} from '../internal/store';
+import { readTracked } from '../internal/track';
+import * as Reducer from '../reducer/reducer';
+import { Reducers } from '../runtime/loop';
+import * as State from '../state/state';
+import {} from '../state/token';
+import { narrowStore } from './asyncData';
+/**
+ * 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 const make = (name, config) => {
+    const store = Context.GenericTag(`reform/asyncCalc/${name}`);
+    // Runtime mirror of the type-level `Gated`, typed as its literal in one place.
+    const gated = gatedFlag(config.alwaysOn);
+    const manifest = {
+        kind: 'AsyncCalc',
+        name,
+        output: config.output,
+        gated,
+        ...(config.error !== undefined ? { error: config.error } : {}),
+    };
+    const read = Effect.flatMap(store, readTracked);
+    return yieldableClass(read, {
+        manifest,
+        store,
+        name,
+        inputs: config.inputs,
+        gated,
+    });
+};
+export function live(calc, config) {
+    // The hidden revision pair, built once per `live` call. Namespacing the state
+    // by the calc's name (`reform/state/${calcName}/invalidateOn`) keeps the tag
+    // out of any plausible user namespace; the duplicate-reducer check is
+    // warning-only and calc names are unique by convention.
+    const revisionState = config.invalidateOn === undefined
+        ? undefined
+        : State.make(`${calc.manifest.name}/invalidateOn`, RevisionSchema);
+    // Scoped so the source subscriptions and the driver fiber are released when
+    // the layer's scope closes (each proof/test builds and disposes its runtime).
+    const driver = Layer.scoped(calc.store, Effect.gen(function* () {
+        // `disabled` is rejected at the type level for non-gated calcs (erased to
+        // `never` there); read it through a loose view for the runtime.
+        const cfg = config;
+        // The hidden revision store, read requirement-free (`serviceOption`): the
+        // assembly below always provides it alongside this driver, and feeding it
+        // through `extraKey` (not `wireSources`) keeps it out of the snapshot —
+        // the user's `query` and `invalidateBy` receive exactly
+        // `InputsObject<Inputs>`, with no hidden property to leak into
+        // spread-into-RPC payloads.
+        const revision = revisionState === undefined
+            ? undefined
+            : Option.getOrUndefined(yield* Effect.serviceOption(revisionState.store));
+        const driver = yield* makeQueryDriver({
+            name: calc.manifest.name,
+            label: 'AsyncCalc',
+            gated: calc.gated,
+            inputs: calc.inputs,
+            query: cfg.query,
+            invalidateBy: cfg.invalidateBy,
+            disabled: cfg.disabled,
+            coalesce: cfg.coalesce,
+            reuse: cfg.reuse,
+            extraKey: revision === undefined
+                ? undefined
+                : {
+                    read: () => revision.getSnapshot(),
+                    subscribe: (listener) => revision.subscribe(listener),
+                },
+        });
+        // The internal store is the full union; narrow to the definition's arms.
+        return narrowStore(driver.store);
+    }));
+    if (config.invalidateOn === undefined || revisionState === undefined)
+        return driver;
+    // The hidden reducer: an ordinary `Reducer` folding every listed event to
+    // n + 1 — the revision's sole writer, registered/unregistered with this
+    // layer's scope like any user reducer. `Layer.provide` builds the hidden
+    // state once and feeds the same store to both the driver and the reducer,
+    // while the outer context (user inputs, the `Reducers` registry) passes
+    // through untouched.
+    const revisionReducer = Reducer.make(`${calc.manifest.name}/invalidateOn`, {
+        states: [revisionState],
+        events: config.invalidateOn,
+    });
+    return Layer.merge(driver, Reducer.live(revisionReducer, bumpRevision)).pipe(Layer.provide(State.live(revisionState, revisionZero)));
+}
+//# sourceMappingURL=asyncCalc.js.map

package/dist/calc/asyncCalc.js.map

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

package/{src/calc/asyncData.ts → dist/calc/asyncData.d.ts}

@@ -1,81 +1,51 @@
-import { type Store } from '../internal/store'
-
-// The value an `AsyncCalc` holds: a tagged union of the query's lifecycle,
-// consumed with `effect`'s `Match` (`Match.value(data).pipe(Match.tag('Success', …))`).
-//
-// The shape is narrowed by the definition, so you only handle arms that can
-// occur: `Idle` exists only for a gateable query (no `alwaysOn`), and `Error`
-// exists only when the query declares an `error` schema. There is no separate
-// "refreshing" arm — a re-fetch keeps the last `Success`/`Error` and flips its
-// `refetching` flag (stale-while-revalidate), so the UI never flashes empty.
-
+import { type Store } from '../internal/store';
 /** A gated query that is currently switched off (only when not `alwaysOn`). */
 export interface AsyncIdle {
-  readonly _tag: 'Idle'
+    readonly _tag: 'Idle';
 }
-
 /** The first fetch, before any value exists. */
 export interface AsyncLoading {
-  readonly _tag: 'Loading'
+    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
+    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
+    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>)
-
+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>
-
-const idle: AsyncIdle = { _tag: 'Idle' }
-const loading: AsyncLoading = { _tag: 'Loading' }
-const success = <A>(value: A, refetching = false): AsyncSuccess<A> => ({
-  _tag: 'Success',
-  value,
-  refetching,
-})
-const error = <E>(err: E, refetching = false): AsyncError<E> => ({
-  _tag: 'Error',
-  error: err,
-  refetching,
-})
-
+export type AnyAsyncData<A, E> = AsyncIdle | AsyncLoading | AsyncSuccess<A> | AsyncError<E>;
+/** The arm-constructor namespace exposed as `AsyncData`. */
+export interface AsyncDataConstructors {
+    readonly idle: AsyncIdle;
+    readonly loading: AsyncLoading;
+    readonly success: <A>(value: A, refetching?: boolean) => AsyncSuccess<A>;
+    readonly error: <E>(err: E, refetching?: boolean) => 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 const AsyncData = { idle, loading, success, error } as const
-
+export declare const AsyncData: AsyncDataConstructors;
 /**
  * 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 const narrowStore = <A, E, Gated extends boolean>(
-  store: Store<AnyAsyncData<A, E>>,
-): Store<AsyncData<A, E, Gated>> => store as unknown as Store<AsyncData<A, E, Gated>>
-
+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
@@ -83,6 +53,5 @@ export const narrowStore = <A, E, Gated extends boolean>(
  * 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 const widenStore = <A, E, Gated extends boolean>(
-  store: Store<AsyncData<A, E, Gated>>,
-): Store<AnyAsyncData<A, E>> => store as unknown as Store<AnyAsyncData<A, E>>
+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/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,4DAA4D;AAC5D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,OAAO,KAAK,YAAY,CAAC,CAAC,CAAC,CAAA;IACxE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA;CACnE;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,qBAAyD,CAAA;AAEjF;;;;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/calc/asyncData.js

@@ -0,0 +1,34 @@
+import {} from '../internal/store';
+const idle = { _tag: 'Idle' };
+const loading = { _tag: 'Loading' };
+const success = (value, refetching = false) => ({
+    _tag: 'Success',
+    value,
+    refetching,
+});
+const error = (err, refetching = false) => ({
+    _tag: 'Error',
+    error: err,
+    refetching,
+});
+/**
+ * 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 const AsyncData = { idle, loading, success, error };
+/**
+ * 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 const narrowStore = (store) => store;
+/**
+ * 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 const widenStore = (store) => store;
+//# sourceMappingURL=asyncData.js.map

package/dist/calc/asyncData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncData.js","sourceRoot":"","sources":["../../src/calc/asyncData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,mBAAmB,CAAA;AAiD9C,MAAM,IAAI,GAAc,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;AACxC,MAAM,OAAO,GAAiB,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AACjD,MAAM,OAAO,GAAG,CAAI,KAAQ,EAAE,UAAU,GAAG,KAAK,EAAmB,EAAE,CAAC,CAAC;IACrE,IAAI,EAAE,SAAS;IACf,KAAK;IACL,UAAU;CACX,CAAC,CAAA;AACF,MAAM,KAAK,GAAG,CAAI,GAAM,EAAE,UAAU,GAAG,KAAK,EAAiB,EAAE,CAAC,CAAC;IAC/D,IAAI,EAAE,OAAO;IACb,KAAK,EAAE,GAAG;IACV,UAAU;CACX,CAAC,CAAA;AAUF;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAA0B,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAA;AAEjF;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,KAAgC,EACD,EAAE,CAAC,KAAiD,CAAA;AAErF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,KAAoC,EACT,EAAE,CAAC,KAA6C,CAAA"}

package/dist/calc/calc.d.ts

@@ -0,0 +1,57 @@
+import { Context, Effect, Layer, type Schema } from 'effect';
+import { type Manifest } from '../definition/definition';
+import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources';
+import { type Store } from '../internal/store';
+import { type AnySource } from '../state/token';
+export { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources';
+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/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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"}