@playfast/reform 0.0.2 → 0.0.4

package/package.json

@@ -1,25 +1,24 @@
 {
   "name": "@playfast/reform",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "sideEffects": [],
   "license": "MIT",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/dts/index.d.ts",
-  "main": "./dist/cjs/index.js",
   "exports": {
     "./package.json": "./package.json",
-    ".": {
-      "types": "./dist/dts/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "default": "./dist/cjs/index.js"
-    }
+    ".": "./src/index.ts"
   },
   "files": [
-    "dist"
+    "src",
+    "README.md",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.typecheck.ts",
+    "!src/**/*.typecheck.tsx"
   ],
-  "publishConfig": {
-    "access": "public"
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   },
   "peerDependencies": {
     "effect": "*",
@@ -29,5 +28,8 @@
     "react": {
       "optional": true
     }
+  },
+  "publishConfig": {
+    "access": "public"
   }
-}
+}

package/src/boundary/boundary.ts

@@ -0,0 +1,192 @@
+import { Context, Data, Effect, Layer, MutableRef, Predicate } from 'effect'
+import { type Manifest, yieldableClass } from '../definition/definition'
+import { resolveScheduler } from '../internal/scheduler'
+import { type InputStores, sameKey, wireSources } from '../internal/sources'
+import { makeDerivedStore, type Store } from '../internal/store'
+import { readTracked } from '../internal/track'
+import { type Source } from '../state/token'
+
+// Boundary: the Suspense-boundary analog, value-level. One derived store that
+// merges the lifecycles of several async sources into a single
+// Pending/Errored/Ready value, so ONE surface (a splash, a skeleton) covers a
+// whole subtree's first load instead of every query consumer painting its own.
+//
+// Reform can do this without React's throw-a-promise machinery because
+// fetching is layer-driven, not render-driven: an `AsyncCalc` runs because its
+// layer is built, never because something rendered. A boundary therefore only
+// *aggregates* lifecycles — it cannot create render-waterfalls, and content it
+// reveals already has its data.
+//
+// The arm mapping IS the semantics, and most of it falls out of `AsyncData`:
+//   Loading            → Pending  (the arm only exists before the first value,
+//                                  so a boundary is first-load-only by construction)
+//   Success            → Ready    (even `refetching: true` — SWR refetches never
+//                                  re-show the fallback; no transition machinery)
+//   Idle               → Ready    (a gated query that is off is DELIBERATELY off —
+//                                  a signed-out viewer must not wait on a query
+//                                  that only runs signed-in)
+//   Error              → Errored  (the error-boundary half, also value-level)
+//
+// Chained gates (B enables when A succeeds) cannot leak a Ready between hops:
+// the boundary's layer requires every covered store, so each driver subscribes
+// upstream BEFORE the boundary does, the scheduler flush runs listeners in
+// subscription order to a fixpoint within one microtask, and reads are
+// pull-fresh — by the time any subscriber reads, the next hop is already
+// Loading. `boundary.test.ts` pins this with a recorded-notification proof.
+
+/** 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
+
+// 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: BoundaryState = { _tag: 'Pending' }
+const readyArm: BoundaryState = { _tag: 'Ready' }
+const erroredArm = (errors: ReadonlyArray<unknown>): BoundaryState =>
+  Data.struct({ _tag: 'Errored' as const, errors: Data.array(errors) })
+
+/**
+ * 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 const make = <const N extends string, const Over extends ReadonlyArray<AnyLifecycleSource>>(
+  name: N,
+  config: BoundaryConfig<Over>,
+): BoundaryClass<N, Over> => {
+  const store = Context.GenericTag<Store<BoundaryState>, Store<BoundaryState>>(
+    `reform/boundary/${name}`,
+  )
+  const manifest: BoundaryManifest<N> = { 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: unknown): string =>
+  Predicate.hasProperty(arm, '_tag') && Predicate.isString(arm._tag) ? arm._tag : ''
+const errorOf = (arm: unknown): ReadonlyArray<unknown> =>
+  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 = <N extends string, Over extends ReadonlyArray<AnyLifecycleSource>>(
+  boundary: BoundaryClass<N, Over>,
+  options: BoundaryOptions = {},
+): Layer.Layer<Store<BoundaryState>, never, InputStores<Over>> =>
+  // 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<
+        { readonly key: ReadonlyArray<unknown>; readonly value: BoundaryState } | undefined
+      >(undefined)
+      const recompute = (): BoundaryState => {
+        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
+    }),
+  )

package/src/calc/asyncCalc.ts

@@ -0,0 +1,267 @@
+import { Context, Effect, Layer, Option, Schema } from 'effect'
+import { type Manifest, yieldableClass } from '../definition/definition'
+import { type AnyEvent } from '../event/event'
+import {
+  type InputsObject,
+  type InputStores,
+  type InvalidateBy,
+} from '../internal/sources'
+import {
+  bumpRevision,
+  type GatedOf,
+  gatedFlag,
+  makeQueryDriver,
+  RevisionSchema,
+  revisionZero,
+} from '../internal/queryDriver'
+import { type Store } 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 { type AnySource } from '../state/token'
+import { type AsyncData, narrowStore } from './asyncData'
+
+// `AsyncCalc` is `Calc`'s async sibling: a derived store whose value is the
+// lifecycle of an Effect (a query), recomputed reactively from its inputs — the
+// React-Query model, but inside the reform graph and without dispatching events.
+// Definition (`make`) is reflectable data; implementation (`live`) is the effect.
+// The reactive machinery lives in `internal/queryDriver` (shared with
+// `RemoteState`); this module owns the definition shape and the `invalidateOn`
+// sugar.
+
+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 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>> => {
+  const store = Context.GenericTag<Store<AsyncData<A, E, GatedOf<AlwaysOn>>>>(
+    `reform/asyncCalc/${name}`,
+  )
+  // Runtime mirror of the type-level `Gated`, typed as its literal in one place.
+  const gated = gatedFlag(config.alwaysOn)
+  const manifest: AsyncCalcManifest<N, A, E> = {
+    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,
+  })
+}
+
+/**
+ * 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 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 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>
+export 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>
+  },
+  // The wide-R implementation signature behind precise overloads — the same
+  // seam `Reducer.live` uses; both overload returns are assignable (RIn is
+  // covariant), so no value is ever cast.
+): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, any> {
+  // 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 as {
+        readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+        readonly invalidateBy?: InvalidateBy<Inputs>
+        readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
+        readonly coalesce?: 'switch' | 'trailing'
+        readonly reuse?: boolean
+      }
+
+      // 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<A, E, Gated>(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)),
+  )
+}

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

@@ -1,49 +1,81 @@
-import { type Store } from '../internal/store.js';
+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.
+
 /** 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>;
+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,
+})
+
 /**
  * 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>;
-};
+export const AsyncData = { idle, loading, success, error } as const
+
 /**
  * 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>>;
+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>>
+
 /**
  * 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
@@ -51,5 +83,6 @@ export declare const narrowStore: <A, E, Gated extends boolean>(store: Store<Any
  * 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
+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>>