@bgub/fig 0.0.1

package/CHANGELOG.md

@@ -0,0 +1 @@
+# Changelog

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Ben Gubler
+
+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,329 @@
+# @bgub/fig
+
+Core primitives for Fig, a TypeScript re-implementation of React's modern
+component model. Renderers live in `@bgub/fig-dom` and `@bgub/fig-server`.
+
+## Installation
+
+```bash
+pnpm add @bgub/fig
+```
+
+Fig packages are ESM-only, require Node `^20.19.0 || >=22.12.0` for Node
+runtime entry points, and rely on package `exports`. TypeScript projects should
+use `moduleResolution: "bundler"`, `"node16"`, or `"nodenext"`, not the legacy
+`"node"` resolver, so subpaths such as `@bgub/fig/jsx-runtime` resolve with
+their types.
+
+## Usage
+
+```tsx
+import { createRoot, on } from "@bgub/fig-dom";
+import { Suspense, readPromise, useState } from "@bgub/fig";
+
+const message = Promise.resolve("Ready");
+
+function Message({ value }: { value: Promise<string> }) {
+  return <span>{readPromise(value)}</span>;
+}
+
+function App() {
+  const [count, setCount] = useState(0);
+
+  return (
+    <main>
+      <button events={[on("click", () => setCount((value) => value + 1))]}>
+        Count {count}
+      </button>
+      <Suspense fallback={<span>Loading</span>}>
+        <Message value={message} />
+      </Suspense>
+    </main>
+  );
+}
+
+const container = document.getElementById("root");
+if (container === null) throw new Error("Missing root.");
+
+createRoot(container).render(<App />);
+```
+
+## Core API
+
+- Elements: `createElement`, `isValidElement`, `Fragment`, and the JSX
+  runtime.
+- State and memoization: `useState`, `useDeferredValue`, `useMemo`, and
+  `useCallback`.
+- Stable identifiers: `useId()` generates IDs that match server render and
+  hydration output.
+- Context: `createContext(defaultValue)` plus render-time
+  `readContext(context)`.
+- Effects: `useReactive`, `useBeforePaint`, and `useBeforeLayout`. Effects
+  receive an `AbortSignal`; attach cleanup to `signal.abort`. An empty deps
+  array runs an effect once per mount.
+- Strict development semantics, with no `StrictMode` component or opt-out:
+  development builds render components twice per pass (discarding the first
+  result) and run first-time effects and renderer `bind` callbacks twice with
+  an abort in between, so impure renders and signal-ignoring cleanup surface
+  early. Production builds strip these checks.
+- `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot?)` reads external
+  stores. Server rendering and hydration require `getServerSnapshot`.
+- `useStableEvent(handler)` returns a stable function for effect-held
+  callbacks (subscriptions, sockets, timers). The handler always sees the
+  latest committed render and follows the Fig event contract: it receives a
+  trailing `AbortSignal`, and the previous invocation's signal aborts on
+  re-entry and on unmount. Calls after unmount receive an already-aborted
+  signal; calling it during render throws.
+- `Suspense` catches pending `readPromise(promise)` reads and shows `fallback`
+  until the promise settles.
+- Data resources live in `@bgub/fig`. Use `dataResource(...)` plus
+  render-time `readData(...)` for keyed async values that need Suspense,
+  deduping, invalidation, refresh, server hydration, and DevTools visibility.
+- `lazy(load)` creates a component that suspends until `load()` resolves to a
+  component type.
+- `<Activity mode="visible" | "hidden">` hides a subtree while preserving its
+  state: hiding hides the DOM (through portals) and aborts effects, binds, and
+  reactive events; revealing restores the DOM and re-runs them. Trees that
+  mount hidden defer their effects until first reveal, and updates inside
+  hidden trees prerender at idle priority. Server rendering streams hidden
+  content inside an inert template; the client keeps it dehydrated — zero
+  hydration cost — until reveal, then adopts the server DOM.
+- `ErrorBoundary` catches render and Fig effect errors. Use `onError` for
+  reporting and change the boundary key to reset sticky fallback state. Data
+  resource load failures report failed keys on `info.dataResourceKeys`, so
+  recovery flows can refresh or invalidate those keys before resetting.
+- `transition(callback)` and `useTransition()` mark updates that may preserve
+  already-revealed Suspense content while new work is pending. Updates scheduled
+  inside the callback run at transition priority, including updates after an
+  `await` while an async transition callback is still pending. If the callback
+  returns a promise, `useTransition()` keeps `isPending` true until it settles.
+  Server rendering runs transition callbacks immediately and never exposes
+  pending state.
+- `useActionState(action, initialState)` matches React's argument order while
+  staying client-side in Fig today. Actions receive the previous state first,
+  then the runner's arguments, then an `AbortSignal` Fig appends — declare the
+  trailing signal parameter (it drives `Args` inference):
+
+  ```ts
+  const [count, add, isPending] = useActionState(
+    (previous: number, amount: number, signal: AbortSignal) => {
+      return fetchNext(previous + amount, { signal });
+    },
+    0,
+  );
+  add(2); // Fig appends the signal; callers pass only the args.
+  ```
+
+  Runs are last-run-wins: a new run aborts the previous one's signal and
+  retires it, so a stale settlement (value or rejection) never touches state,
+  error, or pending. The signal also aborts on unmount and Activity hide.
+  Server actions can layer on top later without changing the hook shape.
+
+- Document resources: `assets([...], children)` attaches resources to a
+  subtree while rendering only `children` on the client. Resource helpers include
+  `stylesheet`, `preload`, `font`, `preconnect`, `title`, `meta`, and `script`.
+  Server rendering exposes `title` and `meta` as document head output; stream-safe
+  assets such as stylesheets can be emitted near the segments that depend on
+  them.
+
+## Renderer APIs
+
+Use `@bgub/fig-dom` for browser rendering:
+
+- `createRoot(container)` renders client roots.
+- `hydrateRoot(container, children, options?)` hydrates server HTML and reports
+  recoverable mismatches with `onRecoverableError`.
+- `createPortal(children, container, key?)` renders into external DOM targets.
+- DOM events use `events={[on("click", (event, signal) => ...)]}`.
+- DOM node access uses `bind={(node, signal) => ...}`.
+- Raw trusted HTML uses `unsafeHTML="<p>trusted html</p>"`.
+
+Use `@bgub/fig-server` for streaming server rendering with
+`renderToStream` or `renderToHtml`.
+
+## Data Resources
+
+Key-addressable async data resources are part of the core package. Data
+resources are render-time inputs with stable keys: Fig dedupes loads by
+key, wires missing values to `Suspense`, tracks committed readers, and
+lets applications invalidate or refresh specific entries and key
+prefixes. The store implementation travels with `dataResource` itself, so
+bundles that never define a resource never ship it.
+
+### Basic Usage
+
+```tsx
+import { Suspense } from "@bgub/fig";
+import { createRoot, on } from "@bgub/fig-dom";
+import { dataResource, readData, refreshData } from "@bgub/fig";
+
+const userResource = dataResource({
+  key: (id: string) => ["user", id],
+  load: async (id: string, { signal }) => {
+    const response = await fetch(`/api/users/${id}`, { signal });
+    return response.json() as Promise<{ name: string }>;
+  },
+});
+
+function Profile({ id }: { id: string }) {
+  const user = readData(userResource, id);
+
+  return (
+    <button events={[on("click", () => void refreshData(userResource, id))]}>
+      {user.name}
+    </button>
+  );
+}
+
+createRoot(document.getElementById("root")!).render(
+  <Suspense fallback={<span>Loading</span>}>
+    <Profile id="one" />
+  </Suspense>,
+);
+```
+
+`readData(resource, ...args)` is render-only. It returns fulfilled values,
+throws pending loads to `Suspense`, and throws failed initial loads to
+`ErrorBoundary`.
+
+### Keys
+
+Every resource has a key function. Keys must be arrays whose first item is a
+string namespace:
+
+```ts
+key: (id: string, locale: string) => ["user", id, { locale }];
+```
+
+Key values may contain strings, finite numbers, booleans, `null`, arrays, and
+plain objects. Object keys are canonicalized in sorted order. `undefined`,
+`NaN`, infinities, functions, symbols, dates, maps, sets, promises, class
+instances, and cycles are invalid.
+
+The key is the whole cache identity. Fig uses the canonical key for reads,
+dedupe, invalidation, refresh, SSR serialization, hydration, diagnostics, and
+DevTools.
+
+### Refresh And Invalidate
+
+`invalidateData(resource, ...args)` marks an existing entry stale. If the key is
+currently observed, Fig schedules the readers; the next read keeps showing the
+last fulfilled value and starts a background reload. If nobody is observing the
+key, invalidation is lazy and does not fetch.
+
+`invalidateDataKey(key)` applies the same stale/reset semantics to one exact
+structured key. `invalidateDataError(error)` invalidates every exact key Fig
+attributed to a caught data error and returns whether any data keys were found.
+Use it from an `ErrorBoundary` fallback before remounting or resetting the
+boundary.
+
+`invalidateDataPrefix(prefix)` marks every existing entry whose structured key
+starts with `prefix` stale. For example, `invalidateDataPrefix(["user"])`
+targets entries like `["user", id]`. Prefix matching uses the same canonical
+key encoder as normal reads, so delimiter-shaped strings do not collide.
+
+`refreshData(resource, ...args)` fetches immediately and resolves with a result
+instead of rejecting:
+
+```ts
+const result = await refreshData(userResource, "one");
+
+if (result.status === "fulfilled") {
+  console.log(result.value);
+}
+```
+
+Result statuses are `fulfilled`, `rejected`, `aborted`, and `unsupported`.
+Refresh failures preserve the last fulfilled value when one exists, so visible
+UI does not fall back to Suspense or an error boundary just because a refresh
+failed.
+
+### Root Store Scope
+
+Fig installs the current root data store while rendering and while running
+Fig-managed callbacks such as delegated event handlers. Outside those scopes,
+bind the store explicitly:
+
+```ts
+const root = createRoot(container);
+
+socket.on("user:update", (id) => {
+  root.data.run(() => invalidateData(userResource, id));
+});
+```
+
+`root.data.run(fn)` is synchronous. If you need to invalidate after an `await`,
+keep the handle and re-enter:
+
+```ts
+const data = root.data;
+await save();
+data.run(() => refreshData(userResource, "one"));
+```
+
+Client roots accept `dataPartition` and `initialData` options. The partition
+separates a store's internal keyspace without changing public resource keys.
+Loaders receive only their resource arguments plus `{ signal }`; app services,
+request cookies, and auth state belong in the surrounding adapter or closure,
+not in the data store.
+
+### Server Values And Hydration
+
+Server renderers expose fulfilled data entries with `getData()`. Pass those
+entries to the client root as `initialData` to hydrate by key.
+
+For server-only data, split the browser-safe key resource from the server
+loader:
+
+```ts
+import { dataResource } from "@bgub/fig";
+import { serverDataResource } from "@bgub/fig/server";
+
+export const userKey = (id: string) => ["user", id];
+
+export const userResource = dataResource<[string], User>({
+  key: userKey,
+});
+
+export const userServerResource = serverDataResource({
+  key: userKey,
+  load: async (id, { signal }) => fetchUser(id, signal),
+});
+```
+
+Client code imports the loader-less resource. If the server streamed a value
+for the same key, the client can read it as a hydrate-only entry. Since the
+resource has no client loader, `refreshData(userResource, id)` resolves with
+`{ status: "unsupported", reason: "no-client-loader" }`; revalidation needs a
+payload or framework refresh path.
+
+Browser bundles need the `figData` transform from `@bgub/fig-vite` so imports of
+`.server.ts(x)` modules become loader-free client stubs instead of bundling the
+server loader. Fig Start includes this transform automatically.
+
+Direct client refreshes of server data are a framework feature, not a core
+data one: an endpoint has to exist to serve them. Fig Start provides
+`remoteDataResource` (from `@bgub/fig-start/server`), whose browser import
+compiles into a plain `dataResource` with a loader that calls the framework
+data endpoint. Without a framework, define an isomorphic `dataResource` whose
+loader fetches an endpoint you own. Server route payload navigations do not
+make an extra data request either way — data read during the payload render
+streams in that same payload response.
+
+### Activity, Errors, And DevTools
+
+Data-resource subscriptions are committed even inside hidden `Activity` trees.
+Invalidating a hidden-only key schedules offscreen prerender work and keeps the
+DOM hidden.
+
+Initial load errors are keyed. `ErrorBoundary` reports the failed keys on
+`info.dataResourceKeys`; reset flows can call `invalidateDataError(error)` or
+refresh/invalidate those keys before remounting or changing the boundary key.
+
+Fig DevTools root snapshots include data-resource entries with their normalized
+keys, statuses, stale state, subscriber counts, current values, and errors. The
+in-page DevTools exposes them in the `Data` tab.
+
+## License
+
+MIT

package/dist/data-CHJh_xU9.d.ts

@@ -0,0 +1,79 @@
+//#region src/data.d.ts
+type DataResourceKeyInput = string | number | boolean | null | readonly DataResourceKeyInput[] | {
+  readonly [key: string]: DataResourceKeyInput;
+};
+type DataResourceKey = readonly [string, ...DataResourceKeyInput[]];
+interface DataResourceLoadContext {
+  signal: AbortSignal;
+}
+interface DataResource<TArgs extends unknown[] = unknown[], TValue = unknown> {
+  readonly $$typeof: symbol;
+  readonly debugArgs?: (...args: TArgs) => DataResourceKeyInput;
+  readonly key: (...args: TArgs) => DataResourceKey;
+  readonly load?: (...argsAndContext: [...TArgs, DataResourceLoadContext]) => TValue | PromiseLike<TValue>;
+}
+type DataRefreshResult<T> = {
+  status: "fulfilled";
+  value: T;
+} | {
+  status: "rejected";
+  error: unknown;
+  staleValue?: T;
+} | {
+  status: "aborted";
+  reason: "superseded" | "store-disposed" | "evicted";
+  staleValue?: T;
+} | {
+  status: "unsupported";
+  reason: "no-client-loader";
+  staleValue?: T;
+};
+interface FigDataHydrationEntry {
+  key: DataResourceKey;
+  value: unknown;
+}
+type FigDataEntryStatus = "pending" | "fulfilled" | "rejected" | "refreshing";
+interface DataStoreEntrySnapshot {
+  canonicalKey: string;
+  error?: unknown;
+  hasValue: boolean;
+  key: DataResourceKey;
+  pending: boolean;
+  refreshError?: unknown;
+  stale: boolean;
+  status: FigDataEntryStatus;
+  subscriberCount: number;
+  value?: unknown;
+}
+interface FigDataStoreHandle {
+  hydrate(entries: readonly FigDataHydrationEntry[]): void;
+  invalidateData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, ...args: TArgs): void;
+  invalidateDataError(error: unknown): boolean;
+  invalidateDataKey(key: DataResourceKey): void;
+  invalidateDataPrefix(prefix: DataResourceKey): void;
+  preloadData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, ...args: TArgs): void;
+  refreshData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, ...args: TArgs): Promise<DataRefreshResult<TValue>>;
+  run<T>(callback: () => T): T;
+}
+interface FigDataStore extends FigDataStoreHandle {
+  commitDataDependencies(owner: object, previousOwner: object | null): void;
+  deleteDataOwner(owner: object): void;
+  releaseDataOwner(owner: object): void;
+  resetDataDependencies(owner: object): void;
+  dispose(): void;
+  inspectDataEntries(): DataStoreEntrySnapshot[];
+  snapshot(): FigDataHydrationEntry[];
+  readData<TArgs extends unknown[], TValue>(resource: DataResource<TArgs, TValue>, args: TArgs, owner: object): TValue;
+}
+interface FigDataStoreHost {
+  getLane(): unknown;
+  partition?: DataResourceKeyInput;
+  schedule(owner: object, lane: unknown): void;
+}
+type FigDataStoreFactory = (host: FigDataStoreHost) => FigDataStore;
+declare function resolveCurrentDataStore(message?: string): FigDataStore;
+declare function setCurrentDataStore(store: FigDataStore | null): FigDataStore | null;
+declare function markDataResourceError(error: unknown, key: DataResourceKey): void;
+declare function dataResourceKeysForError(error: unknown): DataResourceKey[] | undefined;
+//#endregion
+export { DataResourceLoadContext as a, FigDataHydrationEntry as c, FigDataStoreHandle as d, FigDataStoreHost as f, setCurrentDataStore as g, resolveCurrentDataStore as h, DataResourceKeyInput as i, FigDataStore as l, markDataResourceError as m, DataResource as n, DataStoreEntrySnapshot as o, dataResourceKeysForError as p, DataResourceKey as r, FigDataEntryStatus as s, DataRefreshResult as t, FigDataStoreFactory as u };

package/dist/data-h46EcMnE.js

@@ -0,0 +1,37 @@
+//#region src/data.ts
+const objectDataErrors = /* @__PURE__ */ new WeakMap();
+let currentDataStore = null;
+function resolveCurrentDataStore(message = "Data resource APIs require a Fig data store.") {
+	if (currentDataStore === null) throw new Error(message);
+	return currentDataStore;
+}
+function setCurrentDataStore(store) {
+	const previousStore = currentDataStore;
+	currentDataStore = store;
+	return previousStore;
+}
+function markDataResourceError(error, key) {
+	if (!isObjectKey(error)) return;
+	let keys = objectDataErrors.get(error);
+	if (keys === void 0) {
+		keys = [];
+		objectDataErrors.set(error, keys);
+	}
+	if (keys.some((existing) => sameDataResourceKey(existing, key))) return;
+	keys.push(key);
+}
+function dataResourceKeysForError(error) {
+	if (!isObjectKey(error)) return void 0;
+	const keys = objectDataErrors.get(error);
+	return keys === void 0 || keys.length === 0 ? void 0 : [...keys];
+}
+function sameDataResourceKey(a, b) {
+	return a.length === b.length && a.every((value, index) => Object.is(value, b[index]));
+}
+function isObjectKey(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+//#endregion
+export { setCurrentDataStore as i, markDataResourceError as n, resolveCurrentDataStore as r, dataResourceKeysForError as t };
+
+//# sourceMappingURL=data-h46EcMnE.js.map

package/dist/data-h46EcMnE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-h46EcMnE.js","names":[],"sources":["../src/data.ts"],"sourcesContent":["export type DataResourceKeyInput =\n  | string\n  | number\n  | boolean\n  | null\n  | readonly DataResourceKeyInput[]\n  | { readonly [key: string]: DataResourceKeyInput };\n\nexport type DataResourceKey = readonly [string, ...DataResourceKeyInput[]];\n\nexport interface DataResourceLoadContext {\n  signal: AbortSignal;\n}\n\nexport interface DataResource<\n  TArgs extends unknown[] = unknown[],\n  TValue = unknown,\n> {\n  readonly $$typeof: symbol;\n  readonly debugArgs?: (...args: TArgs) => DataResourceKeyInput;\n  readonly key: (...args: TArgs) => DataResourceKey;\n  readonly load?: (\n    ...argsAndContext: [...TArgs, DataResourceLoadContext]\n  ) => TValue | PromiseLike<TValue>;\n}\n\nexport type DataRefreshResult<T> =\n  | { status: \"fulfilled\"; value: T }\n  | { status: \"rejected\"; error: unknown; staleValue?: T }\n  | {\n      status: \"aborted\";\n      reason: \"superseded\" | \"store-disposed\" | \"evicted\";\n      staleValue?: T;\n    }\n  | {\n      status: \"unsupported\";\n      reason: \"no-client-loader\";\n      staleValue?: T;\n    };\n\nexport interface FigDataHydrationEntry {\n  key: DataResourceKey;\n  value: unknown;\n}\n\nexport type FigDataEntryStatus =\n  | \"pending\"\n  | \"fulfilled\"\n  | \"rejected\"\n  | \"refreshing\";\n\nexport interface DataStoreEntrySnapshot {\n  canonicalKey: string;\n  error?: unknown;\n  hasValue: boolean;\n  key: DataResourceKey;\n  pending: boolean;\n  refreshError?: unknown;\n  stale: boolean;\n  status: FigDataEntryStatus;\n  subscriberCount: number;\n  value?: unknown;\n}\n\n// The explicit, app-facing store surface (FigRoot.data, readDataStore()).\n// The free functions in @bgub/fig resolve the ambient store slot, which\n// is only set while Fig executes synchronously — render, event handlers, the\n// synchronous prefix of actions and transitions, and effects. After an\n// `await` the slot is gone, so async flows capture this handle first and call\n// its methods instead.\nexport interface FigDataStoreHandle {\n  hydrate(entries: readonly FigDataHydrationEntry[]): void;\n  invalidateData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    ...args: TArgs\n  ): void;\n  invalidateDataError(error: unknown): boolean;\n  invalidateDataKey(key: DataResourceKey): void;\n  invalidateDataPrefix(prefix: DataResourceKey): void;\n  preloadData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    ...args: TArgs\n  ): void;\n  refreshData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    ...args: TArgs\n  ): Promise<DataRefreshResult<TValue>>;\n  run<T>(callback: () => T): T;\n}\n\nexport interface FigDataStore extends FigDataStoreHandle {\n  commitDataDependencies(owner: object, previousOwner: object | null): void;\n  deleteDataOwner(owner: object): void;\n  releaseDataOwner(owner: object): void;\n  resetDataDependencies(owner: object): void;\n  dispose(): void;\n  inspectDataEntries(): DataStoreEntrySnapshot[];\n  snapshot(): FigDataHydrationEntry[];\n  // Renderer plumbing, not handle surface: args stay an array because the\n  // subscribing owner trails them.\n  readData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    args: TArgs,\n    owner: object,\n  ): TValue;\n}\n\n// The host callbacks a renderer hands to the data-store factory. Structurally\n// compatible with @bgub/fig's DataStoreHost so its createDataStore can\n// register directly.\nexport interface FigDataStoreHost {\n  getLane(): unknown;\n  partition?: DataResourceKeyInput;\n  schedule(owner: object, lane: unknown): void;\n}\n\nexport type FigDataStoreFactory = (host: FigDataStoreHost) => FigDataStore;\n\nconst objectDataErrors = new WeakMap<object, DataResourceKey[]>();\n\nlet currentDataStore: FigDataStore | null = null;\n\nexport function resolveCurrentDataStore(\n  message = \"Data resource APIs require a Fig data store.\",\n): FigDataStore {\n  if (currentDataStore === null) throw new Error(message);\n  return currentDataStore;\n}\n\nexport function setCurrentDataStore(\n  store: FigDataStore | null,\n): FigDataStore | null {\n  const previousStore = currentDataStore;\n  currentDataStore = store;\n  return previousStore;\n}\n\nexport function markDataResourceError(\n  error: unknown,\n  key: DataResourceKey,\n): void {\n  // Only object errors are attributed: the WeakMap keys them by identity, so the\n  // registry is GC-safe and cannot cross-attribute. Primitive rejection values\n  // would collide by value and accumulate forever in a plain Map, so a thrown\n  // primitive simply carries no resource-key metadata.\n  if (!isObjectKey(error)) return;\n\n  let keys = objectDataErrors.get(error);\n  if (keys === undefined) {\n    keys = [];\n    objectDataErrors.set(error, keys);\n  }\n\n  if (keys.some((existing) => sameDataResourceKey(existing, key))) return;\n\n  keys.push(key);\n}\n\nexport function dataResourceKeysForError(\n  error: unknown,\n): DataResourceKey[] | undefined {\n  if (!isObjectKey(error)) return undefined;\n\n  const keys = objectDataErrors.get(error);\n  return keys === undefined || keys.length === 0 ? undefined : [...keys];\n}\n\nfunction sameDataResourceKey(a: DataResourceKey, b: DataResourceKey): boolean {\n  return (\n    a.length === b.length &&\n    a.every((value, index) => Object.is(value, b[index]))\n  );\n}\n\nfunction isObjectKey(value: unknown): value is object {\n  return (\n    (typeof value === \"object\" || typeof value === \"function\") && value !== null\n  );\n}\n"],"mappings":";AAsHA,MAAM,mCAAmB,IAAI,QAAmC;AAEhE,IAAI,mBAAwC;AAE5C,SAAgB,wBACd,UAAU,gDACI;CACd,IAAI,qBAAqB,MAAM,MAAM,IAAI,MAAM,OAAO;CACtD,OAAO;AACT;AAEA,SAAgB,oBACd,OACqB;CACrB,MAAM,gBAAgB;CACtB,mBAAmB;CACnB,OAAO;AACT;AAEA,SAAgB,sBACd,OACA,KACM;CAKN,IAAI,CAAC,YAAY,KAAK,GAAG;CAEzB,IAAI,OAAO,iBAAiB,IAAI,KAAK;CACrC,IAAI,SAAS,KAAA,GAAW;EACtB,OAAO,CAAC;EACR,iBAAiB,IAAI,OAAO,IAAI;CAClC;CAEA,IAAI,KAAK,MAAM,aAAa,oBAAoB,UAAU,GAAG,CAAC,GAAG;CAEjE,KAAK,KAAK,GAAG;AACf;AAEA,SAAgB,yBACd,OAC+B;CAC/B,IAAI,CAAC,YAAY,KAAK,GAAG,OAAO,KAAA;CAEhC,MAAM,OAAO,iBAAiB,IAAI,KAAK;CACvC,OAAO,SAAS,KAAA,KAAa,KAAK,WAAW,IAAI,KAAA,IAAY,CAAC,GAAG,IAAI;AACvE;AAEA,SAAS,oBAAoB,GAAoB,GAA6B;CAC5E,OACE,EAAE,WAAW,EAAE,UACf,EAAE,OAAO,OAAO,UAAU,OAAO,GAAG,OAAO,EAAE,MAAM,CAAC;AAExD;AAEA,SAAS,YAAY,OAAiC;CACpD,QACG,OAAO,UAAU,YAAY,OAAO,UAAU,eAAe,UAAU;AAE5E"}