@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/stores/local-projection/summaryCache.js

@@ -0,0 +1,93 @@
+export function createSummaryCache() {
+    return {
+        summariesByContainerId: new Map(),
+        linkedContainerIdsByDocumentId: new Map(),
+        hydratedContainerIds: new Set(),
+    };
+}
+export function resetSummaryCache(cache) {
+    cache.summariesByContainerId.clear();
+    cache.linkedContainerIdsByDocumentId.clear();
+    cache.hydratedContainerIds.clear();
+}
+function setSummariesForContainer(cache, containerId, summaries) {
+    cache.summariesByContainerId.set(containerId, summaries);
+    cache.hydratedContainerIds.add(containerId);
+}
+function mergeLinks(cache, links) {
+    let changed = false;
+    for (const [documentId, containerIds] of links) {
+        const previous = cache.linkedContainerIdsByDocumentId.get(documentId);
+        changed ||=
+            !previous ||
+                previous.length !== containerIds.length ||
+                previous.some((id, index) => id !== containerIds[index]);
+        cache.linkedContainerIdsByDocumentId.set(documentId, containerIds);
+    }
+    return changed;
+}
+/**
+ * Replace a container's summaries (and merge its document links) from a freshly
+ * loaded or reconciled set. Returns true when the stored value changed, so the
+ * store can decide whether to emit.
+ */
+export function applyContainerSummaries(cache, input) {
+    const previous = cache.summariesByContainerId.get(input.containerId);
+    let changed = !previous || !areSummaryListsEqual(previous, input.documentSummaries);
+    setSummariesForContainer(cache, input.containerId, input.documentSummaries);
+    if (input.linkedContainerIdsByDocumentId) {
+        changed =
+            mergeLinks(cache, input.linkedContainerIdsByDocumentId) || changed;
+    }
+    return changed;
+}
+/** Remove a locally deleted document from every hydrated container view. */
+export function removeDocumentSummary(cache, localId) {
+    const removedDocumentIds = new Set();
+    let changed = false;
+    for (const [containerId, summaries] of cache.summariesByContainerId) {
+        const remaining = summaries.filter((summary) => {
+            if (summary.id !== localId) {
+                return true;
+            }
+            if (summary.documentId) {
+                removedDocumentIds.add(summary.documentId);
+            }
+            return false;
+        });
+        if (remaining.length !== summaries.length) {
+            cache.summariesByContainerId.set(containerId, remaining);
+            changed = true;
+        }
+    }
+    for (const documentId of removedDocumentIds) {
+        changed =
+            cache.linkedContainerIdsByDocumentId.delete(documentId) || changed;
+    }
+    return changed;
+}
+function areSummaryListsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((leftSummary, index) => {
+        const rightSummary = right[index];
+        return (rightSummary !== undefined &&
+            leftSummary.id === rightSummary.id &&
+            leftSummary.documentId === rightSummary.documentId &&
+            leftSummary.containerId === rightSummary.containerId &&
+            leftSummary.documentKind === rightSummary.documentKind &&
+            leftSummary.createdAt === rightSummary.createdAt &&
+            leftSummary.effectiveAccessLevel === rightSummary.effectiveAccessLevel &&
+            leftSummary.title === rightSummary.title &&
+            leftSummary.updatedAt === rightSummary.updatedAt &&
+            leftSummary.accessStateHash === rightSummary.accessStateHash);
+    });
+}
+export function snapshotSummariesByContainerId(cache) {
+    return new Map(cache.summariesByContainerId);
+}
+export function snapshotLinkedContainerIdsByDocumentId(cache) {
+    return new Map(cache.linkedContainerIdsByDocumentId);
+}
+//# sourceMappingURL=summaryCache.js.map

package/stores/local-projection/summaryCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summaryCache.js","sourceRoot":"","sources":["summaryCache.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DocumentSummary } from \"../../data/documents/documentSummary\";\n\n/**\n * In-memory cache of document summaries + container links for the local\n * projection store (Layer A). Holds the device-first view of each container's\n * contents, loaded from SQLite and patched by the background reconciler.\n */\nexport interface SummaryCache {\n  summariesByContainerId: Map<string, ReadonlyArray<DocumentSummary>>;\n  linkedContainerIdsByDocumentId: Map<string, ReadonlyArray<string>>;\n  /** Containers whose summaries have been loaded from SQLite at least once. */\n  hydratedContainerIds: Set<string>;\n}\n\nexport function createSummaryCache(): SummaryCache {\n  return {\n    summariesByContainerId: new Map(),\n    linkedContainerIdsByDocumentId: new Map(),\n    hydratedContainerIds: new Set(),\n  };\n}\n\nexport function resetSummaryCache(cache: SummaryCache): void {\n  cache.summariesByContainerId.clear();\n  cache.linkedContainerIdsByDocumentId.clear();\n  cache.hydratedContainerIds.clear();\n}\n\nfunction setSummariesForContainer(\n  cache: SummaryCache,\n  containerId: string,\n  summaries: ReadonlyArray<DocumentSummary>,\n): void {\n  cache.summariesByContainerId.set(containerId, summaries);\n  cache.hydratedContainerIds.add(containerId);\n}\n\nfunction mergeLinks(\n  cache: SummaryCache,\n  links: ReadonlyMap<string, ReadonlyArray<string>>,\n): boolean {\n  let changed = false;\n  for (const [documentId, containerIds] of links) {\n    const previous = cache.linkedContainerIdsByDocumentId.get(documentId);\n    changed ||=\n      !previous ||\n      previous.length !== containerIds.length ||\n      previous.some((id, index) => id !== containerIds[index]);\n    cache.linkedContainerIdsByDocumentId.set(documentId, containerIds);\n  }\n  return changed;\n}\n\n/**\n * Replace a container's summaries (and merge its document links) from a freshly\n * loaded or reconciled set. Returns true when the stored value changed, so the\n * store can decide whether to emit.\n */\nexport function applyContainerSummaries(\n  cache: SummaryCache,\n  input: {\n    containerId: string;\n    documentSummaries: ReadonlyArray<DocumentSummary>;\n    linkedContainerIdsByDocumentId?:\n      | ReadonlyMap<string, ReadonlyArray<string>>\n      | undefined;\n  },\n): boolean {\n  const previous = cache.summariesByContainerId.get(input.containerId);\n  let changed =\n    !previous || !areSummaryListsEqual(previous, input.documentSummaries);\n\n  setSummariesForContainer(cache, input.containerId, input.documentSummaries);\n  if (input.linkedContainerIdsByDocumentId) {\n    changed =\n      mergeLinks(cache, input.linkedContainerIdsByDocumentId) || changed;\n  }\n\n  return changed;\n}\n\n/** Remove a locally deleted document from every hydrated container view. */\nexport function removeDocumentSummary(\n  cache: SummaryCache,\n  localId: string,\n): boolean {\n  const removedDocumentIds = new Set<string>();\n  let changed = false;\n\n  for (const [containerId, summaries] of cache.summariesByContainerId) {\n    const remaining = summaries.filter((summary) => {\n      if (summary.id !== localId) {\n        return true;\n      }\n      if (summary.documentId) {\n        removedDocumentIds.add(summary.documentId);\n      }\n      return false;\n    });\n    if (remaining.length !== summaries.length) {\n      cache.summariesByContainerId.set(containerId, remaining);\n      changed = true;\n    }\n  }\n\n  for (const documentId of removedDocumentIds) {\n    changed =\n      cache.linkedContainerIdsByDocumentId.delete(documentId) || changed;\n  }\n  return changed;\n}\n\nfunction areSummaryListsEqual(\n  left: ReadonlyArray<DocumentSummary>,\n  right: ReadonlyArray<DocumentSummary>,\n): boolean {\n  if (left.length !== right.length) {\n    return false;\n  }\n\n  return left.every((leftSummary, index) => {\n    const rightSummary = right[index];\n    return (\n      rightSummary !== undefined &&\n      leftSummary.id === rightSummary.id &&\n      leftSummary.documentId === rightSummary.documentId &&\n      leftSummary.containerId === rightSummary.containerId &&\n      leftSummary.documentKind === rightSummary.documentKind &&\n      leftSummary.createdAt === rightSummary.createdAt &&\n      leftSummary.effectiveAccessLevel === rightSummary.effectiveAccessLevel &&\n      leftSummary.title === rightSummary.title &&\n      leftSummary.updatedAt === rightSummary.updatedAt &&\n      leftSummary.accessStateHash === rightSummary.accessStateHash\n    );\n  });\n}\n\nexport function snapshotSummariesByContainerId(\n  cache: SummaryCache,\n): ReadonlyMap<string, ReadonlyArray<DocumentSummary>> {\n  return new Map(cache.summariesByContainerId);\n}\n\nexport function snapshotLinkedContainerIdsByDocumentId(\n  cache: SummaryCache,\n): ReadonlyMap<string, ReadonlyArray<string>> {\n  return new Map(cache.linkedContainerIdsByDocumentId);\n}\n"]}

package/stores/local-projection/types.d.ts

@@ -0,0 +1,45 @@
+import type { DocumentSummary } from "../../data/documents/documentSummary.js";
+import type { ContainerContentsStoreRuntime } from "../container-contents/syncAgent.js";
+import type { ContainerNode } from "../container-contents/types.js";
+/**
+ * Device-first, synchronously-readable view of one domain scope.
+ *
+ * `ready` is a pure function of *local* hydration (SQLite/OPFS load). It is
+ * never gated on authentication, network, or remote reconciliation — that is
+ * the core invariant that keeps Explorer's first paint instant after register.
+ */
+export interface LocalProjectionSnapshot {
+    /** True once the local container tree + summaries have loaded from SQLite. */
+    ready: boolean;
+    /** Container tree nodes, sorted, as produced by the container-contents store. */
+    containers: ReadonlyArray<ContainerNode>;
+    /** Document summaries grouped by the container they were discovered under. */
+    documentSummariesByContainerId: ReadonlyMap<string, ReadonlyArray<DocumentSummary>>;
+    /** Container links per document id (reverse index used by the explorer UI). */
+    linkedContainerIdsByDocumentId: ReadonlyMap<string, ReadonlyArray<string>>;
+}
+/**
+ * A patch applied by the background reconciler (Layer B) into the local
+ * projection (Layer A). Summaries replace the prior set for each listed
+ * container; links replace the prior set for each listed document.
+ */
+export interface LocalProjectionReconciledDelta {
+    containerId: string;
+    documentSummaries: ReadonlyArray<DocumentSummary>;
+    linkedContainerIdsByDocumentId?: ReadonlyMap<string, ReadonlyArray<string>> | undefined;
+}
+/** Read side of the app-facing `tearleads.deviceFirst.open()` handle. */
+export interface LocalProjectionView {
+    getSnapshot: () => LocalProjectionSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    /**
+     * Report which container the user is viewing so the reconciler can sync it
+     * first. Passing `null` clears the active pointer.
+     */
+    setActiveContainer: (containerId: string | null) => void;
+    /**
+     * Push the latest workflow runtime into the view. Call this from an effect
+     * (never during render): it may emit synchronously to subscribers.
+     */
+    updateRuntime: (runtime: ContainerContentsStoreRuntime) => void;
+}

package/stores/local-projection/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/stores/local-projection/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"","sourcesContent":["import type { DocumentSummary } from \"../../data/documents/documentSummary\";\nimport type { ContainerContentsStoreRuntime } from \"../container-contents/syncAgent\";\nimport type { ContainerNode } from \"../container-contents/types\";\n\n/**\n * Device-first, synchronously-readable view of one domain scope.\n *\n * `ready` is a pure function of *local* hydration (SQLite/OPFS load). It is\n * never gated on authentication, network, or remote reconciliation — that is\n * the core invariant that keeps Explorer's first paint instant after register.\n */\nexport interface LocalProjectionSnapshot {\n  /** True once the local container tree + summaries have loaded from SQLite. */\n  ready: boolean;\n  /** Container tree nodes, sorted, as produced by the container-contents store. */\n  containers: ReadonlyArray<ContainerNode>;\n  /** Document summaries grouped by the container they were discovered under. */\n  documentSummariesByContainerId: ReadonlyMap<\n    string,\n    ReadonlyArray<DocumentSummary>\n  >;\n  /** Container links per document id (reverse index used by the explorer UI). */\n  linkedContainerIdsByDocumentId: ReadonlyMap<string, ReadonlyArray<string>>;\n}\n\n/**\n * A patch applied by the background reconciler (Layer B) into the local\n * projection (Layer A). Summaries replace the prior set for each listed\n * container; links replace the prior set for each listed document.\n */\nexport interface LocalProjectionReconciledDelta {\n  containerId: string;\n  documentSummaries: ReadonlyArray<DocumentSummary>;\n  linkedContainerIdsByDocumentId?:\n    | ReadonlyMap<string, ReadonlyArray<string>>\n    | undefined;\n}\n\n/** Read side of the app-facing `tearleads.deviceFirst.open()` handle. */\nexport interface LocalProjectionView {\n  getSnapshot: () => LocalProjectionSnapshot;\n  subscribe: (listener: () => void) => () => void;\n  /**\n   * Report which container the user is viewing so the reconciler can sync it\n   * first. Passing `null` clears the active pointer.\n   */\n  setActiveContainer: (containerId: string | null) => void;\n  /**\n   * Push the latest workflow runtime into the view. Call this from an effect\n   * (never during render): it may emit synchronously to subscribers.\n   */\n  updateRuntime: (runtime: ContainerContentsStoreRuntime) => void;\n}\n"]}

package/sync/reconciliation/documentContentPull.js

@@ -0,0 +1,49 @@
+import { isSystemContainerNode } from "../../stores/container-contents/index.js";
+/**
+ * Routes reconciled summaries into the appropriate content-sync policy.
+ *
+ * System-container contents cannot rely on a mini-app opening them on this
+ * device, especially during identity recovery. Pull each remote version once.
+ * Ordinary documents stay lazy unless an explicit refresh asks an already-open
+ * store to revalidate.
+ */
+export function createReconciledDocumentContentPuller(host) {
+    // Retain only the last observed version for each system-container document.
+    // Keeping the version in the key would grow this cache for every historical
+    // updatedAt value over the reconciler's lifetime.
+    const pulledSystemDocumentVersions = new Map();
+    return (containerId, documents, force) => {
+        const systemContainer = isSystemContainerNode(host.getContainer(containerId) ?? { systemSlot: null });
+        for (const document of documents) {
+            if (!document.documentId) {
+                continue;
+            }
+            if (systemContainer) {
+                // Container scope is significant: the same document can be linked into
+                // multiple system containers whose keys establish different decryption
+                // contexts for the transient store.
+                const documentKey = `${containerId}:${document.documentId}`;
+                if (pulledSystemDocumentVersions.get(documentKey) !== document.updatedAt) {
+                    host.pullDocumentContent({
+                        containerId,
+                        documentId: document.documentId,
+                        localId: document.id,
+                    });
+                    pulledSystemDocumentVersions.set(documentKey, document.updatedAt);
+                }
+                else if (force) {
+                    // The first eager pull registers a document store before scheduling
+                    // its async sync. If that sync failed, a later explicit Refresh must
+                    // be able to retry the same server version without defeating normal
+                    // background dedupe.
+                    host.requestRegisteredDocumentRemoteSync(document.id, document.documentId);
+                }
+                continue;
+            }
+            if (force) {
+                host.requestRegisteredDocumentRemoteSync(document.id, document.documentId);
+            }
+        }
+    };
+}
+//# sourceMappingURL=documentContentPull.js.map

package/sync/reconciliation/documentContentPull.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentContentPull.js","sourceRoot":"","sources":["documentContentPull.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAgBxE;;;;;;;GAOG;AACH,MAAM,UAAU,qCAAqC,CACnD,IAAuC;IAEvC,4EAA4E;IAC5E,4EAA4E;IAC5E,kDAAkD;IAClD,MAAM,4BAA4B,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE/D,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE;QACvC,MAAM,eAAe,GAAG,qBAAqB,CAC3C,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CACvD,CAAC;QAEF,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;gBACzB,SAAS;YACX,CAAC;YAED,IAAI,eAAe,EAAE,CAAC;gBACpB,uEAAuE;gBACvE,uEAAuE;gBACvE,oCAAoC;gBACpC,MAAM,WAAW,GAAG,GAAG,WAAW,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;gBAC5D,IACE,4BAA4B,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,QAAQ,CAAC,SAAS,EACpE,CAAC;oBACD,IAAI,CAAC,mBAAmB,CAAC;wBACvB,WAAW;wBACX,UAAU,EAAE,QAAQ,CAAC,UAAU;wBAC/B,OAAO,EAAE,QAAQ,CAAC,EAAE;qBACrB,CAAC,CAAC;oBACH,4BAA4B,CAAC,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;gBACpE,CAAC;qBAAM,IAAI,KAAK,EAAE,CAAC;oBACjB,oEAAoE;oBACpE,qEAAqE;oBACrE,oEAAoE;oBACpE,qBAAqB;oBACrB,IAAI,CAAC,mCAAmC,CACtC,QAAQ,CAAC,EAAE,EACX,QAAQ,CAAC,UAAU,CACpB,CAAC;gBACJ,CAAC;gBACD,SAAS;YACX,CAAC;YAED,IAAI,KAAK,EAAE,CAAC;gBACV,IAAI,CAAC,mCAAmC,CACtC,QAAQ,CAAC,EAAE,EACX,QAAQ,CAAC,UAAU,CACpB,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import type { ContainerNode } from \"../../stores/container-contents\";\nimport { isSystemContainerNode } from \"../../stores/container-contents\";\nimport type { ReconciliationHost } from \"./serviceTypes\";\n\ninterface ReconciledDocumentContentPullHost {\n  readonly getContainer: (containerId: string) => ContainerNode | null;\n  readonly pullDocumentContent: (input: {\n    readonly containerId: string;\n    readonly documentId: string;\n    readonly localId: string;\n  }) => void;\n  readonly requestRegisteredDocumentRemoteSync: (\n    localId: string,\n    documentId: string,\n  ) => void;\n}\n\n/**\n * Routes reconciled summaries into the appropriate content-sync policy.\n *\n * System-container contents cannot rely on a mini-app opening them on this\n * device, especially during identity recovery. Pull each remote version once.\n * Ordinary documents stay lazy unless an explicit refresh asks an already-open\n * store to revalidate.\n */\nexport function createReconciledDocumentContentPuller(\n  host: ReconciledDocumentContentPullHost,\n): ReconciliationHost[\"requestDocumentContentPull\"] {\n  // Retain only the last observed version for each system-container document.\n  // Keeping the version in the key would grow this cache for every historical\n  // updatedAt value over the reconciler's lifetime.\n  const pulledSystemDocumentVersions = new Map<string, string>();\n\n  return (containerId, documents, force) => {\n    const systemContainer = isSystemContainerNode(\n      host.getContainer(containerId) ?? { systemSlot: null },\n    );\n\n    for (const document of documents) {\n      if (!document.documentId) {\n        continue;\n      }\n\n      if (systemContainer) {\n        // Container scope is significant: the same document can be linked into\n        // multiple system containers whose keys establish different decryption\n        // contexts for the transient store.\n        const documentKey = `${containerId}:${document.documentId}`;\n        if (\n          pulledSystemDocumentVersions.get(documentKey) !== document.updatedAt\n        ) {\n          host.pullDocumentContent({\n            containerId,\n            documentId: document.documentId,\n            localId: document.id,\n          });\n          pulledSystemDocumentVersions.set(documentKey, document.updatedAt);\n        } else if (force) {\n          // The first eager pull registers a document store before scheduling\n          // its async sync. If that sync failed, a later explicit Refresh must\n          // be able to retry the same server version without defeating normal\n          // background dedupe.\n          host.requestRegisteredDocumentRemoteSync(\n            document.id,\n            document.documentId,\n          );\n        }\n        continue;\n      }\n\n      if (force) {\n        host.requestRegisteredDocumentRemoteSync(\n          document.id,\n          document.documentId,\n        );\n      }\n    }\n  };\n}\n"]}

package/sync/reconciliation/idleBackfill.js

@@ -0,0 +1,37 @@
+export function markContainerForced(state, containerId) {
+    state.nextForceGeneration += 1;
+    state.automaticRetryGenerations.delete(containerId);
+    state.forcedContainerGenerations.set(containerId, state.nextForceGeneration);
+}
+export function acknowledgeContainerForce(state, containerId, generation) {
+    if (state.forcedContainerGenerations.get(containerId) === generation) {
+        state.forcedContainerGenerations.delete(containerId);
+        state.automaticRetryGenerations.delete(containerId);
+    }
+}
+export function activateContainer(state, containerId, enqueue) {
+    state.activeContainerId = containerId;
+    if (containerId) {
+        enqueue(containerId, state.forcedContainerGenerations.has(containerId));
+    }
+}
+export function enqueueKnownContainersForIdleBackfill(input) {
+    const { host, scheduleDrain, state } = input;
+    const knownContainerIds = host.listKnownContainerIds();
+    const activeContainerId = state.activeContainerId;
+    const backfillContainerIds = activeContainerId !== null &&
+        !knownContainerIds.includes(activeContainerId) &&
+        host.canDiscoverContainerDocuments(activeContainerId)
+        ? [...knownContainerIds, activeContainerId]
+        : knownContainerIds;
+    state.initialDocumentProbe.arm(backfillContainerIds.filter((id) => host.canDiscoverContainerDocuments(id)));
+    for (const containerId of backfillContainerIds) {
+        const shouldForce = state.forcedContainerGenerations.has(containerId);
+        if (!shouldForce && state.discoveredContainerIds.has(containerId)) {
+            continue;
+        }
+        state.queue.enqueue(containerId, "idle");
+    }
+    scheduleDrain();
+}
+//# sourceMappingURL=idleBackfill.js.map

package/sync/reconciliation/idleBackfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idleBackfill.js","sourceRoot":"","sources":["idleBackfill.ts"],"names":[],"mappings":"AAcA,MAAM,UAAU,mBAAmB,CACjC,KAAwB,EACxB,WAAmB;IAEnB,KAAK,CAAC,mBAAmB,IAAI,CAAC,CAAC;IAC/B,KAAK,CAAC,yBAAyB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACpD,KAAK,CAAC,0BAA0B,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;AAC/E,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,KAAwB,EACxB,WAAmB,EACnB,UAA8B;IAE9B,IAAI,KAAK,CAAC,0BAA0B,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,UAAU,EAAE,CAAC;QACrE,KAAK,CAAC,0BAA0B,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QACrD,KAAK,CAAC,yBAAyB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACtD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,iBAAiB,CAC/B,KAAwB,EACxB,WAA0B,EAC1B,OAAsD;IAEtD,KAAK,CAAC,iBAAiB,GAAG,WAAW,CAAC;IACtC,IAAI,WAAW,EAAE,CAAC;QAChB,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,0BAA0B,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qCAAqC,CAAC,KAIrD;IACC,MAAM,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAC7C,MAAM,iBAAiB,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACvD,MAAM,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAC;IAClD,MAAM,oBAAoB,GACxB,iBAAiB,KAAK,IAAI;QAC1B,CAAC,iBAAiB,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAC9C,IAAI,CAAC,6BAA6B,CAAC,iBAAiB,CAAC;QACnD,CAAC,CAAC,CAAC,GAAG,iBAAiB,EAAE,iBAAiB,CAAC;QAC3C,CAAC,CAAC,iBAAiB,CAAC;IACxB,KAAK,CAAC,oBAAoB,CAAC,GAAG,CAC5B,oBAAoB,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,6BAA6B,CAAC,EAAE,CAAC,CAAC,CAC5E,CAAC;IACF,KAAK,MAAM,WAAW,IAAI,oBAAoB,EAAE,CAAC;QAC/C,MAAM,WAAW,GAAG,KAAK,CAAC,0BAA0B,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACtE,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,sBAAsB,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;YAClE,SAAS;QACX,CAAC;QACD,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAC3C,CAAC;IACD,aAAa,EAAE,CAAC;AAClB,CAAC","sourcesContent":["import type { InitialDocumentProbe } from \"./initialDocumentProbe\";\nimport type { ReconcileQueue } from \"./queue\";\nimport type { ReconciliationHost } from \"./serviceTypes\";\n\nexport interface IdleBackfillState {\n  activeContainerId: string | null;\n  automaticRetryGenerations: Map<string, number>;\n  discoveredContainerIds: Set<string>;\n  forcedContainerGenerations: Map<string, number>;\n  initialDocumentProbe: InitialDocumentProbe;\n  nextForceGeneration: number;\n  queue: ReconcileQueue;\n}\n\nexport function markContainerForced(\n  state: IdleBackfillState,\n  containerId: string,\n): void {\n  state.nextForceGeneration += 1;\n  state.automaticRetryGenerations.delete(containerId);\n  state.forcedContainerGenerations.set(containerId, state.nextForceGeneration);\n}\n\nexport function acknowledgeContainerForce(\n  state: IdleBackfillState,\n  containerId: string,\n  generation: number | undefined,\n): void {\n  if (state.forcedContainerGenerations.get(containerId) === generation) {\n    state.forcedContainerGenerations.delete(containerId);\n    state.automaticRetryGenerations.delete(containerId);\n  }\n}\n\nexport function activateContainer(\n  state: IdleBackfillState,\n  containerId: string | null,\n  enqueue: (containerId: string, force: boolean) => void,\n): void {\n  state.activeContainerId = containerId;\n  if (containerId) {\n    enqueue(containerId, state.forcedContainerGenerations.has(containerId));\n  }\n}\n\nexport function enqueueKnownContainersForIdleBackfill(input: {\n  host: ReconciliationHost;\n  scheduleDrain: () => void;\n  state: IdleBackfillState;\n}): void {\n  const { host, scheduleDrain, state } = input;\n  const knownContainerIds = host.listKnownContainerIds();\n  const activeContainerId = state.activeContainerId;\n  const backfillContainerIds =\n    activeContainerId !== null &&\n    !knownContainerIds.includes(activeContainerId) &&\n    host.canDiscoverContainerDocuments(activeContainerId)\n      ? [...knownContainerIds, activeContainerId]\n      : knownContainerIds;\n  state.initialDocumentProbe.arm(\n    backfillContainerIds.filter((id) => host.canDiscoverContainerDocuments(id)),\n  );\n  for (const containerId of backfillContainerIds) {\n    const shouldForce = state.forcedContainerGenerations.has(containerId);\n    if (!shouldForce && state.discoveredContainerIds.has(containerId)) {\n      continue;\n    }\n    state.queue.enqueue(containerId, \"idle\");\n  }\n  scheduleDrain();\n}\n"]}

package/sync/reconciliation/index.d.ts

@@ -0,0 +1,3 @@
+export { createReconciliationService } from "./service.js";
+export type { ReconciliationHost, ReconciliationService } from "./serviceTypes.js";
+export { connectReconciliationTriggers, enqueueReconciliationForEvents, } from "./triggers.js";

package/sync/reconciliation/index.js

@@ -0,0 +1,3 @@
+export { createReconciliationService } from "./service.js";
+export { connectReconciliationTriggers, enqueueReconciliationForEvents, } from "./triggers.js";
+//# sourceMappingURL=index.js.map

package/sync/reconciliation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,YAAY,CAAC","sourcesContent":["export { createReconciliationService } from \"./service\";\nexport type { ReconciliationHost, ReconciliationService } from \"./serviceTypes\";\nexport {\n  connectReconciliationTriggers,\n  enqueueReconciliationForEvents,\n} from \"./triggers\";\n"]}

package/sync/reconciliation/initialDocumentProbe.d.ts

@@ -0,0 +1,37 @@
+export interface InitialDocumentProbeBatchInput {
+    readonly afterLocalId: string | null;
+    readonly listedContainerIds: ReadonlySet<string>;
+    readonly listedDocumentIds: ReadonlySet<string>;
+}
+export interface InitialDocumentProbeBatchResult {
+    readonly done: boolean;
+    readonly nextCursor: string | null;
+    readonly requestedCount: number;
+}
+export interface InitialDocumentProbeHost {
+    readonly listContainerDocumentIds: (containerId: string) => Promise<ReadonlyArray<string> | null>;
+    readonly probeUndiscoveredDocumentsBatch: (input: InitialDocumentProbeBatchInput) => Promise<InitialDocumentProbeBatchResult>;
+    readonly reportInitialDocumentProbeComplete: (requestedCount: number) => void;
+}
+export interface InitialDocumentProbe {
+    readonly arm: (eligibleContainerIds: ReadonlyArray<string>) => void;
+    /** Accept a completed full discovery listing only in the current probe session. */
+    readonly captureListing: (containerId: string) => (documentIds: ReadonlyArray<string>) => void;
+    readonly canRun: () => boolean;
+    readonly continuationDelayMs: () => number;
+    readonly hasPendingWork: () => boolean;
+    readonly resetPending: () => void;
+    readonly resetSkippedListings: () => void;
+    readonly run: () => Promise<void>;
+}
+/**
+ * Runs one bounded unit per call: first one authoritative container listing,
+ * then one local candidate batch. Incremental discovery watermarks are never
+ * used as evidence that a document is absent from the server.
+ *
+ * The eligible set is replaceable because local hydration can become ready
+ * before the remote tree crawl has surfaced every container. Growth before
+ * completion restarts the candidate cursor; an empty early set never completes
+ * the probe or prevents a later remote-containers-added signal from arming it.
+ */
+export declare function createInitialDocumentProbe(host: InitialDocumentProbeHost): InitialDocumentProbe;

package/sync/reconciliation/initialDocumentProbe.js

@@ -0,0 +1,269 @@
+const MAX_INITIAL_DOCUMENT_LISTING_ATTEMPTS = 3;
+const INITIAL_DOCUMENT_LISTING_RETRY_BASE_DELAY_MS = 1_000;
+function createInitialDocumentProbeState() {
+    return {
+        armed: false,
+        cursor: null,
+        eligibleContainerIds: new Set(),
+        generation: 0,
+        listedDocumentIds: null,
+        listedDocumentIdsByContainer: new Map(),
+        listingAttemptsByContainer: new Map(),
+        listingRetryNotBeforeByContainer: new Map(),
+        probedContainerIds: new Set(),
+        reported: false,
+        requestedCount: 0,
+        running: false,
+        skippedContainerIds: new Set(),
+    };
+}
+function sameIds(left, right) {
+    return left.size === right.size && [...left].every((id) => right.has(id));
+}
+function pendingProbeContainerIds(state) {
+    return [...state.eligibleContainerIds].filter((id) => !state.probedContainerIds.has(id));
+}
+function hasPendingWork(state) {
+    return (state.eligibleContainerIds.size > 0 &&
+        ([...state.eligibleContainerIds].some((id) => !state.listedDocumentIdsByContainer.has(id)) ||
+            pendingProbeContainerIds(state).length > 0));
+}
+/**
+ * Eligible containers still awaiting an authoritative listing, each with the
+ * earliest time its bounded retry backoff allows another attempt (0 = now).
+ */
+function unlistedContainerRetries(state) {
+    return [...state.eligibleContainerIds]
+        .filter((id) => !state.listedDocumentIdsByContainer.has(id))
+        .map((id) => ({
+        containerId: id,
+        notBeforeMs: state.listingRetryNotBeforeByContainer.get(id) ?? 0,
+    }));
+}
+function canRun(state, nowMs = Date.now()) {
+    if (!state.armed || state.running || !hasPendingWork(state)) {
+        return false;
+    }
+    const retries = unlistedContainerRetries(state);
+    return (retries.length === 0 || retries.some((retry) => retry.notBeforeMs <= nowMs));
+}
+function continuationDelayMs(state, nowMs = Date.now()) {
+    const retries = unlistedContainerRetries(state);
+    if (retries.length === 0 ||
+        retries.some((retry) => retry.notBeforeMs <= nowMs)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(...retries.map((retry) => retry.notBeforeMs)) - nowMs);
+}
+/**
+ * Invalidate the listing session: bump the generation, drop the candidate
+ * cursor and merged listing set, and clear listing retry bookkeeping.
+ * Per-container listing/probe results survive unless the caller clears them.
+ */
+function resetListingSession(state) {
+    state.generation += 1;
+    state.armed = false;
+    state.cursor = null;
+    state.listedDocumentIds = null;
+    state.listingAttemptsByContainer.clear();
+    state.listingRetryNotBeforeByContainer.clear();
+    state.reported = false;
+    state.requestedCount = 0;
+    state.skippedContainerIds.clear();
+}
+function resetPending(state) {
+    resetListingSession(state);
+    state.eligibleContainerIds.clear();
+    state.listedDocumentIdsByContainer.clear();
+    state.probedContainerIds.clear();
+}
+function resetSkippedListings(state) {
+    if (state.skippedContainerIds.size === 0) {
+        return;
+    }
+    // A reconnect is a new opportunity for lanes that exhausted their bounded
+    // listing retries. Preserve completed healthy lanes, but invalidate any
+    // candidate cursor because the authoritative listing set can now grow.
+    resetListingSession(state);
+}
+function retainEligibleProbeState(state, nextIds) {
+    for (const containerId of state.listedDocumentIdsByContainer.keys()) {
+        if (!nextIds.has(containerId)) {
+            state.listedDocumentIdsByContainer.delete(containerId);
+        }
+    }
+    for (const containerId of state.probedContainerIds) {
+        if (!nextIds.has(containerId)) {
+            state.probedContainerIds.delete(containerId);
+        }
+    }
+    for (const containerId of state.listingAttemptsByContainer.keys()) {
+        if (!nextIds.has(containerId)) {
+            state.listingAttemptsByContainer.delete(containerId);
+            state.listingRetryNotBeforeByContainer.delete(containerId);
+        }
+    }
+}
+function replaceEligibleContainerIds(state, nextIds) {
+    state.generation += 1;
+    state.cursor = null;
+    state.eligibleContainerIds = nextIds;
+    state.listedDocumentIds = null;
+    retainEligibleProbeState(state, nextIds);
+}
+function armProbe(state, nextEligibleContainerIds) {
+    if (state.reported) {
+        return;
+    }
+    const nextIds = new Set(nextEligibleContainerIds.filter((id) => Boolean(id) && !state.skippedContainerIds.has(id)));
+    if (!sameIds(state.eligibleContainerIds, nextIds)) {
+        replaceEligibleContainerIds(state, nextIds);
+    }
+    if (!hasPendingWork(state)) {
+        return;
+    }
+    state.armed = true;
+}
+function readListedDocumentIds(state, eligibleIds) {
+    if (state.listedDocumentIds !== null) {
+        return state.listedDocumentIds;
+    }
+    state.listedDocumentIds = new Set(eligibleIds.flatMap((containerId) => [
+        ...(state.listedDocumentIdsByContainer.get(containerId) ?? []),
+    ]));
+    return state.listedDocumentIds;
+}
+async function listNextEligibleContainer(input) {
+    const { eligibleIds, host, runGeneration, state } = input;
+    const nowMs = Date.now();
+    const containerId = eligibleIds.find((id) => !state.listedDocumentIdsByContainer.has(id) &&
+        (state.listingRetryNotBeforeByContainer.get(id) ?? 0) <= nowMs);
+    if (!containerId) {
+        return false;
+    }
+    let documentIds;
+    try {
+        documentIds = await host.listContainerDocumentIds(containerId);
+    }
+    catch {
+        documentIds = null;
+    }
+    if (state.generation !== runGeneration) {
+        return true;
+    }
+    if (documentIds === null) {
+        const attempts = (state.listingAttemptsByContainer.get(containerId) ?? 0) + 1;
+        state.listingAttemptsByContainer.set(containerId, attempts);
+        // Retry transient listing failures with bounded, seconds-scale backoff.
+        // Exhausted lanes are skipped until prerequisites are regained so healthy
+        // lanes can converge without suppressing the failed lane forever.
+        if (attempts >= MAX_INITIAL_DOCUMENT_LISTING_ATTEMPTS) {
+            state.skippedContainerIds.add(containerId);
+            state.eligibleContainerIds.delete(containerId);
+            state.listingAttemptsByContainer.delete(containerId);
+            state.listingRetryNotBeforeByContainer.delete(containerId);
+        }
+        else {
+            const retryDelayMs = INITIAL_DOCUMENT_LISTING_RETRY_BASE_DELAY_MS * 2 ** (attempts - 1);
+            state.listingRetryNotBeforeByContainer.set(containerId, Date.now() + retryDelayMs);
+        }
+        return true;
+    }
+    state.listingAttemptsByContainer.delete(containerId);
+    state.listingRetryNotBeforeByContainer.delete(containerId);
+    state.listedDocumentIdsByContainer.set(containerId, new Set(documentIds));
+    return true;
+}
+async function runProbe(host, state) {
+    if (!canRun(state)) {
+        return;
+    }
+    state.running = true;
+    const runGeneration = state.generation;
+    try {
+        const eligibleIds = [...state.eligibleContainerIds];
+        if (await listNextEligibleContainer({
+            eligibleIds,
+            host,
+            runGeneration,
+            state,
+        })) {
+            return;
+        }
+        if (eligibleIds.some((id) => !state.listedDocumentIdsByContainer.has(id))) {
+            return;
+        }
+        const candidateContainerIds = pendingProbeContainerIds(state);
+        if (candidateContainerIds.length === 0) {
+            state.armed = false;
+            return;
+        }
+        const batch = await host.probeUndiscoveredDocumentsBatch({
+            afterLocalId: state.cursor,
+            listedContainerIds: new Set(candidateContainerIds),
+            listedDocumentIds: readListedDocumentIds(state, eligibleIds),
+        });
+        if (state.generation !== runGeneration) {
+            return;
+        }
+        state.requestedCount += batch.requestedCount;
+        if (!batch.done) {
+            if (batch.nextCursor !== null) {
+                state.cursor = batch.nextCursor;
+                return;
+            }
+        }
+        for (const containerId of candidateContainerIds) {
+            state.probedContainerIds.add(containerId);
+        }
+        state.cursor = null;
+        state.armed = hasPendingWork(state);
+        if (!state.reported) {
+            state.reported = true;
+            host.reportInitialDocumentProbeComplete(state.requestedCount);
+        }
+    }
+    finally {
+        state.running = false;
+    }
+}
+/**
+ * Runs one bounded unit per call: first one authoritative container listing,
+ * then one local candidate batch. Incremental discovery watermarks are never
+ * used as evidence that a document is absent from the server.
+ *
+ * The eligible set is replaceable because local hydration can become ready
+ * before the remote tree crawl has surfaced every container. Growth before
+ * completion restarts the candidate cursor; an empty early set never completes
+ * the probe or prevents a later remote-containers-added signal from arming it.
+ */
+export function createInitialDocumentProbe(host) {
+    const state = createInitialDocumentProbeState();
+    return {
+        arm: (eligibleContainerIds) => armProbe(state, eligibleContainerIds),
+        captureListing: (containerId) => {
+            // Early active-container discovery may precede arming; a later probe
+            // deliberately re-reads when it cannot reuse this session's listing.
+            const generation = state.generation;
+            return (documentIds) => {
+                if (state.generation !== generation ||
+                    !state.armed ||
+                    !state.eligibleContainerIds.has(containerId) ||
+                    state.listedDocumentIdsByContainer.has(containerId)) {
+                    return;
+                }
+                state.listedDocumentIdsByContainer.set(containerId, new Set(documentIds));
+                state.listedDocumentIds = null;
+                state.listingAttemptsByContainer.delete(containerId);
+                state.listingRetryNotBeforeByContainer.delete(containerId);
+            };
+        },
+        canRun: () => canRun(state),
+        continuationDelayMs: () => continuationDelayMs(state),
+        hasPendingWork: () => state.armed && hasPendingWork(state),
+        resetPending: () => resetPending(state),
+        resetSkippedListings: () => resetSkippedListings(state),
+        run: () => runProbe(host, state),
+    };
+}
+//# sourceMappingURL=initialDocumentProbe.js.map