@reactra/resource 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akhil Shastri and the Reactra contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @reactra/resource
+
+> Reactra resource runtime — declarative async data (Suspense, swr/cache/retry) for Reactra apps.
+
+**Alpha** — published under the npm dist-tag `alpha`. APIs may change before 1.0.
+
+```bash
+npm install @reactra/resource@alpha
+```
+
+Part of [Reactra](https://github.com/akhilshastri/reactra) — a compiler-first,
+React-19-compatible framework. See the [documentation](https://reactra-docs.vercel.app) to get
+started.
+
+## License
+
+MIT

package/dist/cache.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A settled cache entry. A1 only stores resolved values; `error` is reserved
+ * for B/D stages that may cache rejections under explicit retry/SWR semantics.
+ * `controller` lets the cache abort an in-flight fetch on supersede / clear;
+ * A1 entries are always settled-resolved at write time, so the controller is
+ * effectively post-hoc (kept on the entry so future stages can compose).
+ */
+export interface ResourceCacheEntry<T = unknown> {
+    readonly value: T | undefined;
+    readonly error: unknown;
+    readonly promise: Promise<T | undefined>;
+    readonly controller: AbortController;
+    readonly writtenAt: number;
+}
+/**
+ * The cache API every implementation must satisfy. Pluggable via
+ * `configureResources({ cache })` — a custom backend (sessionStorage, IndexedDB,
+ * remote KV) can drop in by implementing this shape.
+ */
+export interface ResourceCache {
+    get<T = unknown>(resourceName: string, depsKey: string): ResourceCacheEntry<T> | undefined;
+    set<T = unknown>(resourceName: string, depsKey: string, entry: ResourceCacheEntry<T>): void;
+    /**
+     * Drop every entry whose `resourceName` matches. A1: eviction only — mounted
+     * consumers re-fetch on their next natural render (subscriber notify fan-out
+     * lands with A2/D when useMutation needs immediate refetch).
+     */
+    invalidate(resourceName: string | readonly string[]): void;
+    /**
+     * Remove a single entry by `(resourceName, depsKey)`. Aborts its controller
+     * and notifies subscribers. A silent no-op if the entry is not present. Added
+     * in Stage A2 so `useResource` can withdraw an in-flight tombstone when `fn`
+     * rejects — matching the A1 "do not cache rejections" rule for settled writes.
+     */
+    delete(resourceName: string, depsKey: string): void;
+    /**
+     * Stage D — returns true iff `resourceName` has ever been the target of a
+     * successful `set()` on this cache. Used by `useMutation`'s post-success
+     * invalidate path to fire **RES014** when `opts.invalidate` lists a name
+     * that no consumer has fetched (typo-likely). Names are added on `set` and
+     * NEVER removed — `clear` / `invalidate` only evict entries, not name
+     * registrations (the heuristic is "ever known", not "currently present").
+     */
+    hasName(resourceName: string): boolean;
+    subscribe(resourceName: string, depsKey: string, notify: () => void): () => void;
+    /** Drop every entry (or every entry for one resourceName). Aborts each controller. */
+    clear(resourceName?: string): void;
+}
+/**
+ * The default LRU implementation. `Map` preserves insertion order, so a
+ * `delete + set` on read bumps the entry to most-recent; oldest entries (front
+ * of the iterator) evict past `maxEntries`. Each entry's `AbortController` is
+ * aborted on supersede / eviction / clear / invalidate. Subscribers are keyed
+ * identically; `notify(key)` fans out to all of them on every mutation that
+ * touches that key.
+ */
+export declare const createLRUCache: (maxEntries?: number) => ResourceCache;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,OAAO;IAC7C,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,SAAS,CAAA;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAA;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;IAC1F,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IAC3F;;;;OAIG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,CAAA;IAC1D;;;;;OAKG;IACH,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACnD;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAA;IACtC,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;IAChF,sFAAsF;IACtF,KAAK,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACnC;AAQD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,mBAAe,KAAG,aAgIhD,CAAA"}

package/dist/cache.js

@@ -0,0 +1,167 @@
+// @reactra/resource — ResourceCache (Resource v1.0 §6)
+//
+// Stage A1 surface: process-wide LRU singleton + a typed `ResourceCache`
+// interface that custom implementations conform to. `createLRUCache(maxEntries)`
+// builds the default; `configureResources({ cache })` (in `index.ts`) swaps the
+// active instance at app boot. Entries are stored only on SUCCESSFUL `fn`
+// resolution — A1 doesn't cache rejections (a failed fn naturally retries on
+// next mount, matching v0 behaviour). Subscriber notification fan-out is wired
+// (`subscribe` / notify on `set`/`invalidate`/`clear`) but Stage A1's
+// `useResource` doesn't subscribe yet — mounted consumers detect cache changes
+// on next natural render. A2 (in-flight dedup) and D (`useMutation.invalidate`)
+// will start subscribing.
+//
+// Key shape: `<resourceName>|<depsKey>` (single joined string; the `|`
+// separator is opaque to consumers — only `get(name, depsKey)` / `set(...)` are
+// public). `depsKey` is the v0 `depsToKey` serialization (still computed in the
+// hook); the cache treats it as an opaque opaque string.
+const joinKey = (name, depsKey) => `${name}|${depsKey}`;
+const splitName = (joined) => {
+    const sep = joined.indexOf("|");
+    return sep < 0 ? joined : joined.slice(0, sep);
+};
+/**
+ * The default LRU implementation. `Map` preserves insertion order, so a
+ * `delete + set` on read bumps the entry to most-recent; oldest entries (front
+ * of the iterator) evict past `maxEntries`. Each entry's `AbortController` is
+ * aborted on supersede / eviction / clear / invalidate. Subscribers are keyed
+ * identically; `notify(key)` fans out to all of them on every mutation that
+ * touches that key.
+ */
+export const createLRUCache = (maxEntries = 50) => {
+    const entries = new Map();
+    const subscribers = new Map();
+    // Stage D — names that have ever been the target of a successful `set`.
+    // Grows on every set; never shrinks. The "ever known" semantics catches
+    // typos in `useMutation.invalidate(["..."])` without false-positiving on
+    // legitimate empty-cache invalidates (a mounted consumer has always set
+    // its key at least once before the first invalidate is meaningful).
+    const knownNames = new Set();
+    const notify = (key) => {
+        const set = subscribers.get(key);
+        if (set === undefined)
+            return;
+        // Iterate a snapshot — a notify() reentrantly unsubscribing must not
+        // disturb this fan-out.
+        for (const fn of [...set])
+            fn();
+    };
+    const evictIfOver = () => {
+        while (entries.size > maxEntries) {
+            const oldestKey = entries.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            const oldest = entries.get(oldestKey);
+            if (oldest !== undefined)
+                oldest.controller.abort();
+            entries.delete(oldestKey);
+            notify(oldestKey);
+        }
+    };
+    return {
+        get(name, depsKey) {
+            const key = joinKey(name, depsKey);
+            const e = entries.get(key);
+            if (e === undefined)
+                return undefined;
+            // LRU bump.
+            entries.delete(key);
+            entries.set(key, e);
+            return e;
+        },
+        set(name, depsKey, entry) {
+            knownNames.add(name);
+            const key = joinKey(name, depsKey);
+            const prior = entries.get(key);
+            // Supersede a different in-flight controller (the supersede case in §3 +
+            // architect Q9). If `prior.controller === entry.controller`, it's the same
+            // fetch landing — don't abort itself.
+            if (prior !== undefined && prior.controller !== entry.controller) {
+                prior.controller.abort();
+            }
+            entries.delete(key);
+            entries.set(key, entry);
+            evictIfOver();
+            notify(key);
+        },
+        delete(name, depsKey) {
+            const key = joinKey(name, depsKey);
+            const e = entries.get(key);
+            if (e === undefined)
+                return;
+            // Caller chose to delete — abort the controller unconditionally. (The
+            // useResource caller is doing this on fn-rejection; the in-flight is
+            // already settled-error so the abort is informational.)
+            e.controller.abort();
+            entries.delete(key);
+            notify(key);
+        },
+        invalidate(resourceName) {
+            const names = typeof resourceName === "string" ? [resourceName] : resourceName;
+            // RES014 — a name that never wrote to the cache has no entry to evict, so
+            // invalidating it is a silent no-op (it will NOT refetch). This catches the
+            // common footgun: `command f() => … invalidate [r]` where `r` lacks a
+            // `cache`/`swr` modifier, plus useMutation typos. Fires for BOTH paths now
+            // that both route through here. knownNames persists across eviction, so a
+            // genuinely-cached resource never trips this.
+            for (const name of names) {
+                if (!knownNames.has(name)) {
+                    console.warn(`[reactra:resource] RES014: invalidate("${name}") names a resource with no cache entry — ` +
+                        `it will not refetch. Add a \`cache\` or \`swr\` modifier to \`${name}\`, or check the spelling.`);
+                }
+            }
+            const nameSet = new Set(names);
+            // Snapshot keys — `entries.delete` inside the loop would disturb iteration.
+            for (const key of [...entries.keys()]) {
+                if (nameSet.has(splitName(key))) {
+                    const e = entries.get(key);
+                    if (e !== undefined)
+                        e.controller.abort();
+                    entries.delete(key);
+                    notify(key);
+                }
+            }
+        },
+        subscribe(name, depsKey, notifyFn) {
+            const key = joinKey(name, depsKey);
+            let set = subscribers.get(key);
+            if (set === undefined) {
+                set = new Set();
+                subscribers.set(key, set);
+            }
+            set.add(notifyFn);
+            return () => {
+                const s = subscribers.get(key);
+                if (s === undefined)
+                    return;
+                s.delete(notifyFn);
+                if (s.size === 0)
+                    subscribers.delete(key);
+            };
+        },
+        hasName(name) {
+            return knownNames.has(name);
+        },
+        clear(resourceName) {
+            if (resourceName === undefined) {
+                for (const e of entries.values())
+                    e.controller.abort();
+                const keys = [...entries.keys()];
+                entries.clear();
+                for (const key of keys)
+                    notify(key);
+                return;
+            }
+            for (const key of [...entries.keys()]) {
+                if (splitName(key) === resourceName) {
+                    const e = entries.get(key);
+                    if (e !== undefined)
+                        e.controller.abort();
+                    entries.delete(key);
+                    notify(key);
+                }
+            }
+        },
+    };
+};
+//# sourceMappingURL=cache.js.map

package/dist/cache.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,350 @@
+import React from "react";
+import { type ResourceCache, type ResourceCacheEntry } from "./cache.ts";
+export { createLRUCache, type ResourceCache, type ResourceCacheEntry } from "./cache.ts";
+/**
+ * Hook options. v1 added `resourceName` (compiler-injected from the binding
+ * identifier on every DSL `resource` call site) + `cache` + `retry` + `dedup`.
+ * v0 signature preserved exactly — every field is optional; omitting them all
+ * yields the v0 "every mount fetches" behaviour. See Resource v1 §2.
+ */
+export interface ResourceOptions<T = unknown, S = T> {
+    /**
+     * Cache key prefix. Compiler-injected on every DSL `resource` declaration
+     * (derived from the binding identifier). Raw callers may omit it — doing so
+     * disables the cache for that call (and falls back to function-identity
+     * in-flight dedup once A2 lands). Required for `useMutation` invalidation
+     * to target this resource (§7, Stage D).
+     */
+    readonly resourceName?: string;
+    /**
+     * Cache policy. `false` (default) — every mount triggers a fresh fetch (v0
+     * behaviour). `true` — cache the result indefinitely, keyed by
+     * `(resourceName, depsKey)`. Object form lets per-resource override defaults.
+     * Stage A1 honours `true`/`{}`; `ttlMs`/`staleWhileRevalidate`/`maxEntries`
+     * fields are reserved (TTL + SWR ship with Stage B).
+     */
+    readonly cache?: boolean | {
+        readonly ttlMs?: number;
+        readonly staleWhileRevalidate?: boolean;
+        readonly maxEntries?: number;
+    };
+    /**
+     * Retry policy on rejection. Default: no retry (v0 behaviour). Stage C ships
+     * the implementation; the field is reserved here so v1 callers compile.
+     */
+    readonly retry?: number | {
+        readonly count: number;
+        readonly baseMs?: number;
+        readonly jitter?: boolean;
+    };
+    /**
+     * In-flight dedup — two concurrent calls with the same `(resourceName,
+     * depsKey)` share one fetch. Default `true` when `resourceName` is present.
+     * Stage A2 ships the implementation; reserved here so v1 callers compile.
+     */
+    readonly dedup?: boolean;
+    /**
+     * Slice/transform the fetched data with a **re-render bail-out**: the handle's
+     * `.data` is `select(rawData)`, and the consumer re-renders ONLY when the
+     * selected value changes (`Object.is`) — not when an unselected field of the
+     * raw data changes. The DSL `select(u => u.name)` modifier compiles to this.
+     * The cache stores the RAW value; each consumer applies its own `select`.
+     * v1: return a primitive or a stable reference — an object allocated fresh
+     * each call never bails (no comparator yet).
+     */
+    readonly select?: (data: T) => S;
+}
+/** Internal accessor — the active singleton. Not part of the public API. */
+export declare const __getResourceCache: () => ResourceCache;
+/** Test-only: reset the singleton + first-mount guard between test cases. */
+export declare const __resetResourceConfigForTest: () => void;
+/**
+ * Configure the resource layer at app boot (Resource v1 §9). Pass a custom
+ * `cache` implementation (must satisfy `ResourceCache`) or just override the
+ * built-in LRU's max-entries with `cacheMaxEntries`. **Must run before the
+ * first `useResource` mount** — calling it after throws RES010 (the cache
+ * implementation is already in use; the swap is rejected).
+ *
+ * Calling it more than once before the first mount overwrites silently (last
+ * call wins — typically only configures once at app boot). Calling it never
+ * is fine — the built-in LRU runs with `maxEntries: 50` and no TTL.
+ */
+export declare const configureResources: (opts?: {
+    cache?: ResourceCache;
+    cacheMaxEntries?: number;
+}) => void;
+/**
+ * Stage B — TTL-based staleness check. Returns `true` iff `cache.ttlMs` is
+ * set AND `Date.now() - entry.writtenAt` exceeds it. No TTL = never stale
+ * (entries live until eviction). Exported under `__` so the test suite can
+ * exercise the predicate without standing up a render.
+ */
+export declare const __isCacheEntryStale: (entry: ResourceCacheEntry, opts: ResourceOptions<any, any>, now?: number) => boolean;
+/**
+ * Stage B — staleWhileRevalidate opt-in check. Returns `true` iff
+ * `opts.cache` is an object form AND `staleWhileRevalidate: true`. Bare
+ * `cache: true` is treated as "cache but no SWR" — explicit opt-in required.
+ */
+export declare const __shouldRevalidate: (opts: ResourceOptions<any, any>) => boolean;
+/** Normalized retry config; null means "no retry wrapper, call fn once". */
+export interface __RetryConfig {
+    readonly count: number;
+    readonly baseMs: number;
+    readonly jitter: boolean;
+}
+/**
+ * Stage C — normalize `opts.retry` to a `__RetryConfig` or `null`. `retry: N`
+ * (number) becomes `{ count: N, baseMs: 250, jitter: true }`. `retry: { count }`
+ * fills in the same defaults for unset fields. `retry: 0` or absent returns
+ * null (consumer fires `fn` once with zero retry overhead).
+ */
+export declare const __normalizeRetry: (opts: ResourceOptions<any, any>) => __RetryConfig | null;
+/**
+ * Stage C — exponential backoff with optional ±20% jitter. Delay for attempt
+ * `n` (0-indexed) is `baseMs * 2^n`, optionally multiplied by a uniform
+ * `[0.8, 1.2)` jitter factor. `random` is injectable so tests can pin both
+ * extremes (`() => 0` → 0.8x; `() => 1` → 1.2x).
+ */
+export declare const __computeRetryDelay: (attempt: number, config: {
+    readonly baseMs: number;
+    readonly jitter: boolean;
+}, random?: () => number) => number;
+/**
+ * Stage C — abortable `setTimeout` as a Promise. Resolves after `ms`; rejects
+ * with a DOMException("Aborted", "AbortError") if `signal` aborts before the
+ * timer fires (the timer is cleared). If the signal is already aborted at
+ * call time, rejects synchronously on the next microtask.
+ */
+export declare const __delay: (ms: number, signal: AbortSignal) => Promise<void>;
+/**
+ * Stage C — fire `fn(deps, { signal })` up to `config.count + 1` times (one
+ * initial + `count` retries), with exponential backoff + jitter between
+ * attempts. On `AbortError` from `fn` OR signal abort during the backoff
+ * delay, the loop short-circuits and the abort propagates. On exhaustion,
+ * logs RES012 (dev-gated — prod stays silent since the error already surfaces
+ * via `r.error` + ErrorBoundary + the rejected promise) and re-throws the last
+ * error UNCONDITIONALLY. The hook's existing `.then` chain handles
+ * `setState({ error })` + cache.delete tombstone removal unchanged.
+ */
+export declare const __fireWithRetry: <Deps, T>(deps: NonNullable<Deps>, signal: AbortSignal, config: __RetryConfig, fn: (deps: NonNullable<Deps>, ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, random?: () => number) => Promise<T>;
+/**
+ * Handle returned by `useResource`. Drives both the `await(r)` Suspense
+ * boundary (via `promise`) and the success branch body (via `data`).
+ *
+ * `S` is the SELECTED type (`= T` when no `select`): `.data` is what the consumer
+ * sees (the slice). `.promise` stays `Promise<T | undefined>` (the RAW fetch) — the
+ * `await(r){}` lowering discards its resolved value (it only drives Suspense; the
+ * body reads `.data`), so there's no need to project it through `select`.
+ */
+export interface ResourceHandle<T, S = T> {
+    data: S | undefined;
+    error: unknown;
+    isPending: boolean;
+    refetch: () => void;
+    promise: Promise<T | undefined>;
+}
+/**
+ * Stable string key for a `deps` value. Arrays are unwrapped element-wise so
+ * `[1, 2]` keys identically to another `[1, 2]`; scalar refs are compared by
+ * `Object.is`-equivalent identity. Exported for tests.
+ */
+export declare const depsToKey: (deps: unknown) => string;
+/**
+ * The Reactra resource hook. Compiler-emitted from `resource r(deps) => fn(deps)`.
+ *
+ * Behaviour per Resource v0 §2 + §3:
+ *   - `deps === null`  → skip the call. `data/error: undefined`, `isPending: false`,
+ *                        `promise: Promise.resolve(undefined)`.
+ *   - `deps === undefined` → same as `null` but emits a RES004 warning. The
+ *                        explicit skip sentinel is `null`.
+ *   - Otherwise `fn(deps, { signal })` runs immediately. `data` updates on
+ *     resolution; `error` updates on rejection (preserving last good `data`).
+ *   - Deps change (shallow `Object.is`) aborts the in-flight call and re-fires.
+ *   - `refetch()` aborts the current call and re-fires with the same deps.
+ *   - Late resolutions are dropped via a generation counter.
+ *
+ * The returned `promise` is always non-null and is fed to `React.use()` inside
+ * compiled `await(r) { }` blocks so React 19's Suspense can drive the boundary.
+ *
+ * ## StrictMode-safety (the reason this hook is ref-cached, not useMemo'd)
+ *
+ * Earlier drafts used `useMemo` for the promise and a `useEffect(() => () =>
+ * abort())` cleanup. That breaks under React.StrictMode in dev. StrictMode
+ * double-invokes render → mount → cleanup → mount on first mount to surface
+ * impurity. The first mount's `useEffect` cleanup aborts the controller while
+ * the SAME promise object is still referenced by the rendered tree; on the
+ * fake-remount, `React.use(promise)` sees a rejected (AbortError) promise and
+ * the surrounding ErrorBoundary fires for what should be a normal load.
+ * Removing the cleanup-side abort alone doesn't fix it — the top-of-useMemo
+ * abort + StrictMode's deliberate memo-discard still leave a rejected promise
+ * visible to React.use either way (useMemo is a cache *hint*, not a guarantee).
+ *
+ * The fix: cache the entry in a `useRef`. Refs are mutable cells that survive
+ * StrictMode's fake-unmount unchanged because they live outside React's
+ * render-output reconciliation. On the fake-remount, the same `depsKey` finds
+ * the existing entry and reuses its unaborted promise. Abort happens ONLY at
+ * the top of the cache-miss branch (genuine deps change or first call), never
+ * from an effect cleanup. Late resolutions are still dropped by the
+ * `genRef === myGen` guard inside the .then handlers, which covers the cases
+ * the cleanup-abort used to: deps-change, refetch, and the rarer "still
+ * in-flight at real unmount" case (setState on an unmounted component is a
+ * silent no-op in React 18+; no error, no warning, just a dropped state
+ * update). The minor cost is that a fetch in flight at real unmount keeps
+ * running until the network call completes — but its resolution is dropped,
+ * so no setState-on-unmounted and no observable bug. Worth it for StrictMode.
+ *
+ * Mutating refs during render is the standard React 19 pattern for cache-like
+ * state; React docs explicitly bless it when (a) the operation is idempotent
+ * for a given input (same depsKey → same entry) and (b) the mutation doesn't
+ * affect the rendered output during *this* render. Both hold here.
+ */
+export declare const useResource: <Deps, T, S = T>(deps: Deps, fn: (deps: NonNullable<Deps>, ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, opts?: ResourceOptions<T, S>) => ResourceHandle<T, S>;
+/**
+ * Props for the ErrorBoundary emitted by `await(r) error(e) { … }` blocks.
+ * `fallback` is a render-fn (not an element) so the boundary can pass the
+ * caught error to the user's `error(e) { JSX }` body verbatim.
+ */
+/**
+ * Resource v1 §8.1 — the runtime helper a compiler-emitted `warm(inputs,
+ * signal)` companion calls per-resource. Best-effort cache pre-fill; never
+ * throws. The returned promise resolves when the entry settles (success or
+ * any failure, including AbortError).
+ *
+ * Behaviour:
+ *   - If `(name, depsToKey(deps))` already has a cache entry (settled OR
+ *     in-flight), resolve immediately. Stage E treats any present entry as
+ *     "fresh enough" — consumers with SWR drive their own refresh from the
+ *     render path; warm doesn't aggressively refresh.
+ *   - Otherwise: write an in-flight tombstone (Stage A2 shape) keyed under
+ *     a fresh `AbortController` so concurrent warm + consumer mounts dedup.
+ *     Forward `callerSignal.abort` to the cache controller, propagating
+ *     cancel-on-real-navigation through to `fn(deps, { signal })`.
+ *   - On `fn` success: supersede the tombstone with the resolved entry
+ *     (same controller → idempotent supersede per §6).
+ *   - On `fn` failure (including AbortError): `cache.delete(name, depsKey)`
+ *     withdraws the tombstone. Any consumer mid-adopt sees the
+ *     `cacheBust = cacheCoupled && cached === undefined` check (Stage D)
+ *     and re-fires fresh on its next render. Failures are silently
+ *     resolved by the returned promise — RES015 was deliberately not
+ *     minted (§5; failed warms are debug-only).
+ */
+export declare const warmResource: <Deps, T>(name: string, deps: Deps, fn: (deps: Deps, ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, callerSignal: AbortSignal) => Promise<void>;
+/**
+ * The name of a resource known to the project, used to type
+ * {@link MutationOptions.invalidate}. See Resource v1 §7.
+ *
+ * **This alias is `string` by default.** When `@reactra/vite-plugin` runs over
+ * a project it writes `.reactra/resource-names.d.ts`, which uses TS declaration
+ * merging to narrow this alias to the union of every `resource X(...)` name
+ * declared across the project (e.g. `"customer" | "orderSummary"`). With that
+ * file on the TS `include` path, `invalidate: ["custmer"]` becomes a compile
+ * error while `invalidate: ["customer"]` typechecks.
+ *
+ * The default-to-`string` guarantee is load-bearing: with NO generated file
+ * present (a fresh clone, a library consumer, a project that hasn't built yet),
+ * `invalidate: string[]` and `invalidate: ["anything"]` keep compiling — the
+ * typed union is an additive narrowing, never a hard requirement. RES014 stays
+ * the runtime backstop for dynamic / un-generated names.
+ *
+ * It must be a PROJECT-WIDE union (one merged declaration), not per-file:
+ * invalidation is cross-file (a mutation in `save.tsx` invalidates a resource
+ * declared in `[id].tsx`), so a per-file union would make correct cross-file
+ * invalidation a type error.
+ */
+export type ResourceName = string;
+/** Options for `useMutation`. See Resource v1 §7. */
+export interface MutationOptions {
+    /**
+     * After a successful mutation, invalidate every resource whose `resourceName`
+     * appears in this list. v1 keys invalidation purely by `resourceName`
+     * (architect Q6 Path C — the `tags` field is deferred to v1.1 with the DSL
+     * grammar extension). Typed as {@link ResourceName}[] so a typo fails at
+     * compile time once `.reactra/resource-names.d.ts` is generated; RES014 stays
+     * the runtime backstop (warns when a listed name has never been written to
+     * the cache, e.g. a dynamic name). The mutation still completes either way.
+     */
+    readonly invalidate?: readonly ResourceName[];
+    /**
+     * If false (default), calling `mutate()` while a previous call is in-flight
+     * throws **RES013**. Set true to allow overlapping calls — the most recent
+     * resolution wins for the handle's `data`/`error`/`isPending`; older calls
+     * still resolve their own returned promise (they're just no-ops for the
+     * handle's state).
+     */
+    readonly concurrent?: boolean;
+    /** Per-mutation retry policy. Same shape as `ResourceOptions.retry`. */
+    readonly retry?: ResourceOptions["retry"];
+}
+/** Handle returned by `useMutation`. See Resource v1 §7. */
+export interface MutationHandle<Args, T> {
+    /**
+     * Fire the mutation. Returns a promise resolving to `T` on success. Throws
+     * RES013 if called while `isPending` is true and `concurrent !== true`.
+     */
+    mutate: (args: Args) => Promise<T>;
+    /** True while the latest `mutate()` call's promise is unresolved. */
+    isPending: boolean;
+    /** Last successful return value; cleared by `reset()` or overwritten by the next success. */
+    data: T | undefined;
+    /** Last error; cleared by `reset()` or by the next successful resolution. */
+    error: unknown;
+    /** Clear `data` + `error` + abort any in-flight call. **Stable reference.** */
+    reset: () => void;
+}
+/**
+ * Resource v1 §7 — `useMutation(fn, opts?)`. A user-called hook for
+ * non-idempotent side effects (POST, PATCH, DELETE, …) that may need to
+ * invalidate cached resources on success. Lives in `@reactra/resource`; NOT
+ * emitted by the compiler from any DSL keyword (architect Q6 — `mutation` is
+ * deliberately not added to the 25-keyword surface in v1).
+ *
+ * Behaviour:
+ *   - `mutate(args)` immediately calls `fn(args, { signal })` and returns the
+ *     promise. `isPending` toggles `true → false` on settle (success OR error).
+ *   - On success: writes `data`, clears `error`, then runs
+ *     `__currentCache.invalidate(opts.invalidate)` if `invalidate` is set. The
+ *     returned promise resolves AFTER invalidation is initiated.
+ *   - On rejection: writes `error`, retains the previous `data`. Retries (if
+ *     `opts.retry`) drain before the rejection lands. A final failure does NOT
+ *     invalidate.
+ *   - `reset()` aborts the in-flight call, clears `data` + `error`, toggles
+ *     `isPending` false. Reference is stable across renders.
+ *   - **RES013** throws if `mutate()` is called while `isPending` is true and
+ *     `concurrent !== true`. Set `concurrent: true` to opt in to overlap.
+ *   - **RES014** warns if `opts.invalidate` lists a name not yet known to the
+ *     cache (likely a typo). The mutation still completes.
+ *
+ * StrictMode: no `useEffect`. The in-flight controller lives in a `useRef`
+ * and is aborted by `reset()` or replaced on the next `mutate()` call.
+ */
+export declare const useMutation: <Args, T>(fn: (args: Args, ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, opts?: MutationOptions) => MutationHandle<Args, T>;
+export interface ErrorBoundaryProps {
+    children: React.ReactNode;
+    fallback: (error: unknown) => React.ReactNode;
+}
+interface ErrorBoundaryState {
+    error: unknown;
+}
+/**
+ * React class component used by compiled `await(r) error(e) { … }` blocks.
+ * Phase-1 surface: catches render-time errors below the boundary, then
+ * renders `fallback(error)`. No reset API yet — a fresh boundary is created
+ * on every parent re-render that re-emits a new JSX subtree.
+ *
+ * Resource v0 §4: errors thrown inside `fn` reject the promise; React.use()
+ * re-throws on subsequent render; this boundary catches the re-throw.
+ */
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError: (error: unknown) => ErrorBoundaryState;
+    render(): React.ReactNode;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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