@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/stores/container-contents/remoteWriteGuards.js

@@ -0,0 +1,54 @@
+import { findOrganizationSystemRootState, findSystemContainerStateForRoot, } from "./systemContainerLookup.js";
+import { isContainerInSubtree } from "./utils.js";
+const activeByState = new WeakMap();
+/** Invalidate remote settlement only when a local edit touches its subtree. */
+export function invalidateRemoteContainerWrites(state, changedIds, movedId) {
+    if (changedIds?.length === 0 && movedId === undefined)
+        return;
+    for (const write of activeByState.get(state) ?? []) {
+        let rootId;
+        if (typeof write.scope === "object") {
+            const root = state.containersById.get(write.scope.rootId);
+            if (root) {
+                rootId = (findSystemContainerStateForRoot(state, write.scope.systemSlot, root) ??
+                    findOrganizationSystemRootState(state, root.container.organizationId ||
+                        state.runtime.auth.organizationId ||
+                        "", write.scope.systemSlot))?.container.id;
+            }
+        }
+        else {
+            rootId = write.scope;
+        }
+        if (write.scope === undefined ||
+            changedIds === null ||
+            (rootId !== undefined &&
+                (changedIds.some((id) => isContainerInSubtree(state.containersById, id, rootId)) ||
+                    (movedId !== undefined &&
+                        isContainerInSubtree(state.containersById, rootId, movedId))))) {
+            write.changed = true;
+        }
+    }
+}
+export function trackRemoteContainerWrite(state, scope) {
+    const active = activeByState.get(state) ?? new Set();
+    activeByState.set(state, active);
+    const write = { changed: false, scope };
+    active.add(write);
+    return {
+        changed: () => write.changed,
+        dispose: () => {
+            active.delete(write);
+        },
+    };
+}
+/** An undiscovered system child has a stable slot before it has a local id. */
+export function invalidateRemoteSystemContainerWrite(state, rootId, systemSlot) {
+    for (const write of activeByState.get(state) ?? []) {
+        if (typeof write.scope === "object" &&
+            write.scope.rootId === rootId &&
+            write.scope.systemSlot === systemSlot) {
+            write.changed = true;
+        }
+    }
+}
+//# sourceMappingURL=remoteWriteGuards.js.map

package/stores/container-contents/remoteWriteGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteWriteGuards.js","sourceRoot":"","sources":["remoteWriteGuards.ts"],"names":[],"mappings":"AACA,OAAO,EACL,+BAA+B,EAC/B,+BAA+B,GAChC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAY/C,MAAM,aAAa,GAAG,IAAI,OAAO,EAG9B,CAAC;AAEJ,+EAA+E;AAC/E,MAAM,UAAU,+BAA+B,CAC7C,KAAkC,EAClC,UAAoC,EACpC,OAAgB;IAEhB,IAAI,UAAU,EAAE,MAAM,KAAK,CAAC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO;IAC9D,KAAK,MAAM,KAAK,IAAI,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;QACnD,IAAI,MAA0B,CAAC;QAC/B,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;YACpC,MAAM,IAAI,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC1D,IAAI,IAAI,EAAE,CAAC;gBACT,MAAM,GAAG,CACP,+BAA+B,CAC7B,KAAK,EACL,KAAK,CAAC,KAAK,CAAC,UAAU,EACtB,IAAI,CACL;oBACD,+BAA+B,CAC7B,KAAK,EACL,IAAI,CAAC,SAAS,CAAC,cAAc;wBAC3B,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc;wBACjC,EAAE,EACJ,KAAK,CAAC,KAAK,CAAC,UAAU,CACvB,CACF,EAAE,SAAS,CAAC,EAAE,CAAC;YAClB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC;QACvB,CAAC;QACD,IACE,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,UAAU,KAAK,IAAI;YACnB,CAAC,MAAM,KAAK,SAAS;gBACnB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CACtB,oBAAoB,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,EAAE,MAAM,CAAC,CACvD;oBACC,CAAC,OAAO,KAAK,SAAS;wBACpB,oBAAoB,CAAC,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,EACpE,CAAC;YACD,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;QACvB,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,KAAkC,EAClC,KAAiC;IAEjC,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,GAAG,EAAqB,CAAC;IACxE,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACjC,MAAM,KAAK,GAAsB,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAC3D,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClB,OAAO;QACL,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO;QAC5B,OAAO,EAAE,GAAG,EAAE;YACZ,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,oCAAoC,CAClD,KAAkC,EAClC,MAAc,EACd,UAA+B;IAE/B,KAAK,MAAM,KAAK,IAAI,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;QACnD,IACE,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;YAC/B,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,MAAM;YAC7B,KAAK,CAAC,KAAK,CAAC,UAAU,KAAK,UAAU,EACrC,CAAC;YACD,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;QACvB,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import type { ContainerSystemSlot } from \"@tearleads/validators/containerSystemSlot\";\nimport {\n  findOrganizationSystemRootState,\n  findSystemContainerStateForRoot,\n} from \"./systemContainerLookup\";\nimport type { ContainerContentsStoreState } from \"./types\";\nimport { isContainerInSubtree } from \"./utils\";\n\nexport type RemoteContainerWriteScope =\n  | string\n  | {\n      rootId: string;\n      systemSlot: ContainerSystemSlot;\n    };\ninterface ActiveRemoteWrite {\n  changed: boolean;\n  scope: RemoteContainerWriteScope | undefined;\n}\nconst activeByState = new WeakMap<\n  ContainerContentsStoreState,\n  Set<ActiveRemoteWrite>\n>();\n\n/** Invalidate remote settlement only when a local edit touches its subtree. */\nexport function invalidateRemoteContainerWrites(\n  state: ContainerContentsStoreState,\n  changedIds: readonly string[] | null,\n  movedId?: string,\n): void {\n  if (changedIds?.length === 0 && movedId === undefined) return;\n  for (const write of activeByState.get(state) ?? []) {\n    let rootId: string | undefined;\n    if (typeof write.scope === \"object\") {\n      const root = state.containersById.get(write.scope.rootId);\n      if (root) {\n        rootId = (\n          findSystemContainerStateForRoot(\n            state,\n            write.scope.systemSlot,\n            root,\n          ) ??\n          findOrganizationSystemRootState(\n            state,\n            root.container.organizationId ||\n              state.runtime.auth.organizationId ||\n              \"\",\n            write.scope.systemSlot,\n          )\n        )?.container.id;\n      }\n    } else {\n      rootId = write.scope;\n    }\n    if (\n      write.scope === undefined ||\n      changedIds === null ||\n      (rootId !== undefined &&\n        (changedIds.some((id) =>\n          isContainerInSubtree(state.containersById, id, rootId),\n        ) ||\n          (movedId !== undefined &&\n            isContainerInSubtree(state.containersById, rootId, movedId))))\n    ) {\n      write.changed = true;\n    }\n  }\n}\n\nexport function trackRemoteContainerWrite(\n  state: ContainerContentsStoreState,\n  scope?: RemoteContainerWriteScope,\n) {\n  const active = activeByState.get(state) ?? new Set<ActiveRemoteWrite>();\n  activeByState.set(state, active);\n  const write: ActiveRemoteWrite = { changed: false, scope };\n  active.add(write);\n  return {\n    changed: () => write.changed,\n    dispose: () => {\n      active.delete(write);\n    },\n  };\n}\n\n/** An undiscovered system child has a stable slot before it has a local id. */\nexport function invalidateRemoteSystemContainerWrite(\n  state: ContainerContentsStoreState,\n  rootId: string,\n  systemSlot: ContainerSystemSlot,\n): void {\n  for (const write of activeByState.get(state) ?? []) {\n    if (\n      typeof write.scope === \"object\" &&\n      write.scope.rootId === rootId &&\n      write.scope.systemSlot === systemSlot\n    ) {\n      write.changed = true;\n    }\n  }\n}\n"]}

package/stores/container-contents/remoteWriteQueue.js

@@ -0,0 +1,51 @@
+import { errorMessage } from "../../data/errorMessage.js";
+import { trackRemoteContainerWrite, } from "./remoteWriteGuards.js";
+import { captureContainerWriteGeneration } from "./writeGeneration.js";
+const remoteWritesByState = new WeakMap();
+/** Online operations serialize together; local writes never wait for their I/O. */
+export function chainRemoteContainerTask(state, syncAgent, staleResult, work, scope, options = {}) {
+    const contextCurrent = captureContainerWriteGeneration(state);
+    const previous = remoteWritesByState.get(state);
+    const tail = previous?.current() ? previous.tail : Promise.resolve();
+    const task = tail.then(async () => {
+        if (!contextCurrent())
+            return staleResult;
+        // Install the guard at one local queue boundary. New writes can proceed
+        // immediately afterward; an ongoing stream cannot starve the remote task.
+        const boundary = state.writeChain
+            .catch(() => null)
+            .then(() => trackRemoteContainerWrite(state, scope));
+        state.writeChain = boundary.then(() => null);
+        const tracked = await boundary;
+        const isCurrent = () => contextCurrent() && !tracked.changed();
+        try {
+            if (!isCurrent())
+                return staleResult;
+            const result = await work(isCurrent);
+            // Only completed operations opt in. A replaced runtime always cancels.
+            return contextCurrent() &&
+                (!tracked.changed() || options.preserveResultOnLocalWrite)
+                ? result
+                : staleResult;
+        }
+        finally {
+            tracked.dispose();
+            if (contextCurrent() && tracked.changed()) {
+                // The HTTP side may have committed before a new local write invalidated
+                // this operation. Reconcile its authoritative result without allowing
+                // the older operation to install state over the user's newer write.
+                state.localContainersNeedRefresh = true;
+                void syncAgent.refreshLocalContainers().catch((error) => {
+                    state.runtime.util.log(`Container contents: local refresh failed (${errorMessage(error)})`);
+                });
+                syncAgent.scheduleRemoteHydration();
+            }
+        }
+    });
+    remoteWritesByState.set(state, {
+        current: contextCurrent,
+        tail: task.then(() => undefined, () => undefined),
+    });
+    return task;
+}
+//# sourceMappingURL=remoteWriteQueue.js.map

package/stores/container-contents/remoteWriteQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteWriteQueue.js","sourceRoot":"","sources":["remoteWriteQueue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAEL,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AAEpE,MAAM,mBAAmB,GAAG,IAAI,OAAO,EAGpC,CAAC;AAEJ,mFAAmF;AACnF,MAAM,UAAU,wBAAwB,CACtC,KAAkC,EAClC,SAGC,EACD,WAAc,EACd,IAA8C,EAC9C,KAAiC,EACjC,UAAoD,EAAE;IAEtD,MAAM,cAAc,GAAG,+BAA+B,CAAC,KAAK,CAAC,CAAC;IAC9D,MAAM,QAAQ,GAAG,mBAAmB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,IAAI,GAAG,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IACrE,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;QAChC,IAAI,CAAC,cAAc,EAAE;YAAE,OAAO,WAAW,CAAC;QAC1C,wEAAwE;QACxE,0EAA0E;QAC1E,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU;aAC9B,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;aACjB,IAAI,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QACvD,KAAK,CAAC,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC;QAC/B,MAAM,SAAS,GAAG,GAAG,EAAE,CAAC,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QAC/D,IAAI,CAAC;YACH,IAAI,CAAC,SAAS,EAAE;gBAAE,OAAO,WAAW,CAAC;YACrC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,CAAC;YACrC,uEAAuE;YACvE,OAAO,cAAc,EAAE;gBACrB,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,OAAO,CAAC,0BAA0B,CAAC;gBAC1D,CAAC,CAAC,MAAM;gBACR,CAAC,CAAC,WAAW,CAAC;QAClB,CAAC;gBAAS,CAAC;YACT,OAAO,CAAC,OAAO,EAAE,CAAC;YAClB,IAAI,cAAc,EAAE,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;gBAC1C,wEAAwE;gBACxE,sEAAsE;gBACtE,oEAAoE;gBACpE,KAAK,CAAC,0BAA0B,GAAG,IAAI,CAAC;gBACxC,KAAK,SAAS,CAAC,sBAAsB,EAAE,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;oBAC/D,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,6CAA6C,YAAY,CAAC,KAAK,CAAC,GAAG,CACpE,CAAC;gBACJ,CAAC,CAAC,CAAC;gBACH,SAAS,CAAC,uBAAuB,EAAE,CAAC;YACtC,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IACH,mBAAmB,CAAC,GAAG,CAAC,KAAK,EAAE;QAC7B,OAAO,EAAE,cAAc;QACvB,IAAI,EAAE,IAAI,CAAC,IAAI,CACb,GAAG,EAAE,CAAC,SAAS,EACf,GAAG,EAAE,CAAC,SAAS,CAChB;KACF,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["import { errorMessage } from \"../../data/errorMessage\";\nimport {\n  type RemoteContainerWriteScope,\n  trackRemoteContainerWrite,\n} from \"./remoteWriteGuards\";\nimport type { ContainerContentsStoreSyncAgent } from \"./syncAgent\";\nimport type { ContainerContentsStoreState } from \"./types\";\nimport { captureContainerWriteGeneration } from \"./writeGeneration\";\n\nconst remoteWritesByState = new WeakMap<\n  ContainerContentsStoreState,\n  { current: () => boolean; tail: Promise<void> }\n>();\n\n/** Online operations serialize together; local writes never wait for their I/O. */\nexport function chainRemoteContainerTask<T>(\n  state: ContainerContentsStoreState,\n  syncAgent: Pick<\n    ContainerContentsStoreSyncAgent,\n    \"refreshLocalContainers\" | \"scheduleRemoteHydration\"\n  >,\n  staleResult: T,\n  work: (isCurrent: () => boolean) => Promise<T>,\n  scope?: RemoteContainerWriteScope,\n  options: { preserveResultOnLocalWrite?: boolean } = {},\n): Promise<T> {\n  const contextCurrent = captureContainerWriteGeneration(state);\n  const previous = remoteWritesByState.get(state);\n  const tail = previous?.current() ? previous.tail : Promise.resolve();\n  const task = tail.then(async () => {\n    if (!contextCurrent()) return staleResult;\n    // Install the guard at one local queue boundary. New writes can proceed\n    // immediately afterward; an ongoing stream cannot starve the remote task.\n    const boundary = state.writeChain\n      .catch(() => null)\n      .then(() => trackRemoteContainerWrite(state, scope));\n    state.writeChain = boundary.then(() => null);\n    const tracked = await boundary;\n    const isCurrent = () => contextCurrent() && !tracked.changed();\n    try {\n      if (!isCurrent()) return staleResult;\n      const result = await work(isCurrent);\n      // Only completed operations opt in. A replaced runtime always cancels.\n      return contextCurrent() &&\n        (!tracked.changed() || options.preserveResultOnLocalWrite)\n        ? result\n        : staleResult;\n    } finally {\n      tracked.dispose();\n      if (contextCurrent() && tracked.changed()) {\n        // The HTTP side may have committed before a new local write invalidated\n        // this operation. Reconcile its authoritative result without allowing\n        // the older operation to install state over the user's newer write.\n        state.localContainersNeedRefresh = true;\n        void syncAgent.refreshLocalContainers().catch((error: unknown) => {\n          state.runtime.util.log(\n            `Container contents: local refresh failed (${errorMessage(error)})`,\n          );\n        });\n        syncAgent.scheduleRemoteHydration();\n      }\n    }\n  });\n  remoteWritesByState.set(state, {\n    current: contextCurrent,\n    tail: task.then(\n      () => undefined,\n      () => undefined,\n    ),\n  });\n  return task;\n}\n"]}

package/stores/container-contents/reportShareFailure.js

@@ -0,0 +1,44 @@
+import { isKeyingVerificationError } from "../../data/keyingProjectionVerification/error.js";
+import { isProjectionVerificationCancelledError } from "../../workflows/containers/index.js";
+import { isDatabaseUnavailableError } from "../../workflows/documents/index.js";
+import { getContainerContentsStoreLogLabel } from "./logLabel.js";
+// Both host callbacks are declared `=> void` but may be async (see
+// Tearleads.logError), and this runs from a catch that rethrows to the caller,
+// where a throwing logger would replace the share failure with its own.
+function dispatchToHost(call) {
+    try {
+        void Promise.resolve(call()).catch(() => undefined);
+    }
+    catch {
+        // Hosts may throw synchronously or return a rejected promise.
+    }
+}
+/**
+ * Report a thrown container share through the host's diagnostics before the
+ * failure propagates to the UI. The app can only show a generic label, so this
+ * is the one place the actual failure — a persistence error or an invariant
+ * throw — is observable off the device.
+ * Purely observational: the error is always rethrown by the caller unchanged.
+ */
+export function reportContainerShareFailure(state, operation, error) {
+    const message = `${getContainerContentsStoreLogLabel(state)}: ${operation} failed`;
+    // Not an app failure, so it stays local: the runtime is released under
+    // in-flight callers on every identity switch and host-driven database retry,
+    // a projection verification cancelled by a newer generation re-runs on its
+    // own, and a keying verification refusal (a rollback or a relabeled group,
+    // which a duplicate grant can race into) belongs to the security-incident
+    // path rather than app diagnostics.
+    if (isDatabaseUnavailableError(error) ||
+        isProjectionVerificationCancelledError(error) ||
+        isKeyingVerificationError(error)) {
+        dispatchToHost(() => state.runtime.util.log(message));
+        return;
+    }
+    const { logError } = state.runtime.util;
+    if (!logError) {
+        dispatchToHost(() => state.runtime.util.log(message));
+        return;
+    }
+    dispatchToHost(() => logError(message, error));
+}
+//# sourceMappingURL=reportShareFailure.js.map

package/stores/container-contents/reportShareFailure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportShareFailure.js","sourceRoot":"","sources":["reportShareFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EAAE,sCAAsC,EAAE,MAAM,4BAA4B,CAAC;AACpF,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,iCAAiC,EAAE,MAAM,YAAY,CAAC;AAG/D,mEAAmE;AACnE,+EAA+E;AAC/E,wEAAwE;AACxE,SAAS,cAAc,CAAC,IAAmB;IACzC,IAAI,CAAC;QACH,KAAK,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,8DAA8D;IAChE,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CACzC,KAAkC,EAClC,SAAiB,EACjB,KAAc;IAEd,MAAM,OAAO,GAAG,GAAG,iCAAiC,CAAC,KAAK,CAAC,KAAK,SAAS,SAAS,CAAC;IACnF,uEAAuE;IACvE,6EAA6E;IAC7E,2EAA2E;IAC3E,2EAA2E;IAC3E,0EAA0E;IAC1E,oCAAoC;IACpC,IACE,0BAA0B,CAAC,KAAK,CAAC;QACjC,sCAAsC,CAAC,KAAK,CAAC;QAC7C,yBAAyB,CAAC,KAAK,CAAC,EAChC,CAAC;QACD,cAAc,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QACtD,OAAO;IACT,CAAC;IAED,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;IACxC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,cAAc,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QACtD,OAAO;IACT,CAAC;IAED,cAAc,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;AACjD,CAAC","sourcesContent":["import { isKeyingVerificationError } from \"../../data/keyingProjectionVerification/error\";\nimport { isProjectionVerificationCancelledError } from \"../../workflows/containers\";\nimport { isDatabaseUnavailableError } from \"../../workflows/documents\";\nimport { getContainerContentsStoreLogLabel } from \"./logLabel\";\nimport type { ContainerContentsStoreState } from \"./types\";\n\n// Both host callbacks are declared `=> void` but may be async (see\n// Tearleads.logError), and this runs from a catch that rethrows to the caller,\n// where a throwing logger would replace the share failure with its own.\nfunction dispatchToHost(call: () => unknown): void {\n  try {\n    void Promise.resolve(call()).catch(() => undefined);\n  } catch {\n    // Hosts may throw synchronously or return a rejected promise.\n  }\n}\n\n/**\n * Report a thrown container share through the host's diagnostics before the\n * failure propagates to the UI. The app can only show a generic label, so this\n * is the one place the actual failure — a persistence error or an invariant\n * throw — is observable off the device.\n * Purely observational: the error is always rethrown by the caller unchanged.\n */\nexport function reportContainerShareFailure(\n  state: ContainerContentsStoreState,\n  operation: string,\n  error: unknown,\n): void {\n  const message = `${getContainerContentsStoreLogLabel(state)}: ${operation} failed`;\n  // Not an app failure, so it stays local: the runtime is released under\n  // in-flight callers on every identity switch and host-driven database retry,\n  // a projection verification cancelled by a newer generation re-runs on its\n  // own, and a keying verification refusal (a rollback or a relabeled group,\n  // which a duplicate grant can race into) belongs to the security-incident\n  // path rather than app diagnostics.\n  if (\n    isDatabaseUnavailableError(error) ||\n    isProjectionVerificationCancelledError(error) ||\n    isKeyingVerificationError(error)\n  ) {\n    dispatchToHost(() => state.runtime.util.log(message));\n    return;\n  }\n\n  const { logError } = state.runtime.util;\n  if (!logError) {\n    dispatchToHost(() => state.runtime.util.log(message));\n    return;\n  }\n\n  dispatchToHost(() => logError(message, error));\n}\n"]}

package/stores/container-contents/setContainerIconOperation.js

@@ -0,0 +1,47 @@
+import { installContainerMetadataRecord, setContainerIconMetadataStateFromRuntime, } from "../../workflows/container-contents/metadata.js";
+import { createDetachedContainerMetadataState, installDetachedContainerMetadataState, } from "../../workflows/container-contents/metadataStateIsolation.js";
+import { getContainerContentsStoreLogLabel } from "./logLabel.js";
+import { removeMissingContainerState } from "./missingContainerState.js";
+import { updateContainerContentsSnapshot } from "./state.js";
+import { toContainerNode } from "./utils.js";
+// Set the icon shown for a container. Mirrors renameContainer's write path: it
+// writes the icon into the container metadata document (CRDT), enqueues the
+// incremental update, persists, and schedules a sync. A null icon clears the
+// custom icon back to the default folder. No-ops when the icon is unchanged.
+export async function setContainerIcon(state, syncAgent, containerId, icon, isCurrent = () => true) {
+    if (state.runtime.infra.dbStatus !== "ready" || !state.snapshot.ready) {
+        return null;
+    }
+    const existingState = state.containersById.get(containerId);
+    if (!existingState) {
+        return null;
+    }
+    const normalizedIcon = icon?.trim() || null;
+    if ((existingState.container.icon ?? null) === normalizedIcon) {
+        return toContainerNode(existingState);
+    }
+    const detachedState = await createDetachedContainerMetadataState(existingState);
+    if (!isCurrent())
+        return null;
+    const updated = await setContainerIconMetadataStateFromRuntime({
+        icon: normalizedIcon,
+        metadataState: detachedState,
+        persistence: state.persistence,
+        runtime: state.runtime,
+        stillCurrent: isCurrent,
+    });
+    if (!isCurrent())
+        return null;
+    if (!updated) {
+        removeMissingContainerState(state, existingState);
+        return null;
+    }
+    detachedState.container = updated.container;
+    installContainerMetadataRecord(detachedState, updated.record);
+    installDetachedContainerMetadataState(existingState, detachedState);
+    updateContainerContentsSnapshot(state);
+    syncAgent.scheduleSync();
+    state.runtime.util.log(`${getContainerContentsStoreLogLabel(state)}: set container ${containerId} icon to "${normalizedIcon ?? "folder"}"`);
+    return toContainerNode(existingState);
+}
+//# sourceMappingURL=setContainerIconOperation.js.map

package/stores/container-contents/setContainerIconOperation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setContainerIconOperation.js","sourceRoot":"","sources":["setContainerIconOperation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,wCAAwC,GACzC,MAAM,6CAA6C,CAAC;AACrD,OAAO,EACL,oCAAoC,EACpC,qCAAqC,GACtC,MAAM,2DAA2D,CAAC;AACnE,OAAO,EAAE,iCAAiC,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAC;AAG1D,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C,+EAA+E;AAC/E,4EAA4E;AAC5E,6EAA6E;AAC7E,6EAA6E;AAC7E,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,KAAkC,EAClC,SAA0C,EAC1C,WAAmB,EACnB,IAAmB,EACnB,YAAiC,GAAG,EAAE,CAAC,IAAI;IAE3C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC5D,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC;IAC5C,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,cAAc,EAAE,CAAC;QAC9D,OAAO,eAAe,CAAC,aAAa,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,aAAa,GACjB,MAAM,oCAAoC,CAAC,aAAa,CAAC,CAAC;IAC5D,IAAI,CAAC,SAAS,EAAE;QAAE,OAAO,IAAI,CAAC;IAC9B,MAAM,OAAO,GAAG,MAAM,wCAAwC,CAAC;QAC7D,IAAI,EAAE,cAAc;QACpB,aAAa,EAAE,aAAa;QAC5B,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,YAAY,EAAE,SAAS;KACxB,CAAC,CAAC;IACH,IAAI,CAAC,SAAS,EAAE;QAAE,OAAO,IAAI,CAAC;IAC9B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,2BAA2B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,aAAa,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IAC5C,8BAA8B,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9D,qCAAqC,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACpE,+BAA+B,CAAC,KAAK,CAAC,CAAC;IACvC,SAAS,CAAC,YAAY,EAAE,CAAC;IACzB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,GAAG,iCAAiC,CAAC,KAAK,CAAC,mBAAmB,WAAW,aAAa,cAAc,IAAI,QAAQ,GAAG,CACpH,CAAC;IACF,OAAO,eAAe,CAAC,aAAa,CAAC,CAAC;AACxC,CAAC","sourcesContent":["import {\n  installContainerMetadataRecord,\n  setContainerIconMetadataStateFromRuntime,\n} from \"../../workflows/container-contents/metadata\";\nimport {\n  createDetachedContainerMetadataState,\n  installDetachedContainerMetadataState,\n} from \"../../workflows/container-contents/metadataStateIsolation\";\nimport { getContainerContentsStoreLogLabel } from \"./logLabel\";\nimport { removeMissingContainerState } from \"./missingContainerState\";\nimport { updateContainerContentsSnapshot } from \"./state\";\nimport type { ContainerContentsStoreSyncAgent } from \"./syncAgent\";\nimport type { ContainerContentsStoreState } from \"./types\";\nimport { toContainerNode } from \"./utils\";\nimport type { ContainerWriteGuard } from \"./writeGeneration\";\n\n// Set the icon shown for a container. Mirrors renameContainer's write path: it\n// writes the icon into the container metadata document (CRDT), enqueues the\n// incremental update, persists, and schedules a sync. A null icon clears the\n// custom icon back to the default folder. No-ops when the icon is unchanged.\nexport async function setContainerIcon(\n  state: ContainerContentsStoreState,\n  syncAgent: ContainerContentsStoreSyncAgent,\n  containerId: string,\n  icon: string | null,\n  isCurrent: ContainerWriteGuard = () => true,\n) {\n  if (state.runtime.infra.dbStatus !== \"ready\" || !state.snapshot.ready) {\n    return null;\n  }\n\n  const existingState = state.containersById.get(containerId);\n  if (!existingState) {\n    return null;\n  }\n\n  const normalizedIcon = icon?.trim() || null;\n  if ((existingState.container.icon ?? null) === normalizedIcon) {\n    return toContainerNode(existingState);\n  }\n\n  const detachedState =\n    await createDetachedContainerMetadataState(existingState);\n  if (!isCurrent()) return null;\n  const updated = await setContainerIconMetadataStateFromRuntime({\n    icon: normalizedIcon,\n    metadataState: detachedState,\n    persistence: state.persistence,\n    runtime: state.runtime,\n    stillCurrent: isCurrent,\n  });\n  if (!isCurrent()) return null;\n  if (!updated) {\n    removeMissingContainerState(state, existingState);\n    return null;\n  }\n\n  detachedState.container = updated.container;\n  installContainerMetadataRecord(detachedState, updated.record);\n  installDetachedContainerMetadataState(existingState, detachedState);\n  updateContainerContentsSnapshot(state);\n  syncAgent.scheduleSync();\n  state.runtime.util.log(\n    `${getContainerContentsStoreLogLabel(state)}: set container ${containerId} icon to \"${normalizedIcon ?? \"folder\"}\"`,\n  );\n  return toContainerNode(existingState);\n}\n"]}

package/stores/container-contents/shareOperations.js

@@ -0,0 +1,90 @@
+import { runWithSecurityIncidentReporting } from "../../data/keyingProjectionVerification/error.js";
+import { shareContainerState, shareContainerStateWithGroup, } from "../../workflows/container-contents/container-state/share.js";
+import { installContainerMetadataRecord } from "../../workflows/container-contents/metadata.js";
+import { getContainerContentsStoreLogLabel } from "./logLabel.js";
+import { removeMissingContainerState } from "./missingContainerState.js";
+import { reportContainerShareFailure } from "./reportShareFailure.js";
+import { updateContainerContentsSnapshot } from "./state.js";
+export async function shareContainerUsing(state, syncAgent, containerId, share, logMessage, isCurrent = () => true) {
+    if (state.runtime.infra.dbStatus !== "ready" ||
+        !state.snapshot.ready ||
+        !state.runtime.auth.isAuthenticated ||
+        !state.runtime.state.online ||
+        !isCurrent()) {
+        return false;
+    }
+    const existingState = state.containersById.get(containerId);
+    const expectedAccessStateHash = existingState?.record.accessStateHash;
+    if (!existingState?.record.documentId ||
+        typeof expectedAccessStateHash !== "string" ||
+        expectedAccessStateHash.length === 0) {
+        return false;
+    }
+    let shared;
+    try {
+        shared = await share(existingState);
+    }
+    catch (error) {
+        reportContainerShareFailure(state, "share", error);
+        throw error;
+    }
+    if (!shared || !isCurrent() || shared.status === "confirmed") {
+        if (!isCurrent() || shared?.status === "confirmed") {
+            state.localContainersNeedRefresh = true;
+            state.containerParentIdsNeedingHydration.add(existingState.container.parentId);
+            void syncAgent.refreshLocalContainers();
+            syncAgent.scheduleRemoteHydration();
+        }
+        return shared?.status === "confirmed" || shared?.status === "persisted";
+    }
+    if (shared.status === "missing") {
+        removeMissingContainerState(state, existingState);
+        return false;
+    }
+    existingState.container = shared.container;
+    installContainerMetadataRecord(existingState, shared.record);
+    updateContainerContentsSnapshot(state);
+    if (shared.status === "identity-superseded")
+        return false;
+    await syncAgent.primeDocumentsForSharedSubtree(containerId, isCurrent);
+    if (!isCurrent())
+        return true;
+    syncAgent.scheduleSync();
+    state.runtime.util.log(`${getContainerContentsStoreLogLabel(state)}: ${logMessage}`);
+    return true;
+}
+export async function shareContainerWithUser(state, syncAgent, containerId, userId, isCurrent = () => true) {
+    return shareContainerUsing(state, syncAgent, containerId, (containerState) => shareContainerState({
+        accessLevel: "write",
+        containerState,
+        persistence: state.persistence,
+        recipientUserId: userId,
+        resolveProjectionUserKey: state.resolveProjectionUserKey,
+        runtime: state.runtime,
+        stillCurrent: isCurrent,
+    }), `shared container ${containerId} with ${userId}`, isCurrent);
+}
+export async function shareContainerWithGroup(state, syncAgent, containerId, groupId, accessLevel, options = {}, isCurrent = () => true) {
+    return shareContainerUsing(state, syncAgent, containerId, (containerState) => 
+    // A group share is where a relabeled directory row would misdirect a
+    // key wrap, so its verification failures (the signed-name mismatch
+    // above all) are recorded as security incidents, not just surfaced.
+    runWithSecurityIncidentReporting(state.runtime.util.reportSecurityIncident, {
+        objectId: containerId,
+        objectKind: "container",
+        operation: "container.share.group",
+        organizationId: containerState.container.organizationId,
+    }, () => shareContainerStateWithGroup({
+        accessLevel,
+        containerState,
+        expectedGroupName: options.expectedGroupName,
+        knownContainerKeks: options.knownContainerKeks,
+        persistence: state.persistence,
+        recipientGroupId: groupId,
+        requireExistingGrant: options.requireExistingGrant,
+        resolveProjectionUserKey: state.resolveProjectionUserKey,
+        runtime: state.runtime,
+        stillCurrent: isCurrent,
+    })), `shared container ${containerId} with group ${groupId}`, isCurrent);
+}
+//# sourceMappingURL=shareOperations.js.map

package/stores/container-contents/shareOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shareOperations.js","sourceRoot":"","sources":["shareOperations.ts"],"names":[],"mappings":"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","sourcesContent":["import { runWithSecurityIncidentReporting } from \"../../data/keyingProjectionVerification/error\";\nimport {\n  shareContainerState,\n  shareContainerStateWithGroup,\n} from \"../../workflows/container-contents/container-state/share\";\nimport type { SharedContainerStateResult } from \"../../workflows/container-contents/container-state/types\";\nimport { installContainerMetadataRecord } from \"../../workflows/container-contents/metadata\";\nimport { getContainerContentsStoreLogLabel } from \"./logLabel\";\nimport { removeMissingContainerState } from \"./missingContainerState\";\nimport { reportContainerShareFailure } from \"./reportShareFailure\";\nimport { updateContainerContentsSnapshot } from \"./state\";\nimport type {\n  ContainerContentsStoreSyncAgent,\n  ContainerState,\n} from \"./syncAgent\";\nimport type {\n  ContainerContentsShareAccessLevel,\n  ContainerContentsStoreState,\n} from \"./types\";\nimport type { ContainerWriteGuard } from \"./writeGeneration\";\n\nexport async function shareContainerUsing(\n  state: ContainerContentsStoreState,\n  syncAgent: ContainerContentsStoreSyncAgent,\n  containerId: string,\n  share: (\n    containerState: ContainerState,\n  ) => Promise<SharedContainerStateResult | null>,\n  logMessage: string,\n  isCurrent: ContainerWriteGuard = () => true,\n) {\n  if (\n    state.runtime.infra.dbStatus !== \"ready\" ||\n    !state.snapshot.ready ||\n    !state.runtime.auth.isAuthenticated ||\n    !state.runtime.state.online ||\n    !isCurrent()\n  ) {\n    return false;\n  }\n\n  const existingState = state.containersById.get(containerId);\n  const expectedAccessStateHash = existingState?.record.accessStateHash;\n  if (\n    !existingState?.record.documentId ||\n    typeof expectedAccessStateHash !== \"string\" ||\n    expectedAccessStateHash.length === 0\n  ) {\n    return false;\n  }\n\n  let shared: SharedContainerStateResult | null;\n  try {\n    shared = await share(existingState);\n  } catch (error) {\n    reportContainerShareFailure(state, \"share\", error);\n    throw error;\n  }\n  if (!shared || !isCurrent() || shared.status === \"confirmed\") {\n    if (!isCurrent() || shared?.status === \"confirmed\") {\n      state.localContainersNeedRefresh = true;\n      state.containerParentIdsNeedingHydration.add(\n        existingState.container.parentId,\n      );\n      void syncAgent.refreshLocalContainers();\n      syncAgent.scheduleRemoteHydration();\n    }\n    return shared?.status === \"confirmed\" || shared?.status === \"persisted\";\n  }\n  if (shared.status === \"missing\") {\n    removeMissingContainerState(state, existingState);\n    return false;\n  }\n\n  existingState.container = shared.container;\n  installContainerMetadataRecord(existingState, shared.record);\n  updateContainerContentsSnapshot(state);\n  if (shared.status === \"identity-superseded\") return false;\n\n  await syncAgent.primeDocumentsForSharedSubtree(containerId, isCurrent);\n  if (!isCurrent()) return true;\n  syncAgent.scheduleSync();\n  state.runtime.util.log(\n    `${getContainerContentsStoreLogLabel(state)}: ${logMessage}`,\n  );\n  return true;\n}\n\nexport async function shareContainerWithUser(\n  state: ContainerContentsStoreState,\n  syncAgent: ContainerContentsStoreSyncAgent,\n  containerId: string,\n  userId: string,\n  isCurrent: ContainerWriteGuard = () => true,\n) {\n  return shareContainerUsing(\n    state,\n    syncAgent,\n    containerId,\n    (containerState) =>\n      shareContainerState({\n        accessLevel: \"write\",\n        containerState,\n        persistence: state.persistence,\n        recipientUserId: userId,\n        resolveProjectionUserKey: state.resolveProjectionUserKey,\n        runtime: state.runtime,\n        stillCurrent: isCurrent,\n      }),\n    `shared container ${containerId} with ${userId}`,\n    isCurrent,\n  );\n}\n\nexport async function shareContainerWithGroup(\n  state: ContainerContentsStoreState,\n  syncAgent: ContainerContentsStoreSyncAgent,\n  containerId: string,\n  groupId: string,\n  accessLevel: ContainerContentsShareAccessLevel,\n  options: {\n    expectedGroupName?: string | undefined;\n    knownContainerKeks?: ReadonlyMap<string, Uint8Array> | undefined;\n    requireExistingGrant?: boolean | undefined;\n  } = {},\n  isCurrent: ContainerWriteGuard = () => true,\n) {\n  return shareContainerUsing(\n    state,\n    syncAgent,\n    containerId,\n    (containerState) =>\n      // A group share is where a relabeled directory row would misdirect a\n      // key wrap, so its verification failures (the signed-name mismatch\n      // above all) are recorded as security incidents, not just surfaced.\n      runWithSecurityIncidentReporting(\n        state.runtime.util.reportSecurityIncident,\n        {\n          objectId: containerId,\n          objectKind: \"container\",\n          operation: \"container.share.group\",\n          organizationId: containerState.container.organizationId,\n        },\n        () =>\n          shareContainerStateWithGroup({\n            accessLevel,\n            containerState,\n            expectedGroupName: options.expectedGroupName,\n            knownContainerKeks: options.knownContainerKeks,\n            persistence: state.persistence,\n            recipientGroupId: groupId,\n            requireExistingGrant: options.requireExistingGrant,\n            resolveProjectionUserKey: state.resolveProjectionUserKey,\n            runtime: state.runtime,\n            stillCurrent: isCurrent,\n          }),\n      ),\n    `shared container ${containerId} with group ${groupId}`,\n    isCurrent,\n  );\n}\n"]}

package/stores/container-contents/startupHydration.js

@@ -0,0 +1,110 @@
+import { createContainerParentSyncLane, loadContainerSyncLaneCheckRecords, } from "../../workflows/container-contents/containerPersistence.js";
+import { hasStartupDocumentSyncWork } from "../../workflows/container-contents/documentPriming.js";
+import { isDatabaseUnavailableError } from "../../workflows/container-contents/syncLane.js";
+const STARTUP_REMOTE_HYDRATION_FRESH_MS = 15 * 60_000;
+function isFreshStartupRemoteHydrationCheck(checkedAt, nowMs) {
+    const checkedAtMs = Date.parse(checkedAt);
+    return (Number.isFinite(checkedAtMs) &&
+        nowMs - checkedAtMs <= STARTUP_REMOTE_HYDRATION_FRESH_MS);
+}
+function shouldHydrateUnmarkedStartupRoot(state) {
+    // An empty authenticated cache needs one root probe to discover the remote
+    // tree. Existing local-only roots are deliberately left cache-first; explicit
+    // refresh and remote events can reconcile them without polling every startup.
+    return state.containersById.size === 0;
+}
+async function getStaleStartupRemoteHydrationParentIds(state, isCurrent) {
+    const parentIds = [null, ...state.containersById.keys()];
+    const syncLanes = parentIds.map((parentId) => createContainerParentSyncLane(parentId));
+    const checkRecords = await loadContainerSyncLaneCheckRecords(state.runtime.infra.execSql, syncLanes);
+    if (isCurrent?.() === false) {
+        return null;
+    }
+    const nowMs = Date.now();
+    const rootCheckRecord = checkRecords[0];
+    state.rootLaneHydrated = rootCheckRecord
+        ? isFreshStartupRemoteHydrationCheck(rootCheckRecord.checkedAt, nowMs)
+        : false;
+    const hydrateUnmarkedRoot = shouldHydrateUnmarkedStartupRoot(state);
+    return parentIds.filter((_, index) => {
+        const checkRecord = checkRecords[index];
+        if (!checkRecord) {
+            return hydrateUnmarkedRoot && index === 0;
+        }
+        return !isFreshStartupRemoteHydrationCheck(checkRecord.checkedAt, nowMs);
+    });
+}
+function reportStartupHydrationError(message, error) {
+    if (isDatabaseUnavailableError(error)) {
+        return;
+    }
+    console.error(message, error);
+}
+export async function scheduleStaleStartupRemoteHydration(input) {
+    const { requestHydration, state } = input;
+    if (!state.runtime.auth.isAuthenticated || !state.runtime.state.online) {
+        return false;
+    }
+    let parentIds;
+    try {
+        parentIds = await getStaleStartupRemoteHydrationParentIds(state, input.isCurrent);
+    }
+    catch (error) {
+        if (input.isCurrent?.() === false) {
+            return false;
+        }
+        reportStartupHydrationError("Failed to inspect startup container contents hydration:", error);
+        return false;
+    }
+    if (!parentIds || input.isCurrent?.() === false) {
+        return false;
+    }
+    const activeContainerId = state.runtime.state.containerId;
+    const shouldScheduleStaleRootRecovery = state.rootLaneHydrated &&
+        activeContainerId !== null &&
+        !state.containersById.has(activeContainerId);
+    if (parentIds.length === 0) {
+        return shouldScheduleStaleRootRecovery;
+    }
+    for (const parentId of parentIds) {
+        state.containerParentIdsNeedingHydration.add(parentId);
+    }
+    // Startup stays cache-first: only the local freshness-marker read is awaited.
+    // Missing markers on an existing remote cache do not force a first-open poll;
+    // stale checked lanes and empty caches hydrate behind the cached tree.
+    // WebSocket events and explicit refresh bypass this.
+    void requestHydration().catch((error) => {
+        reportStartupHydrationError("Failed to schedule startup container contents hydration:", error);
+    });
+    return shouldScheduleStaleRootRecovery;
+}
+export async function hasStartupContainerSyncWork(state) {
+    const execSql = state.runtime.infra.execSql;
+    const [createIntents, moveIntents] = await Promise.all([
+        state.persistence.listPendingCreateIntents(execSql),
+        state.persistence.listUnsyncedMoveIntents(execSql),
+    ]);
+    if (createIntents.length > 0 || moveIntents.length > 0) {
+        return true;
+    }
+    // Durable document-level work (pending creates, queued Loro updates or
+    // attachments, pending document move intents) is drained by lane passes too:
+    // the pass primes the owning document stores, which register and request
+    // their own sync lanes. Without this probe, a relaunch whose only pending
+    // work is document-level never schedules any lane and the write queue sits
+    // unattempted forever.
+    if (await hasStartupDocumentSyncWork(execSql)) {
+        return true;
+    }
+    const containerIds = Array.from(state.containersById.keys());
+    if (containerIds.length === 0) {
+        return false;
+    }
+    const [containersWithPendingMetadata, containersWithPullContinuations] = await Promise.all([
+        state.persistence.listContainerIdsWithPendingUpdates(execSql, containerIds),
+        state.persistence.listContainerIdsWithPullContinuations(execSql, containerIds),
+    ]);
+    return (containersWithPendingMetadata.length > 0 ||
+        containersWithPullContinuations.length > 0);
+}
+//# sourceMappingURL=startupHydration.js.map

package/stores/container-contents/startupHydration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startupHydration.js","sourceRoot":"","sources":["startupHydration.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type ContainerContentsPersistence,\n  createContainerParentSyncLane,\n  loadContainerSyncLaneCheckRecords,\n} from \"../../workflows/container-contents/containerPersistence\";\nimport { hasStartupDocumentSyncWork } from \"../../workflows/container-contents/documentPriming\";\nimport { isDatabaseUnavailableError } from \"../../workflows/container-contents/syncLane\";\n\nconst STARTUP_REMOTE_HYDRATION_FRESH_MS = 15 * 60_000;\ntype StartupHydrationExecSql = Parameters<\n  typeof loadContainerSyncLaneCheckRecords\n>[0];\n\ninterface StartupHydrationState {\n  containerParentIdsNeedingHydration: Set<string | null>;\n  containersById: ReadonlyMap<\n    string,\n    {\n      container: {\n        metadataDocumentId?: string | null | undefined;\n        parentId: string | null;\n      };\n    }\n  >;\n  rootLaneHydrated: boolean;\n  runtime: {\n    auth: { isAuthenticated: boolean; organizationId?: string | null };\n    infra: { execSql: StartupHydrationExecSql };\n    state: { containerId: string | null; online: boolean };\n  };\n}\n\nfunction isFreshStartupRemoteHydrationCheck(\n  checkedAt: string,\n  nowMs: number,\n): boolean {\n  const checkedAtMs = Date.parse(checkedAt);\n  return (\n    Number.isFinite(checkedAtMs) &&\n    nowMs - checkedAtMs <= STARTUP_REMOTE_HYDRATION_FRESH_MS\n  );\n}\n\nfunction shouldHydrateUnmarkedStartupRoot(\n  state: StartupHydrationState,\n): boolean {\n  // An empty authenticated cache needs one root probe to discover the remote\n  // tree. Existing local-only roots are deliberately left cache-first; explicit\n  // refresh and remote events can reconcile them without polling every startup.\n  return state.containersById.size === 0;\n}\n\nasync function getStaleStartupRemoteHydrationParentIds(\n  state: StartupHydrationState,\n  isCurrent?: (() => boolean) | undefined,\n): Promise<Array<string | null> | null> {\n  const parentIds = [null, ...state.containersById.keys()];\n  const syncLanes = parentIds.map((parentId) =>\n    createContainerParentSyncLane(parentId),\n  );\n  const checkRecords = await loadContainerSyncLaneCheckRecords(\n    state.runtime.infra.execSql,\n    syncLanes,\n  );\n  if (isCurrent?.() === false) {\n    return null;\n  }\n  const nowMs = Date.now();\n  const rootCheckRecord = checkRecords[0];\n  state.rootLaneHydrated = rootCheckRecord\n    ? isFreshStartupRemoteHydrationCheck(rootCheckRecord.checkedAt, nowMs)\n    : false;\n  const hydrateUnmarkedRoot = shouldHydrateUnmarkedStartupRoot(state);\n\n  return parentIds.filter((_, index) => {\n    const checkRecord = checkRecords[index];\n    if (!checkRecord) {\n      return hydrateUnmarkedRoot && index === 0;\n    }\n\n    return !isFreshStartupRemoteHydrationCheck(checkRecord.checkedAt, nowMs);\n  });\n}\n\nfunction reportStartupHydrationError(message: string, error: unknown) {\n  if (isDatabaseUnavailableError(error)) {\n    return;\n  }\n\n  console.error(message, error);\n}\n\nexport async function scheduleStaleStartupRemoteHydration(input: {\n  isCurrent?: (() => boolean) | undefined;\n  requestHydration: () => Promise<void>;\n  state: StartupHydrationState;\n}): Promise<boolean> {\n  const { requestHydration, state } = input;\n  if (!state.runtime.auth.isAuthenticated || !state.runtime.state.online) {\n    return false;\n  }\n\n  let parentIds: Array<string | null> | null;\n  try {\n    parentIds = await getStaleStartupRemoteHydrationParentIds(\n      state,\n      input.isCurrent,\n    );\n  } catch (error: unknown) {\n    if (input.isCurrent?.() === false) {\n      return false;\n    }\n    reportStartupHydrationError(\n      \"Failed to inspect startup container contents hydration:\",\n      error,\n    );\n    return false;\n  }\n  if (!parentIds || input.isCurrent?.() === false) {\n    return false;\n  }\n  const activeContainerId = state.runtime.state.containerId;\n  const shouldScheduleStaleRootRecovery =\n    state.rootLaneHydrated &&\n    activeContainerId !== null &&\n    !state.containersById.has(activeContainerId);\n  if (parentIds.length === 0) {\n    return shouldScheduleStaleRootRecovery;\n  }\n\n  for (const parentId of parentIds) {\n    state.containerParentIdsNeedingHydration.add(parentId);\n  }\n  // Startup stays cache-first: only the local freshness-marker read is awaited.\n  // Missing markers on an existing remote cache do not force a first-open poll;\n  // stale checked lanes and empty caches hydrate behind the cached tree.\n  // WebSocket events and explicit refresh bypass this.\n  void requestHydration().catch((error: unknown) => {\n    reportStartupHydrationError(\n      \"Failed to schedule startup container contents hydration:\",\n      error,\n    );\n  });\n  return shouldScheduleStaleRootRecovery;\n}\n\nexport async function hasStartupContainerSyncWork(state: {\n  containersById: ReadonlyMap<string, unknown>;\n  persistence: ContainerContentsPersistence;\n  runtime: { infra: { execSql: StartupHydrationExecSql } };\n}): Promise<boolean> {\n  const execSql = state.runtime.infra.execSql;\n  const [createIntents, moveIntents] = await Promise.all([\n    state.persistence.listPendingCreateIntents(execSql),\n    state.persistence.listUnsyncedMoveIntents(execSql),\n  ]);\n  if (createIntents.length > 0 || moveIntents.length > 0) {\n    return true;\n  }\n\n  // Durable document-level work (pending creates, queued Loro updates or\n  // attachments, pending document move intents) is drained by lane passes too:\n  // the pass primes the owning document stores, which register and request\n  // their own sync lanes. Without this probe, a relaunch whose only pending\n  // work is document-level never schedules any lane and the write queue sits\n  // unattempted forever.\n  if (await hasStartupDocumentSyncWork(execSql)) {\n    return true;\n  }\n\n  const containerIds = Array.from(state.containersById.keys());\n  if (containerIds.length === 0) {\n    return false;\n  }\n  const [containersWithPendingMetadata, containersWithPullContinuations] =\n    await Promise.all([\n      state.persistence.listContainerIdsWithPendingUpdates(\n        execSql,\n        containerIds,\n      ),\n      state.persistence.listContainerIdsWithPullContinuations(\n        execSql,\n        containerIds,\n      ),\n    ]);\n  return (\n    containersWithPendingMetadata.length > 0 ||\n    containersWithPullContinuations.length > 0\n  );\n}\n"]}

package/stores/container-contents/state.d.ts

@@ -0,0 +1,14 @@
+import type { ContainerContentsPersistence } from "../../workflows/container-contents/containerPersistence.js";
+import type { ContainerContentsStoreRuntime, ContainerContentsStoreSyncAgent } from "./syncAgentTypes.js";
+import type { ContainerContentsStoreState } from "./types.js";
+export declare function createContainerContentsStoreState(initialRuntime: ContainerContentsStoreRuntime, persistence: ContainerContentsPersistence, logLabel?: string | undefined): ContainerContentsStoreState;
+export declare function updateContainerContentsSnapshot(state: ContainerContentsStoreState): void;
+export declare function subscribeToContainerContentsStore(state: ContainerContentsStoreState, listener: () => void): () => boolean;
+export declare function updateContainerContentsStoreRuntime(state: ContainerContentsStoreState, nextRuntime: ContainerContentsStoreRuntime, syncAgent: ContainerContentsStoreSyncAgent): void;
+export declare function consumePendingContainerContentsReconnectRefresh(state: {
+    remoteReconnectRefreshPending: boolean;
+    snapshot: {
+        ready: boolean;
+    };
+}, refresh: () => Promise<boolean>): void;
+export declare function updateContainerContentsStorePersistence(state: ContainerContentsStoreState, nextPersistence: ContainerContentsPersistence, syncAgent: ContainerContentsStoreSyncAgent): void;