@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/records/hooks.js

@@ -0,0 +1,39 @@
+import { useCallback as u, useSyncExternalStore as m, useEffect as d, useMemo as y, useRef as x } from "react";
+import { subscribeToKey as g, UNKNOWN_STATE as h, readState as v, getUnknownState as z, retainKeys as E, subscribeToStaleness as N, readStaleness as O, getEmptyStaleness as R } from "./store.js";
+import { recordKey as j } from "./wire.js";
+function C(a, o, i) {
+  const e = o == null ? null : j(a.type, o), t = i.needs, s = u(
+    (f) => e === null ? () => {
+    } : g(e, f),
+    [e]
+  ), p = u(
+    () => e === null ? h : v(e, t),
+    [e, t]
+  ), l = m(s, p, z);
+  return d(() => e === null ? void 0 : E([e]), [e]), l;
+}
+function M(a, o, i) {
+  const e = i.needs, t = y(() => o.map((r) => j(a.type, r)), [a.type, o.join("\0")]), s = t.join("\0"), p = u(
+    (r) => {
+      const n = t.map((c) => g(c, r));
+      return () => n.forEach((c) => c());
+    },
+    [s]
+  ), l = x(null), f = u(() => {
+    const r = t.map((S) => v(S, e)), n = l.current;
+    if (n && n.signature === s && n.needs === e && n.states.length === r.length && n.states.every((S, k) => S === r[k]))
+      return n.states;
+    const c = Object.freeze(r);
+    return l.current = { signature: s, needs: e, states: c }, c;
+  }, [s, e]), b = y(() => Object.freeze(t.map(() => h)), [s]), K = u(() => b, [b]), T = m(p, f, K);
+  return d(() => E(t), [s]), T;
+}
+function W() {
+  return m(N, O, R);
+}
+export {
+  C as useRecord,
+  M as useRecords,
+  W as useStaleness
+};
+//# sourceMappingURL=hooks.js.map

package/dist/lib/records/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sources":["../../../src/lib/records/hooks.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from \"react\";\nimport type { ReadOptions, RecordState, RecordTypeToken, StalenessEntry } from \"./types\";\nimport {\n  getEmptyStaleness,\n  getUnknownState,\n  readState,\n  readStaleness,\n  retainKeys,\n  subscribeToKey,\n  subscribeToStaleness,\n  UNKNOWN_STATE,\n} from \"./store\";\nimport { recordKey } from \"./wire\";\n\n/* ============================================================================\n   THE READ HOOKS.\n\n   Every one of them is a `useSyncExternalStore` over the module store, and\n   every one of them is written around ONE constraint: `getSnapshot` MUST\n   return the identical reference when nothing changed, or React throws \"The\n   result of getSnapshot should be cached\" and loops. The store's per-key state\n   memo does the work for a single key; the array hook needs a second, small\n   memo of its own, because an array built per render is a fresh reference even\n   when every element in it is identical.\n\n   `getServerSnapshot` is passed everywhere. It is not needed in a plain SPA\n   build, and omitting it throws under any future prerender — which is exactly\n   the sort of latent failure this package documents rather than discovers.\n   ========================================================================= */\n\n/**\n * Read one record.\n *\n * `needs` IS REQUIRED. It names the field set that must have landed from a\n * FETCH before this key reports `present`; until then the answer is `unknown`,\n * even when a broadcast has already seeded the key with real values. That is\n * the whole guard: a projection function handed a broadcast-seeded record\n * assumes absent means empty and renders a confident, wrong answer.\n *\n * `id` may be `null`/`undefined` for a conditional read — the hook then holds\n * no subscription and reports `unknown`, rather than forcing a caller into two\n * code paths around a rule of hooks.\n */\nexport function useRecord<T>(\n  token: RecordTypeToken<T>,\n  id: string | number | null | undefined,\n  options: ReadOptions,\n): RecordState<T> {\n  const key = id === null || id === undefined ? null : recordKey(token.type, id);\n  const needs = options.needs;\n\n  const subscribe = useCallback(\n    (listener: () => void) => (key === null ? () => {} : subscribeToKey(key, listener)),\n    [key],\n  );\n\n  const getSnapshot = useCallback(\n    () => (key === null ? UNKNOWN_STATE : readState(key, needs)),\n    [key, needs],\n  );\n\n  const state = useSyncExternalStore(subscribe, getSnapshot, getUnknownState);\n\n  /* Retention is a ROOT claim, not a subscription: it says \"hydration may\n     still walk through here\", which is what keeps a record's children alive\n     when nothing reads them directly. */\n  useEffect(() => (key === null ? undefined : retainKeys([key])), [key]);\n\n  return state as RecordState<T>;\n}\n\n/**\n * Read many records at once, sharing one hydration per key with every other\n * reader of that key.\n *\n * IT TAKES A KEY LIST AND DERIVES A STRING FROM IT rather than depending on the\n * array's identity, so a caller passing a freshly-mapped array on every render\n * — the normal thing to do — does not re-subscribe and does not violate\n * `getSnapshot` identity. The alternative, subscribing to the whole store for a\n * set of records, is the anti-pattern this package already ships once in\n * `createSimStore.useById`; per-key notification is the entire reason this\n * store exists.\n */\nexport function useRecords<T>(\n  token: RecordTypeToken<T>,\n  ids: readonly (string | number)[],\n  options: ReadOptions,\n): readonly RecordState<T>[] {\n  const needs = options.needs;\n  const keys = useMemo(() => ids.map((id) => recordKey(token.type, id)), [token.type, ids.join(\"\\0\")]);\n  const signature = keys.join(\"\\0\");\n\n  const subscribe = useCallback(\n    (listener: () => void) => {\n      const releases = keys.map((key) => subscribeToKey(key, listener));\n      return () => releases.forEach((release) => release());\n    },\n    [signature],\n  );\n\n  const cache = useRef<{ signature: string; needs: string; states: readonly RecordState<unknown>[] } | null>(null);\n\n  const getSnapshot = useCallback(() => {\n    const next = keys.map((key) => readState(key, needs));\n    const previous = cache.current;\n    if (\n      previous &&\n      previous.signature === signature &&\n      previous.needs === needs &&\n      previous.states.length === next.length &&\n      previous.states.every((state, index) => state === next[index])\n    ) {\n      return previous.states;\n    }\n    const frozen = Object.freeze(next);\n    cache.current = { signature, needs, states: frozen };\n    return frozen;\n  }, [signature, needs]);\n\n  /* One array per key list, built once. A fresh literal here throws under the\n     only condition `getServerSnapshot` exists for, exactly as it would for the\n     single-key hook — the length has to match, so the shared empty constant\n     will not do. */\n  const serverStates = useMemo(() => Object.freeze(keys.map(() => UNKNOWN_STATE)), [signature]);\n  const getServerSnapshot = useCallback(() => serverStates, [serverStates]);\n\n  const states = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n\n  useEffect(() => retainKeys(keys), [signature]);\n\n  return states as readonly RecordState<T>[];\n}\n\n/**\n * The staleness signal: affected ROOTS and their now-stale field sets.\n *\n * ITS ONLY CONSUMER IS THE LAYER THAT PERFORMED THE ORIGINAL FETCH. It\n * re-issues the request it already made — it needs no registry of loaders,\n * because \"which field set\" is not a question it has to answer; it is the one\n * it already asked. The library contributes the signal and nothing else, which\n * is what keeps every endpoint and every type name out of this package.\n *\n * TWO PROPERTIES THE CONSUMER MUST SUPPLY, because they are not expressible\n * here: coalescing in BREADTH (twenty-five rows going stale in one burst is one\n * list refetch, not twenty-five record refetches) and in TIME (a minimum\n * interval, plus dedup against a refetch already in flight — a second signal\n * arriving mid-flight sets a re-run flag rather than issuing a second request).\n * Breadth alone is not enough: an event with no change guard on the server\n * fires continuously during a long job, so it is a stream rather than a burst.\n */\nexport function useStaleness(): readonly StalenessEntry[] {\n  return useSyncExternalStore(subscribeToStaleness, readStaleness, getEmptyStaleness);\n}\n"],"names":["useRecord","token","id","options","key","recordKey","needs","subscribe","useCallback","listener","subscribeToKey","getSnapshot","UNKNOWN_STATE","readState","state","useSyncExternalStore","getUnknownState","useEffect","retainKeys","useRecords","ids","keys","useMemo","signature","releases","release","cache","useRef","next","previous","index","frozen","serverStates","getServerSnapshot","states","useStaleness","subscribeToStaleness","readStaleness","getEmptyStaleness"],"mappings":";;;AA2CO,SAASA,EACdC,GACAC,GACAC,GACgB;AAChB,QAAMC,IAAMF,KAAO,OAA2B,OAAOG,EAAUJ,EAAM,MAAMC,CAAE,GACvEI,IAAQH,EAAQ,OAEhBI,IAAYC;AAAA,IAChB,CAACC,MAA0BL,MAAQ,OAAO,MAAM;AAAA,IAAC,IAAIM,EAAeN,GAAKK,CAAQ;AAAA,IACjF,CAACL,CAAG;AAAA,EAAA,GAGAO,IAAcH;AAAA,IAClB,MAAOJ,MAAQ,OAAOQ,IAAgBC,EAAUT,GAAKE,CAAK;AAAA,IAC1D,CAACF,GAAKE,CAAK;AAAA,EAAA,GAGPQ,IAAQC,EAAqBR,GAAWI,GAAaK,CAAe;AAK1E,SAAAC,EAAU,MAAOb,MAAQ,OAAO,SAAYc,EAAW,CAACd,CAAG,CAAC,GAAI,CAACA,CAAG,CAAC,GAE9DU;AACT;AAcO,SAASK,EACdlB,GACAmB,GACAjB,GAC2B;AAC3B,QAAMG,IAAQH,EAAQ,OAChBkB,IAAOC,EAAQ,MAAMF,EAAI,IAAI,CAAClB,MAAOG,EAAUJ,EAAM,MAAMC,CAAE,CAAC,GAAG,CAACD,EAAM,MAAMmB,EAAI,KAAK,IAAI,CAAC,CAAC,GAC7FG,IAAYF,EAAK,KAAK,IAAI,GAE1Bd,IAAYC;AAAA,IAChB,CAACC,MAAyB;AACxB,YAAMe,IAAWH,EAAK,IAAI,CAACjB,MAAQM,EAAeN,GAAKK,CAAQ,CAAC;AAChE,aAAO,MAAMe,EAAS,QAAQ,CAACC,MAAYA,GAAS;AAAA,IACtD;AAAA,IACA,CAACF,CAAS;AAAA,EAAA,GAGNG,IAAQC,EAA6F,IAAI,GAEzGhB,IAAcH,EAAY,MAAM;AACpC,UAAMoB,IAAOP,EAAK,IAAI,CAACjB,MAAQS,EAAUT,GAAKE,CAAK,CAAC,GAC9CuB,IAAWH,EAAM;AACvB,QACEG,KACAA,EAAS,cAAcN,KACvBM,EAAS,UAAUvB,KACnBuB,EAAS,OAAO,WAAWD,EAAK,UAChCC,EAAS,OAAO,MAAM,CAACf,GAAOgB,MAAUhB,MAAUc,EAAKE,CAAK,CAAC;AAE7D,aAAOD,EAAS;AAElB,UAAME,IAAS,OAAO,OAAOH,CAAI;AACjC,WAAAF,EAAM,UAAU,EAAE,WAAAH,GAAW,OAAAjB,GAAO,QAAQyB,EAAA,GACrCA;AAAA,EACT,GAAG,CAACR,GAAWjB,CAAK,CAAC,GAMf0B,IAAeV,EAAQ,MAAM,OAAO,OAAOD,EAAK,IAAI,MAAMT,CAAa,CAAC,GAAG,CAACW,CAAS,CAAC,GACtFU,IAAoBzB,EAAY,MAAMwB,GAAc,CAACA,CAAY,CAAC,GAElEE,IAASnB,EAAqBR,GAAWI,GAAasB,CAAiB;AAE7E,SAAAhB,EAAU,MAAMC,EAAWG,CAAI,GAAG,CAACE,CAAS,CAAC,GAEtCW;AACT;AAmBO,SAASC,IAA0C;AACxD,SAAOpB,EAAqBqB,GAAsBC,GAAeC,CAAiB;AACpF;"}

package/dist/lib/records/store.js

@@ -0,0 +1,572 @@
+import { devWarn as V } from "../dev-warn.js";
+import { staleFieldsFor as W } from "./define-record-type.js";
+import { normalizeTypeName as x, recordKey as H, isStalePing as Y, payloadIdentity as J, isRecordRef as M, normalizeTimestamp as ce, tombstoneAt as ae, explicitlyUndeleted as de, isEnvelopeKey as ue } from "./wire.js";
+const Q = -1, c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Set(), b = /* @__PURE__ */ new Map();
+let j = /* @__PURE__ */ new Set();
+const g = /* @__PURE__ */ new Map();
+let w = 0, S;
+function Re(e) {
+  if (e !== S) {
+    S = e, c.clear(), l.clear(), y.clear(), k.clear(), w += 1, _e();
+    for (const n of [...E]) n();
+  }
+}
+const E = /* @__PURE__ */ new Set();
+function Ve(e) {
+  return E.add(e), () => E.delete(e);
+}
+function Me() {
+  return S;
+}
+function Ee() {
+  return w;
+}
+const m = Object.freeze([]);
+function le(e, n) {
+  if (Y(e))
+    return { verdict: "rejected-shape", keys: m, refusedNested: m, reason: "a __stale ping carries no __type to key on" };
+  const t = J(e);
+  if (!t)
+    return { verdict: "rejected-shape", keys: m, refusedNested: m, reason: "missing __type or id" };
+  if (S !== void 0 && n.tenant !== S)
+    return {
+      verdict: "dropped-tenant",
+      keys: m,
+      refusedNested: m,
+      reason: `stamped for tenant ${String(n.tenant)}; this store now serves ${String(S)}`
+    };
+  S === void 0 && n.tenant !== void 0 && V(
+    "recordStore",
+    "a write carried a tenant but the store has none — call setRecordStoreTenant() or the cross-tenant guard is inert."
+  ), n.source === "broadcast" && n.tag !== void 0 && V(
+    "recordStore",
+    "a broadcast supplied a field-set tag — ignored. A broadcast is partial by whitelist and can never complete a record."
+  );
+  const r = { options: n, touched: /* @__PURE__ */ new Set(), refusedNested: [], inFlight: /* @__PURE__ */ new Map() }, s = X(e, t, r);
+  return s === "dropped-older" ? { verdict: s, keys: m, refusedNested: m, reason: `older than the stored ${t.key}` } : { verdict: s, keys: [...r.touched], refusedNested: r.refusedNested };
+}
+function Be(e, n) {
+  const t = [], r = /* @__PURE__ */ new Set();
+  for (const s of e) {
+    const o = le(s, n);
+    t.push(o);
+    for (const f of o.keys) r.add(f);
+  }
+  return { results: t, keys: [...r] };
+}
+function X(e, n, t) {
+  const { key: r, type: s } = n, o = ce(e.__timestamp), f = c.get(r);
+  if (f && f.timestamp !== void 0 && o !== void 0 && o < f.timestamp)
+    return V("recordStore", `refused a strictly older write for ${r}`), "dropped-older";
+  const i = f ?? Z(r, s);
+  t.inFlight.set(e, r), t.touched.add(r);
+  const a = ne(e, t), p = o ?? i.timestamp;
+  let u = !1;
+  i.hasBase || (i.hasBase = !0, u = !0);
+  for (const [F, P] of Object.entries(a))
+    (!(F in i.data) || !q(i.data[F], P)) && (i.data[F] = P, u = !0), p !== void 0 && (i.fieldVersions[F] = p);
+  const L = ae(e);
+  return L !== void 0 ? i.deletedAt !== L && (i.deletedAt = L, u = !0) : de(e) && i.deletedAt !== void 0 && (i.deletedAt = void 0, u = !0), t.options.source === "fetch" && t.options.tag !== void 0 && !i.tags.has(t.options.tag) && (i.tags.add(t.options.tag), u = !0), me(r, s, i, t.options.source, new Set(Object.keys(a))) && (u = !0), t.options.source === "fetch" && ye(i, new Set(Object.keys(a))) && (u = !0, T(i)), o !== void 0 && (i.timestamp === void 0 || o > i.timestamp) && (i.timestamp = o), u ? (i.baseVersion += 1, N(r, i), "applied") : "unchanged";
+}
+function Z(e, n) {
+  const t = {
+    type: n,
+    data: {},
+    hasBase: !1,
+    layers: [],
+    version: 0,
+    baseVersion: 0,
+    timestamp: void 0,
+    fieldVersions: {},
+    deletedAt: void 0,
+    tags: /* @__PURE__ */ new Set(),
+    stale: /* @__PURE__ */ new Set()
+  };
+  return c.set(e, t), t;
+}
+let R = 0;
+function pe(e, n, t) {
+  const r = H(e, n), s = c.get(r) ?? Z(r, x(e));
+  return R += 1, s.layers.push({
+    id: R,
+    fields: { ...t.fields ?? {} },
+    at: t.at,
+    tombstone: t.tombstone,
+    created: t.created === !0,
+    kept: t.kept === !0
+  }), T(s), N(r, s), R;
+}
+function Ie(e, n, t, r) {
+  const s = c.get(e), o = s?.layers.find((a) => a.id === n);
+  if (!s || !o || Object.keys(o.fields).length === 0) return;
+  const f = ee(t, e, r), i = o.at === void 0 ? t : t[o.at];
+  if (typeof i == "object" && i !== null && !Array.isArray(i)) {
+    const a = i;
+    for (const p of Object.keys(o.fields))
+      p in a && (o.fields[p] = re(a[p], f));
+  }
+  return o.kept = !0, T(s), N(e, s), { ...o.fields };
+}
+function qe(e, n, t) {
+  const r = c.get(e), s = r?.layers.find((o) => o.id === n);
+  if (!(!r || !s))
+    for (const o of Object.keys(s.fields))
+      (r.fieldVersions[s.at ?? o] ?? 0) >= t && delete s.fields[o];
+}
+function xe(e, n, t, r, s) {
+  const o = c.get(e)?.data ?? {}, f = {};
+  for (const [i, a] of Object.entries(ne(r, ee(r, e, s))))
+    i in o || (f[i] = a);
+  Object.keys(f).length !== 0 && pe(n, t, { fields: f, kept: !0 });
+}
+function ee(e, n, t) {
+  return {
+    options: { source: "fetch", tenant: t },
+    touched: /* @__PURE__ */ new Set(),
+    refusedNested: [],
+    inFlight: /* @__PURE__ */ new Map([[e, n]])
+  };
+}
+function ye(e, n) {
+  let t = !1;
+  for (const s of e.layers)
+    if (s.kept) {
+      if (s.at !== void 0) {
+        n.has(s.at) && (s.fields = {}, t = !0);
+        continue;
+      }
+      for (const o of n)
+        o in s.fields && (delete s.fields[o], t = !0);
+    }
+  const r = e.layers.filter((s) => !(s.kept && Object.keys(s.fields).length === 0));
+  return r.length !== e.layers.length && (e.layers = r, t = !0), t;
+}
+function De(e, n) {
+  const t = c.get(e);
+  if (!t) return;
+  const r = t.layers.findIndex((s) => s.id === n);
+  if (r !== -1) {
+    if (t.layers.splice(r, 1), T(t), !t.hasBase && t.layers.length === 0) {
+      c.delete(e), l.delete(e), y.delete(e), w += 1, ie(e);
+      return;
+    }
+    N(e, t);
+  }
+}
+function Ge(e, n, t, r) {
+  const s = c.get(e);
+  if (!s || t.length === 0) return;
+  let o = !1;
+  for (const i of s.layers)
+    if (!(i.id >= n || i.created || i.tombstone !== void 0 || i.at !== r))
+      for (const a of t)
+        a in i.fields && (delete i.fields[a], o = !0);
+  const f = s.layers.filter(
+    (i) => i.id >= n || i.created || i.tombstone !== void 0 || Object.keys(i.fields).length > 0
+  );
+  f.length !== s.layers.length && (s.layers = f), o && (T(s), N(e, s));
+}
+function Ue(e) {
+  return c.get(e)?.deletedAt !== void 0;
+}
+function $e(e, n) {
+  return c.get(e)?.data[n];
+}
+function Ce(e) {
+  return c.get(e)?.baseVersion ?? 0;
+}
+function Pe(e) {
+  return c.get(e)?.layers.some((n) => n.kept) ?? !1;
+}
+function We(e, n) {
+  const t = c.get(e);
+  return !t || !t.hasBase ? { status: "no-base" } : t.deletedAt !== void 0 ? { status: "deleted" } : t.tags.has(n) ? { status: "present", record: se(e, t, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), (s) => s.kept === !0) } : { status: "unknown" };
+}
+function He(e) {
+  const n = x(e), t = [];
+  for (const [r, s] of c)
+    s.type === n && s.layers.some((o) => !o.kept) && t.push(r);
+  return t;
+}
+function Ye(e, n) {
+  const t = x(e);
+  let r = b.get(t);
+  return r || (r = /* @__PURE__ */ new Set(), b.set(t, r)), r.add(n), () => {
+    const s = b.get(t);
+    s && (s.delete(n), s.size === 0 && b.delete(t));
+  };
+}
+function T(e) {
+  b.has(e.type) && (j.add(e.type), $());
+}
+function te(e) {
+  for (let n = e.layers.length - 1; n >= 0; n -= 1) {
+    const t = e.layers[n].tombstone;
+    if (t !== void 0) return t;
+  }
+  return e.deletedAt;
+}
+function he(e) {
+  return e.layers.some((n) => n.created);
+}
+function N(e, n) {
+  n.version += 1, w += 1, ie(e);
+}
+function me(e, n, t, r, s) {
+  let o = !1;
+  if (r === "fetch") {
+    for (const i of s)
+      t.stale.delete(i) && (o = !0);
+    return o;
+  }
+  const f = W(n);
+  (f === "*" || f.length > 0 || ge(t, s)) && (v.add(e), $());
+  for (const i of be(n, t, s))
+    t.stale.has(i) || (t.stale.add(i), o = !0);
+  return o;
+}
+function ge(e, n) {
+  return e.layers.some(
+    (t) => t.kept && (t.at !== void 0 ? n.has(t.at) : Object.keys(t.fields).some((r) => n.has(r)))
+  );
+}
+function be(e, n, t) {
+  const r = W(e);
+  return r === "*" ? Object.keys(n.data).filter((s) => s !== "id" && !t.has(s)) : r.filter((s) => !t.has(s));
+}
+function ne(e, n) {
+  const t = {};
+  for (const [r, s] of Object.entries(e))
+    ue(r) || (t[r] = re(s, n));
+  return t;
+}
+function re(e, n) {
+  return K(e, (t, r) => {
+    const s = n.inFlight.get(t);
+    return s !== void 0 ? s : (X(t, r, n) === "dropped-older" && n.refusedNested.push(r.key), r.key);
+  });
+}
+function Je(e) {
+  return K(e, (n, t) => t.key);
+}
+function K(e, n) {
+  if (Array.isArray(e)) return e.map((t) => K(t, n));
+  if (O(e)) {
+    const t = e;
+    if (!Y(t)) {
+      const s = J(t);
+      if (s) return { __ref: n(t, s) };
+    }
+    const r = {};
+    for (const [s, o] of Object.entries(e)) r[s] = K(o, n);
+    return r;
+  }
+  return e;
+}
+function Se(e) {
+  const n = l.get(e);
+  if (n) {
+    if (n.atGlobal === w) return n.value;
+    if (ve(n.deps))
+      return n.atGlobal = w, n.value;
+  }
+  const t = /* @__PURE__ */ new Map(), s = B(e, t, /* @__PURE__ */ new Map());
+  return l.set(e, { value: s, deps: t, atGlobal: w }), s;
+}
+function ve(e) {
+  for (const [n, t] of e) {
+    const r = c.get(n);
+    if ((r ? r.version : Q) !== t) return !1;
+  }
+  return !0;
+}
+function B(e, n, t) {
+  if (t.has(e)) return t.get(e);
+  const r = c.get(e);
+  if (n.set(e, r ? r.version : Q), !r || te(r) !== void 0) {
+    t.set(e, void 0);
+    return;
+  }
+  return se(e, r, n, t, () => !0);
+}
+function se(e, n, t, r, s) {
+  const o = { __type: n.type };
+  r.set(e, o);
+  for (const [f, i] of Object.entries(n.data)) o[f] = z(i, t, r);
+  for (const f of n.layers) {
+    if (!s(f)) continue;
+    if (f.at === void 0) {
+      for (const [p, u] of Object.entries(f.fields)) o[p] = z(u, t, r);
+      continue;
+    }
+    const i = o[f.at], a = O(i) ? { ...i } : {};
+    for (const [p, u] of Object.entries(f.fields)) a[p] = z(u, t, r);
+    o[f.at] = a;
+  }
+  return o;
+}
+function z(e, n, t) {
+  if (M(e)) return B(e.__ref, n, t);
+  if (Array.isArray(e)) {
+    const r = [];
+    for (const s of e) {
+      if (M(s)) {
+        const o = B(s.__ref, n, t);
+        o !== void 0 && r.push(o);
+        continue;
+      }
+      r.push(z(s, n, t));
+    }
+    return r;
+  }
+  if (O(e)) {
+    const r = {};
+    for (const [s, o] of Object.entries(e)) r[s] = z(o, n, t);
+    return r;
+  }
+  return e;
+}
+const D = Object.freeze({ status: "unknown" });
+function Qe() {
+  return D;
+}
+function we(e, n) {
+  const t = ke(e);
+  if (t.status !== "present") return t;
+  const r = c.get(e);
+  return r && (r.tags.has(n) || he(r)) ? t : D;
+}
+function ke(e) {
+  const n = c.get(e);
+  if (!n)
+    return y.delete(e), D;
+  const t = y.get(e), r = te(n);
+  if (r !== void 0) {
+    if (t && t.status === "deleted" && t.at === r) return t;
+    const f = Object.freeze({ status: "deleted", at: r });
+    return y.set(e, f), f;
+  }
+  const s = Se(e);
+  if (t && t.status === "present" && t.record === s && t.version === n.version)
+    return t;
+  const o = Object.freeze({
+    status: "present",
+    record: s,
+    version: n.version,
+    stale: Object.freeze([...n.stale].sort())
+  });
+  return y.set(e, o), o;
+}
+function Xe(e, n, t) {
+  return we(H(e, n), t);
+}
+let k = /* @__PURE__ */ new Set();
+const v = /* @__PURE__ */ new Set(), Oe = /* @__PURE__ */ new Set();
+let d = null;
+const G = typeof requestAnimationFrame == "function", oe = typeof document < "u";
+function Ae() {
+  return oe && document.hidden;
+}
+function je(e) {
+  return G && !Ae() ? requestAnimationFrame(e) : setTimeout(e, 0);
+}
+function U(e) {
+  G && cancelAnimationFrame(e), clearTimeout(e);
+}
+function ie(e) {
+  k.add(e), $();
+}
+function $() {
+  d === null && (d = je(() => {
+    d = null, fe();
+  }));
+}
+function ze() {
+  !oe || !G || document.addEventListener("visibilitychange", () => {
+    !document.hidden || d === null || (U(d), d = setTimeout(() => {
+      d = null, fe();
+    }, 0));
+  });
+}
+ze();
+function fe() {
+  if (d !== null && (U(d), d = null), k.size === 0 && v.size === 0 && j.size === 0) return;
+  const e = k;
+  k = /* @__PURE__ */ new Set();
+  const n = j;
+  j = /* @__PURE__ */ new Set();
+  const t = new Set(e);
+  for (const [r, s] of l)
+    if (!t.has(r)) {
+      for (const o of e)
+        if (s.deps.has(o)) {
+          t.add(r);
+          break;
+        }
+    }
+  for (const r of t) {
+    const s = h.get(r);
+    if (s)
+      for (const o of [...s]) o();
+  }
+  for (const r of [..._]) r();
+  for (const r of n) for (const s of [...b.get(r) ?? []]) s();
+}
+function _e() {
+  for (const e of [...h.values()])
+    for (const n of [...e]) n();
+  for (const e of [..._]) e();
+  for (const e of [...b.values()]) for (const n of [...e]) n();
+}
+function Ze(e, n) {
+  let t = h.get(e);
+  return t || (t = /* @__PURE__ */ new Set(), h.set(e, t)), t.add(n), () => {
+    const r = h.get(e);
+    r && (r.delete(n), r.size === 0 && h.delete(e));
+  };
+}
+function et(e) {
+  return _.add(e), () => _.delete(e);
+}
+const C = Object.freeze([]);
+let A = C;
+function tt() {
+  const e = Te();
+  return Ne(A, e) || (A = Object.freeze(e)), A;
+}
+function nt() {
+  if (v.size === 0) return Oe;
+  const e = new Set(v);
+  for (const [n, t] of l)
+    if (!e.has(n)) {
+      for (const r of v)
+        if (t.deps.has(r)) {
+          e.add(n);
+          break;
+        }
+    }
+  return v.clear(), e;
+}
+function rt() {
+  return C;
+}
+function Te() {
+  const e = /* @__PURE__ */ new Map();
+  for (const [n, t] of c)
+    if (t.stale.size !== 0)
+      for (const [r, s] of l) {
+        if (!s.deps.has(n)) continue;
+        let o = e.get(r);
+        o || (o = /* @__PURE__ */ new Set(), e.set(r, o));
+        for (const f of t.stale) o.add(f);
+      }
+  return [...e].map(([n, t]) => ({ key: n, fields: Object.freeze([...t].sort()) })).sort((n, t) => n.key < t.key ? -1 : n.key > t.key ? 1 : 0);
+}
+function Ne(e, n) {
+  return e.length !== n.length ? !1 : e.every((t, r) => {
+    const s = n[r];
+    return t.key === s.key && t.fields.length === s.fields.length && t.fields.every((o, f) => o === s.fields[f]);
+  });
+}
+function st(e) {
+  for (const t of e) g.set(t, (g.get(t) ?? 0) + 1);
+  let n = !1;
+  return () => {
+    if (!n) {
+      n = !0;
+      for (const t of e) {
+        const r = (g.get(t) ?? 0) - 1;
+        r <= 0 ? g.delete(t) : g.set(t, r);
+      }
+    }
+  };
+}
+function ot() {
+  const e = /* @__PURE__ */ new Set(), n = [...g.keys()];
+  for (const r of h.keys()) n.push(r);
+  for (const [r, s] of c) s.layers.some((o) => !o.kept) && n.push(r);
+  for (; n.length > 0; ) {
+    const r = n.pop();
+    if (e.has(r)) continue;
+    e.add(r);
+    const s = c.get(r);
+    if (s)
+      for (const o of Object.values(s.data)) I(o, n);
+  }
+  let t = 0;
+  for (const r of [...c.keys()])
+    e.has(r) || (c.delete(r), l.delete(r), y.delete(r), v.delete(r), t += 1);
+  for (const r of [...l.keys()])
+    e.has(r) || (l.delete(r), y.delete(r));
+  return t;
+}
+function I(e, n) {
+  if (M(e)) {
+    n.push(e.__ref);
+    return;
+  }
+  if (Array.isArray(e)) {
+    for (const t of e) I(t, n);
+    return;
+  }
+  if (O(e))
+    for (const t of Object.values(e)) I(t, n);
+}
+function it() {
+  d !== null && (U(d), d = null), c.clear(), l.clear(), y.clear(), h.clear(), _.clear(), b.clear(), j = /* @__PURE__ */ new Set(), g.clear(), k = /* @__PURE__ */ new Set(), v.clear(), A = C, w = 0, S = void 0;
+}
+function ft() {
+  return { records: c.size, memos: l.size, roots: g.size, listeners: h.size };
+}
+function O(e) {
+  if (typeof e != "object" || e === null || Array.isArray(e)) return !1;
+  const n = Object.getPrototypeOf(e);
+  return n === Object.prototype || n === null;
+}
+function q(e, n) {
+  if (Object.is(e, n)) return !0;
+  if (Array.isArray(e) || Array.isArray(n))
+    return !Array.isArray(e) || !Array.isArray(n) || e.length !== n.length ? !1 : e.every((t, r) => q(t, n[r]));
+  if (O(e) && O(n)) {
+    const t = Object.keys(e), r = Object.keys(n);
+    return t.length !== r.length ? !1 : t.every((s) => s in n && q(e[s], n[s]));
+  }
+  return !1;
+}
+export {
+  D as UNKNOWN_STATE,
+  fe as flushRecordNotifications,
+  rt as getEmptyStaleness,
+  Me as getRecordStoreTenant,
+  Qe as getUnknownState,
+  Pe as hasKeptLayer,
+  Ue as isBaseTombstoned,
+  Ie as keepOptimisticLayer,
+  He as layeredKeys,
+  Xe as peekRecord,
+  xe as pushKeptAnswerLayer,
+  pe as pushOptimisticLayer,
+  $e as readBaseField,
+  We as readBaseState,
+  Ce as readBaseVersion,
+  tt as readStaleness,
+  we as readState,
+  ft as recordStoreStats,
+  Ee as recordStoreVersion,
+  De as removeOptimisticLayer,
+  it as resetRecordStore,
+  st as retainKeys,
+  Re as setRecordStoreTenant,
+  Je as storedShape,
+  Ze as subscribeToKey,
+  Ye as subscribeToLayers,
+  et as subscribeToStaleness,
+  Ve as subscribeToTenant,
+  ot as sweepRecords,
+  nt as takeStaleEvents,
+  Ge as trimOptimisticLayers,
+  qe as trimSupersededFields,
+  le as write,
+  Be as writeAll
+};
+//# sourceMappingURL=store.js.map