@oxyhq/services 30.0.0 → 30.0.1

package/lib/commonjs/ui/runtime/createOxyRuntime.js

@@ -0,0 +1,433 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOxyRuntime = createOxyRuntime;
+var _core = require("@oxyhq/core");
+/**
+ * A change of SUBJECT — the account the session acts as.
+ *
+ * `previous === null` is an initial sign-in (nothing account-scoped is cached
+ * yet); `next === null` is a sign-out; both non-null and different is a switch,
+ * the only case that must invalidate a warm cache.
+ */
+
+/**
+ * The three seams the runtime reads, declared STRUCTURALLY rather than as the
+ * concrete `OxyServices` / `SessionClient` / `SessionClientHost` types.
+ *
+ * The real classes satisfy them, so nothing changes at the call site — but a
+ * test can hand the runtime three plain objects instead of casting a stub
+ * through `unknown`, which is how a stub silently drifts from the interface it
+ * pretends to implement.
+ */
+
+/**
+ * The headless session runtime (ADR 0004).
+ *
+ * It owns the session facts and the ORDER in which they become visible. React
+ * is an adapter: the provider hands components this object and they subscribe
+ * with selectors, so an unrelated change (a locale, a dialog opening) cannot
+ * rebuild an auth consumer's view.
+ */
+
+const EMPTY_SESSIONS = [];
+function deriveStatus(facts) {
+  if (!facts.authResolved) {
+    return 'booting';
+  }
+  if (facts.account !== null) {
+    return 'authenticated';
+  }
+  return facts.error !== null ? 'error' : 'signed_out';
+}
+function deriveTokenStatus(facts) {
+  if (facts.hasAccessToken && facts.tokenReady) {
+    return 'ready';
+  }
+  if (facts.account !== null || facts.hasAccessToken) {
+    return 'refreshing';
+  }
+  return 'missing';
+}
+
+/**
+ * The actor behind the active context, resolved to a full `User`.
+ *
+ * Falls back to the subject: on a device with no directory, and on any
+ * non-delegated context, the two ARE the same person, and saying so is more
+ * useful than a `null` every caller would have to special-case.
+ */
+function derivePrincipal(activeContext, profiles, account) {
+  if (activeContext === null) {
+    return account;
+  }
+  return profiles.get(activeContext.actor.userId) ?? account;
+}
+function createOxyRuntime(config) {
+  const {
+    oxyServices,
+    sessionClient,
+    sessionClientHost,
+    identity,
+    onSubjectChange,
+    onDeviceEmpty,
+    onSessionsProjected,
+    onIdentityUnbound,
+    logger
+  } = config;
+  const facts = {
+    deviceState: null,
+    directory: null,
+    profiles: new Map(),
+    sessions: EMPTY_SESSIONS,
+    activeSessionId: null,
+    account: null,
+    pinnedAccountId: null,
+    isLoading: false,
+    error: null,
+    storageReady: false,
+    tokenReady: true,
+    hasAccessToken: Boolean(oxyServices.getAccessToken()),
+    authResolved: false,
+    switching: false
+  };
+  const listeners = new Set();
+  let snapshot = buildSnapshot();
+  /**
+   * Depth of the current transition. Nested mutations publish ONCE, at the
+   * outermost boundary — a projection that sets sessions, the active id and the
+   * account must not wake React three times with two of them half-applied.
+   */
+  let depth = 0;
+  let dirty = false;
+  /** The subject as it stood when the OUTERMOST transition opened. */
+  let subjectAtEntry = null;
+  function buildSnapshot() {
+    const activeContext = (0, _core.resolveActiveContext)(facts.directory);
+    return Object.freeze({
+      status: deriveStatus(facts),
+      device: facts.directory,
+      deviceState: facts.deviceState,
+      activeContext,
+      principal: derivePrincipal(activeContext, facts.profiles, facts.account),
+      account: facts.account,
+      tokenStatus: deriveTokenStatus(facts),
+      authResolved: facts.authResolved,
+      switching: facts.switching,
+      error: facts.error === null ? null : {
+        message: facts.error,
+        code: 'oxy_runtime_error'
+      },
+      sessions: facts.sessions,
+      activeSessionId: facts.activeSessionId,
+      isLoading: facts.isLoading,
+      storageReady: facts.storageReady,
+      hasAccessToken: facts.hasAccessToken,
+      tokenReady: facts.tokenReady
+    });
+  }
+  function notify() {
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch (error) {
+        logger('An OxyRuntime subscriber threw', error);
+      }
+    }
+  }
+
+  /**
+   * The ONE ordered transition. Every fact change goes through here, so the
+   * sequence ADR 0002 mandates holds for a local switch, a socket push, a cold
+   * boot and a cross-tab wake alike:
+   *
+   *   the bearer is already committed (SessionClient awaits its mint before it
+   *   calls us) → reset account-scoped caches → publish the snapshot → notify.
+   *
+   * Publishing before the reset would let a woken component read a cache entry
+   * belonging to the previous subject while holding the new subject's bearer,
+   * which is the account-switch race in its quietest form: no error, just the
+   * wrong person's data.
+   */
+  function transition(mutate) {
+    if (depth === 0) {
+      subjectAtEntry = facts.account?.id ?? null;
+    }
+    depth += 1;
+    try {
+      mutate();
+    } finally {
+      depth -= 1;
+    }
+    if (depth > 0) {
+      // A nested transition publishes nothing and fires no reset: the subject
+      // is compared once, at the outermost boundary, so a projection that
+      // touches the account twice cannot reset the caches twice.
+      return;
+    }
+    const nextSubject = facts.account?.id ?? null;
+    if (nextSubject !== subjectAtEntry) {
+      dirty = true;
+      onSubjectChange?.({
+        previous: subjectAtEntry,
+        next: nextSubject
+      });
+    }
+    if (!dirty) {
+      return;
+    }
+    dirty = false;
+    snapshot = buildSnapshot();
+    notify();
+  }
+
+  /** Mark the snapshot stale from inside a transition. */
+  function touch() {
+    dirty = true;
+  }
+  function setSessions(next) {
+    if ((0, _core.sessionsArraysEqual)(facts.sessions, next)) {
+      return;
+    }
+    facts.sessions = next;
+    touch();
+  }
+  function setActiveSessionIdFact(sessionId) {
+    if (facts.activeSessionId === sessionId) {
+      return;
+    }
+    facts.activeSessionId = sessionId;
+    touch();
+  }
+
+  /**
+   * The one place a `User` becomes THE subject — and the one place identity is
+   * normalised, so a profile arriving as `_id` from one lane and `id` from
+   * another can never produce two accounts that are the same person.
+   */
+  function setAccountFact(user) {
+    if (user === null) {
+      if (facts.account === null) {
+        return;
+      }
+      facts.account = null;
+      touch();
+      return;
+    }
+    if (facts.account === user) {
+      return;
+    }
+    facts.account = (0, _core.normalizeUserIdentity)(user);
+    touch();
+  }
+
+  // ── Projection ───────────────────────────────────────────────────────────
+
+  async function reconcileFromClient() {
+    const state = sessionClient.getState();
+    if (state === null) {
+      return;
+    }
+    if (state.accounts.length === 0) {
+      sessionClientHost.setCurrentAccountId(null);
+      await onDeviceEmpty();
+      return;
+    }
+    // Capture the revision this projection is for, then bail after the async
+    // profile fetch if a fresher state has landed — last-writer-wins, so two
+    // overlapping projections can never publish in the wrong order.
+    const capturedRevision = state.revision;
+    // Resolve the pin BEFORE the fetch (memoised: one storage + keychain read
+    // per boot) so the first pass over a freshly applied state is already bound.
+    // Deferring it would let a sibling app's switch render once as this
+    // client's user before the pin corrected it.
+    const pinnedAccountId = identity ? await identity.ensurePinnedAccountId() : null;
+    const ids = (0, _core.accountIdsOf)(state);
+    let users = [];
+    try {
+      users = ids.length > 0 ? await oxyServices.getUsersByIds(ids) : [];
+    } catch (fetchError) {
+      logger('Failed to resolve account profiles during the device projection', fetchError);
+      return;
+    }
+    const latest = sessionClient.getState();
+    if (!latest || latest.revision !== capturedRevision) {
+      return;
+    }
+    if (identity && (pinnedAccountId === null || (0, _core.activeSessionIdOf)(latest, pinnedAccountId) === null)) {
+      // Either no verified pin, or the pinned account left this device's session
+      // set. Leave the current projection untouched and re-derive from the key.
+      onIdentityUnbound?.(identity, latest.revision);
+      return;
+    }
+    const directory = sessionClient.getDirectory();
+    transition(() => {
+      facts.pinnedAccountId = pinnedAccountId;
+      if (facts.deviceState !== latest) {
+        facts.deviceState = latest;
+        touch();
+      }
+      if (facts.directory !== directory) {
+        facts.directory = directory;
+        touch();
+      }
+      for (const resolved of users) {
+        facts.profiles.set(resolved.id, resolved);
+      }
+      const projected = (0, _core.normalizeAndSortSessions)((0, _core.deviceStateToClientSessions)(latest, facts.profiles, pinnedAccountId), facts.activeSessionId, false);
+      setSessions(projected);
+      onSessionsProjected?.(projected.map(session => session.sessionId));
+      setActiveSessionIdFact((0, _core.activeSessionIdOf)(latest, pinnedAccountId));
+      const activeUser = (0, _core.activeUserOf)(latest, facts.profiles, pinnedAccountId);
+      if (activeUser) {
+        setAccountFact(activeUser);
+      }
+    });
+    // The host's current account feeds the socket handshake and the bearer's
+    // token-account comparisons, so it tracks the PIN — never the account
+    // another app switched the device to.
+    sessionClientHost.setCurrentAccountId(pinnedAccountId ?? latest.activeAccountId);
+  }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    start() {
+      return sessionClient.subscribe(() => {
+        void reconcileFromClient().catch(error => {
+          logger('Failed to project a device-state transition', error);
+        });
+      });
+    },
+    reconcileFromClient,
+    batch(mutate) {
+      transition(mutate);
+    },
+    async activateContext(contextId) {
+      // `switching` is published BEFORE the request so a switcher can disable
+      // its rows for the whole round trip, and cleared in `finally` so a
+      // refused activation does not strand it on.
+      this.setSwitching(true);
+      try {
+        await sessionClient.activateContext(contextId);
+        await reconcileFromClient();
+      } finally {
+        this.setSwitching(false);
+      }
+    },
+    async signOutContext(contextId) {
+      await sessionClient.signOutContext(contextId);
+      await reconcileFromClient();
+    },
+    async signOutPrincipal(principalId) {
+      await sessionClient.signOutPrincipal(principalId);
+      await reconcileFromClient();
+    },
+    async refreshDirectory() {
+      await sessionClient.refreshDirectory();
+      const directory = sessionClient.getDirectory();
+      transition(() => {
+        if (facts.directory === directory) {
+          return;
+        }
+        facts.directory = directory;
+        touch();
+      });
+    },
+    setAccount(user) {
+      transition(() => {
+        setAccountFact(user);
+        if (facts.isLoading) {
+          facts.isLoading = false;
+          touch();
+        }
+        if (facts.error !== null) {
+          facts.error = null;
+          touch();
+        }
+        facts.profiles.set(user.id, user);
+      });
+    },
+    setLoading(loading) {
+      transition(() => {
+        if (facts.isLoading === loading) return;
+        facts.isLoading = loading;
+        touch();
+      });
+    },
+    setError(error) {
+      transition(() => {
+        if (facts.error === error) return;
+        facts.error = error;
+        touch();
+      });
+    },
+    setStorageReady(ready) {
+      transition(() => {
+        if (facts.storageReady === ready) return;
+        facts.storageReady = ready;
+        touch();
+      });
+    },
+    setTokenReady(ready) {
+      transition(() => {
+        if (facts.tokenReady === ready) return;
+        facts.tokenReady = ready;
+        touch();
+      });
+    },
+    setHasAccessToken(has) {
+      transition(() => {
+        if (facts.hasAccessToken === has) return;
+        facts.hasAccessToken = has;
+        touch();
+      });
+    },
+    setSwitching(switching) {
+      transition(() => {
+        if (facts.switching === switching) return;
+        facts.switching = switching;
+        touch();
+      });
+    },
+    markAuthResolved() {
+      transition(() => {
+        if (facts.authResolved) return;
+        facts.authResolved = true;
+        facts.tokenReady = true;
+        touch();
+      });
+    },
+    mergeSessions(incoming, options = {}) {
+      transition(() => {
+        const processed = options.merge ? (0, _core.mergeSessions)(facts.sessions, incoming, facts.activeSessionId, false) : (0, _core.normalizeAndSortSessions)(incoming, facts.activeSessionId, false);
+        onSessionsProjected?.([...processed.map(session => session.sessionId), ...(options.preserveSessionIds ?? [])]);
+        setSessions(processed);
+      });
+    },
+    setActiveSessionId(sessionId) {
+      transition(() => {
+        setActiveSessionIdFact(sessionId);
+      });
+    },
+    clearSession() {
+      transition(() => {
+        setSessions(EMPTY_SESSIONS);
+        setActiveSessionIdFact(null);
+        setAccountFact(null);
+        facts.deviceState = null;
+        facts.directory = null;
+        facts.profiles = new Map();
+        facts.pinnedAccountId = null;
+        touch();
+      });
+    }
+  };
+}
+//# sourceMappingURL=createOxyRuntime.js.map

package/lib/commonjs/ui/runtime/createOxyRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_core","require","EMPTY_SESSIONS","deriveStatus","facts","authResolved","account","error","deriveTokenStatus","hasAccessToken","tokenReady","derivePrincipal","activeContext","profiles","get","actor","userId","createOxyRuntime","config","oxyServices","sessionClient","sessionClientHost","identity","onSubjectChange","onDeviceEmpty","onSessionsProjected","onIdentityUnbound","logger","deviceState","directory","Map","sessions","activeSessionId","pinnedAccountId","isLoading","storageReady","Boolean","getAccessToken","switching","listeners","Set","snapshot","buildSnapshot","depth","dirty","subjectAtEntry","resolveActiveContext","Object","freeze","status","device","principal","tokenStatus","message","code","notify","listener","transition","mutate","id","nextSubject","previous","next","touch","setSessions","sessionsArraysEqual","setActiveSessionIdFact","sessionId","setAccountFact","user","normalizeUserIdentity","reconcileFromClient","state","getState","accounts","length","setCurrentAccountId","capturedRevision","revision","ensurePinnedAccountId","ids","accountIdsOf","users","getUsersByIds","fetchError","latest","activeSessionIdOf","getDirectory","resolved","set","projected","normalizeAndSortSessions","deviceStateToClientSessions","map","session","activeUser","activeUserOf","activeAccountId","getSnapshot","subscribe","add","delete","start","catch","batch","activateContext","contextId","setSwitching","signOutContext","signOutPrincipal","principalId","refreshDirectory","setAccount","setLoading","loading","setError","setStorageReady","ready","setTokenReady","setHasAccessToken","has","markAuthResolved","mergeSessions","incoming","options","processed","merge","mergeSessionLists","preserveSessionIds","setActiveSessionId","clearSession"],"sourceRoot":"../../../../src","sources":["ui/runtime/createOxyRuntime.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/ui/runtime/index.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "OxyRuntimeHandleProvider", {
+  enumerable: true,
+  get: function () {
+    return _runtimeContext.OxyRuntimeHandleProvider;
+  }
+});
+Object.defineProperty(exports, "OxyRuntimeMissingError", {
+  enumerable: true,
+  get: function () {
+    return _runtimeContext.OxyRuntimeMissingError;
+  }
+});
+Object.defineProperty(exports, "createOxyRuntime", {
+  enumerable: true,
+  get: function () {
+    return _createOxyRuntime.createOxyRuntime;
+  }
+});
+Object.defineProperty(exports, "useActiveAccount", {
+  enumerable: true,
+  get: function () {
+    return _runtimeContext.useActiveAccount;
+  }
+});
+Object.defineProperty(exports, "useDeviceDirectory", {
+  enumerable: true,
+  get: function () {
+    return _runtimeContext.useDeviceDirectory;
+  }
+});
+Object.defineProperty(exports, "useOxyRuntime", {
+  enumerable: true,
+  get: function () {
+    return _runtimeContext.useOxyRuntime;
+  }
+});
+Object.defineProperty(exports, "useOxySnapshot", {
+  enumerable: true,
+  get: function () {
+    return _runtimeContext.useOxySnapshot;
+  }
+});
+Object.defineProperty(exports, "useRuntimeSelector", {
+  enumerable: true,
+  get: function () {
+    return _useRuntimeSnapshot.useRuntimeSelector;
+  }
+});
+Object.defineProperty(exports, "useRuntimeSnapshot", {
+  enumerable: true,
+  get: function () {
+    return _useRuntimeSnapshot.useRuntimeSnapshot;
+  }
+});
+var _createOxyRuntime = require("./createOxyRuntime.js");
+var _useRuntimeSnapshot = require("./useRuntimeSnapshot.js");
+var _runtimeContext = require("./runtimeContext.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/ui/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_createOxyRuntime","require","_useRuntimeSnapshot","_runtimeContext"],"sourceRoot":"../../../../src","sources":["ui/runtime/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,IAAAA,iBAAA,GAAAC,OAAA;AASA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA","ignoreList":[]}

package/lib/commonjs/ui/runtime/runtimeContext.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OxyRuntimeMissingError = exports.OxyRuntimeHandleProvider = void 0;
+exports.useActiveAccount = useActiveAccount;
+exports.useDeviceDirectory = useDeviceDirectory;
+exports.useOxyRuntime = useOxyRuntime;
+exports.useOxySnapshot = useOxySnapshot;
+var _react = require("react");
+var _useRuntimeSnapshot = require("./useRuntimeSnapshot.js");
+/**
+ * The runtime reference itself, as a context value that NEVER changes identity
+ * (ADR 0004).
+ *
+ * It is deliberately a second context beside the big `OxyContextState` one.
+ * That value is rebuilt whenever any of its fifty-odd members moves — a locale,
+ * a dialog opening — and every hook reading it re-renders with it. Hooks
+ * hanging off this one subscribe to the runtime with a selector instead, so
+ * only a change to what they actually selected wakes them. Retiring the wide
+ * context is Phase 8; this is what its replacements are built on.
+ */
+const OxyRuntimeHandleContext = /*#__PURE__*/(0, _react.createContext)(null);
+const OxyRuntimeHandleProvider = exports.OxyRuntimeHandleProvider = OxyRuntimeHandleContext.Provider;
+const RUNTIME_MISSING_MESSAGE = 'useOxyRuntime() was called outside <OxyProvider>. Mount <OxyProvider clientId="…"> above this component.';
+class OxyRuntimeMissingError extends Error {
+  code = 'oxy_runtime_missing';
+  constructor() {
+    super(RUNTIME_MISSING_MESSAGE);
+    this.name = 'OxyRuntimeMissingError';
+  }
+}
+
+/** The runtime this provider owns. THROWS when no `<OxyProvider>` is mounted. */
+exports.OxyRuntimeMissingError = OxyRuntimeMissingError;
+function useOxyRuntime() {
+  const runtime = (0, _react.useContext)(OxyRuntimeHandleContext);
+  if (runtime === null) {
+    throw new OxyRuntimeMissingError();
+  }
+  return runtime;
+}
+function selectActiveAccount(snapshot) {
+  return {
+    principal: snapshot.principal,
+    account: snapshot.account,
+    context: snapshot.activeContext,
+    isDelegated: snapshot.activeContext?.isDelegated ?? false,
+    status: snapshot.status
+  };
+}
+function activeAccountsEqual(a, b) {
+  return a.principal === b.principal && a.account === b.account && a.context === b.context && a.isDelegated === b.isDelegated && a.status === b.status;
+}
+
+/**
+ * Who this app is running as, with the actor and the subject kept apart.
+ *
+ * Unlike `useOxy()`, this re-renders only when one of those five facts moves —
+ * a locale change, a dialog opening or a session-list refresh does not reach it.
+ */
+function useActiveAccount() {
+  return (0, _useRuntimeSnapshot.useRuntimeSelector)(useOxyRuntime(), selectActiveAccount, activeAccountsEqual);
+}
+const selectDirectory = snapshot => snapshot.device;
+
+/**
+ * The device directory — every principal on this device and the contexts each
+ * may act as (ADR 0002).
+ *
+ * `null` until something calls `runtime.refreshDirectory()`. A client that
+ * never asks for one never pays for the round trip.
+ */
+function useDeviceDirectory() {
+  return (0, _useRuntimeSnapshot.useRuntimeSelector)(useOxyRuntime(), selectDirectory);
+}
+
+/** The whole runtime snapshot. Prefer a narrower hook where one exists. */
+function useOxySnapshot() {
+  return (0, _useRuntimeSnapshot.useRuntimeSnapshot)(useOxyRuntime());
+}
+//# sourceMappingURL=runtimeContext.js.map

package/lib/commonjs/ui/runtime/runtimeContext.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_useRuntimeSnapshot","OxyRuntimeHandleContext","createContext","OxyRuntimeHandleProvider","exports","Provider","RUNTIME_MISSING_MESSAGE","OxyRuntimeMissingError","Error","code","constructor","name","useOxyRuntime","runtime","useContext","selectActiveAccount","snapshot","principal","account","context","activeContext","isDelegated","status","activeAccountsEqual","a","b","useActiveAccount","useRuntimeSelector","selectDirectory","device","useDeviceDirectory","useOxySnapshot","useRuntimeSnapshot"],"sourceRoot":"../../../../src","sources":["ui/runtime/runtimeContext.tsx"],"mappings":";;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKA,IAAAC,mBAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAME,uBAAuB,gBAAG,IAAAC,oBAAa,EAAoB,IAAI,CAAC;AAE/D,MAAMC,wBAAwB,GAAAC,OAAA,CAAAD,wBAAA,GAAGF,uBAAuB,CAACI,QAAQ;AAExE,MAAMC,uBAAuB,GAC3B,0GAA0G;AAErG,MAAMC,sBAAsB,SAASC,KAAK,CAAC;EACvCC,IAAI,GAAG,qBAAqB;EAErCC,WAAWA,CAAA,EAAG;IACZ,KAAK,CAACJ,uBAAuB,CAAC;IAC9B,IAAI,CAACK,IAAI,GAAG,wBAAwB;EACtC;AACF;;AAEA;AAAAP,OAAA,CAAAG,sBAAA,GAAAA,sBAAA;AACO,SAASK,aAAaA,CAAA,EAAe;EAC1C,MAAMC,OAAO,GAAG,IAAAC,iBAAU,EAACb,uBAAuB,CAAC;EACnD,IAAIY,OAAO,KAAK,IAAI,EAAE;IACpB,MAAM,IAAIN,sBAAsB,CAAC,CAAC;EACpC;EACA,OAAOM,OAAO;AAChB;AAiBA,SAASE,mBAAmBA,CAACC,QAK5B,EAAiB;EAChB,OAAO;IACLC,SAAS,EAAED,QAAQ,CAACC,SAAS;IAC7BC,OAAO,EAAEF,QAAQ,CAACE,OAAO;IACzBC,OAAO,EAAEH,QAAQ,CAACI,aAAa;IAC/BC,WAAW,EAAEL,QAAQ,CAACI,aAAa,EAAEC,WAAW,IAAI,KAAK;IACzDC,MAAM,EAAEN,QAAQ,CAACM;EACnB,CAAC;AACH;AAEA,SAASC,mBAAmBA,CAACC,CAAgB,EAAEC,CAAgB,EAAW;EACxE,OACED,CAAC,CAACP,SAAS,KAAKQ,CAAC,CAACR,SAAS,IAC3BO,CAAC,CAACN,OAAO,KAAKO,CAAC,CAACP,OAAO,IACvBM,CAAC,CAACL,OAAO,KAAKM,CAAC,CAACN,OAAO,IACvBK,CAAC,CAACH,WAAW,KAAKI,CAAC,CAACJ,WAAW,IAC/BG,CAAC,CAACF,MAAM,KAAKG,CAAC,CAACH,MAAM;AAEzB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,gBAAgBA,CAAA,EAAkB;EAChD,OAAO,IAAAC,sCAAkB,EAACf,aAAa,CAAC,CAAC,EAAEG,mBAAmB,EAAEQ,mBAAmB,CAAC;AACtF;AAEA,MAAMK,eAAe,GAAIZ,QAA4C,IACnEA,QAAQ,CAACa,MAAM;;AAEjB;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,kBAAkBA,CAAA,EAA2B;EAC3D,OAAO,IAAAH,sCAAkB,EAACf,aAAa,CAAC,CAAC,EAAEgB,eAAe,CAAC;AAC7D;;AAEA;AACO,SAASG,cAAcA,CAAA,EAA0C;EACtE,OAAO,IAAAC,sCAAkB,EAACpB,aAAa,CAAC,CAAC,CAAC;AAC5C","ignoreList":[]}

package/lib/commonjs/ui/runtime/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/lib/commonjs/ui/runtime/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../../src","sources":["ui/runtime/types.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/ui/runtime/useRuntimeSnapshot.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRuntimeSelector = useRuntimeSelector;
+exports.useRuntimeSnapshot = useRuntimeSnapshot;
+var _react = require("react");
+/**
+ * Subscribe to the whole runtime snapshot.
+ *
+ * The runtime publishes a frozen object only when a fact actually changed, so
+ * identity comparison is exact: a locale change, a dialog opening or an
+ * unrelated query settling does not wake anything subscribed here.
+ */
+function useRuntimeSnapshot(runtime) {
+  return (0, _react.useSyncExternalStore)(runtime.subscribe, runtime.getSnapshot, runtime.getSnapshot);
+}
+
+/**
+ * Subscribe to one derived value of the runtime snapshot.
+ *
+ * The selection is cached against the snapshot it was computed from, which is
+ * what makes a selector returning a fresh object (`{user, isAuthenticated}`)
+ * safe here: `useSyncExternalStore` calls `getSnapshot` several times per
+ * commit and would otherwise see a new object every call and loop.
+ *
+ * `selector` must be stable — hoist it to module scope or wrap it in
+ * `useCallback`. An inline arrow re-subscribes on every render.
+ */
+function useRuntimeSelector(runtime, selector, isEqual) {
+  const cache = (0, _react.useRef)(null);
+  const getSelection = (0, _react.useCallback)(() => {
+    const snapshot = runtime.getSnapshot();
+    const cached = cache.current;
+    if (cached !== null && cached.snapshot === snapshot) {
+      return cached.value;
+    }
+    const value = selector(snapshot);
+    if (cached !== null && isEqual?.(cached.value, value) === true) {
+      // Same value under the caller's equality: keep the PREVIOUS reference so a
+      // structurally-equal recomputation does not read as a change.
+      cache.current = {
+        snapshot,
+        value: cached.value
+      };
+      return cached.value;
+    }
+    cache.current = {
+      snapshot,
+      value
+    };
+    return value;
+  }, [runtime, selector, isEqual]);
+  return (0, _react.useSyncExternalStore)(runtime.subscribe, getSelection, getSelection);
+}
+//# sourceMappingURL=useRuntimeSnapshot.js.map