@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/stores/documents/documentStore/versionCoverage.js

@@ -0,0 +1,45 @@
+import { mergeVersionVectors, satisfiesVersionVector } from "../../../internal/loro/index.js";
+/**
+ * Extend a trusted coverage frontier through durable or remotely accepted
+ * update spans. A span is usable only when its start is already covered and
+ * its end belongs to the current document. Iterating to a fixed point lets a
+ * persisted queue restore coverage even when its rows are not topologically
+ * ordered.
+ *
+ * Invalid or disconnected spans are ignored. The caller can then materialize
+ * the remaining frontier instead of classifying unproven operations as safe.
+ */
+export function extendDocumentVersionCoverage(input) {
+    let coverage = mergeVersionVectors([input.baseVersion]);
+    if (!satisfiesVersionVector(input.documentVersion, coverage)) {
+        throw new Error("Document coverage base is outside the current snapshot");
+    }
+    const remaining = new Set(input.spans.keys());
+    let advanced = true;
+    while (advanced) {
+        advanced = false;
+        for (const index of remaining) {
+            const span = input.spans[index];
+            if (!span)
+                continue;
+            try {
+                const isConnected = satisfiesVersionVector(coverage, span.partialStartVersionVector);
+                const isWellFormed = satisfiesVersionVector(span.partialEndVersionVector, span.partialStartVersionVector);
+                const belongsToDocument = satisfiesVersionVector(input.documentVersion, span.partialEndVersionVector);
+                if (!isConnected || !isWellFormed || !belongsToDocument)
+                    continue;
+                coverage = mergeVersionVectors([
+                    coverage,
+                    span.partialEndVersionVector,
+                ]);
+                remaining.delete(index);
+                advanced = true;
+            }
+            catch {
+                remaining.delete(index);
+            }
+        }
+    }
+    return coverage;
+}
+//# sourceMappingURL=versionCoverage.js.map

package/stores/documents/documentStore/versionCoverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"versionCoverage.js","sourceRoot":"","sources":["versionCoverage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAO9E;;;;;;;;;GASG;AACH,MAAM,UAAU,6BAA6B,CAAC,KAI7C;IACC,IAAI,QAAQ,GAAG,mBAAmB,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IACxD,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,eAAe,EAAE,QAAQ,CAAC,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAE9C,IAAI,QAAQ,GAAG,IAAI,CAAC;IACpB,OAAO,QAAQ,EAAE,CAAC;QAChB,QAAQ,GAAG,KAAK,CAAC;QACjB,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,IAAI;gBAAE,SAAS;YAEpB,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,sBAAsB,CACxC,QAAQ,EACR,IAAI,CAAC,yBAAyB,CAC/B,CAAC;gBACF,MAAM,YAAY,GAAG,sBAAsB,CACzC,IAAI,CAAC,uBAAuB,EAC5B,IAAI,CAAC,yBAAyB,CAC/B,CAAC;gBACF,MAAM,iBAAiB,GAAG,sBAAsB,CAC9C,KAAK,CAAC,eAAe,EACrB,IAAI,CAAC,uBAAuB,CAC7B,CAAC;gBACF,IAAI,CAAC,WAAW,IAAI,CAAC,YAAY,IAAI,CAAC,iBAAiB;oBAAE,SAAS;gBAElE,QAAQ,GAAG,mBAAmB,CAAC;oBAC7B,QAAQ;oBACR,IAAI,CAAC,uBAAuB;iBAC7B,CAAC,CAAC;gBACH,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACxB,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;YAAC,MAAM,CAAC;gBACP,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["import { mergeVersionVectors, satisfiesVersionVector } from \"@tearleads/loro\";\n\ninterface DocumentVersionSpan {\n  readonly partialEndVersionVector: string;\n  readonly partialStartVersionVector: string;\n}\n\n/**\n * Extend a trusted coverage frontier through durable or remotely accepted\n * update spans. A span is usable only when its start is already covered and\n * its end belongs to the current document. Iterating to a fixed point lets a\n * persisted queue restore coverage even when its rows are not topologically\n * ordered.\n *\n * Invalid or disconnected spans are ignored. The caller can then materialize\n * the remaining frontier instead of classifying unproven operations as safe.\n */\nexport function extendDocumentVersionCoverage(input: {\n  readonly baseVersion: string;\n  readonly documentVersion: string;\n  readonly spans: readonly DocumentVersionSpan[];\n}): string {\n  let coverage = mergeVersionVectors([input.baseVersion]);\n  if (!satisfiesVersionVector(input.documentVersion, coverage)) {\n    throw new Error(\"Document coverage base is outside the current snapshot\");\n  }\n  const remaining = new Set(input.spans.keys());\n\n  let advanced = true;\n  while (advanced) {\n    advanced = false;\n    for (const index of remaining) {\n      const span = input.spans[index];\n      if (!span) continue;\n\n      try {\n        const isConnected = satisfiesVersionVector(\n          coverage,\n          span.partialStartVersionVector,\n        );\n        const isWellFormed = satisfiesVersionVector(\n          span.partialEndVersionVector,\n          span.partialStartVersionVector,\n        );\n        const belongsToDocument = satisfiesVersionVector(\n          input.documentVersion,\n          span.partialEndVersionVector,\n        );\n        if (!isConnected || !isWellFormed || !belongsToDocument) continue;\n\n        coverage = mergeVersionVectors([\n          coverage,\n          span.partialEndVersionVector,\n        ]);\n        remaining.delete(index);\n        advanced = true;\n      } catch {\n        remaining.delete(index);\n      }\n    }\n  }\n\n  return coverage;\n}\n"]}

package/stores/documents/documentStore/writerProjectionGeneration.js

@@ -0,0 +1,20 @@
+/**
+ * A realtime hint says a manifest this document's projection cites may have
+ * moved. Drop the held projection and advance the generation so an operation
+ * already in flight cannot reinstall what it fetched before the hint.
+ */
+export function invalidateDocumentWriterProjection(state) {
+    state.writerProjection = null;
+    state.writerProjectionGeneration += 1;
+}
+/**
+ * Install a projection an operation fetched or was handed back, unless a hint
+ * invalidated the document while that operation ran: its answer may predate
+ * the hint, so the slot stays empty and the next operation fetches fresh.
+ */
+export function installDocumentWriterProjection(state, projection, capturedGeneration) {
+    if (state.writerProjectionGeneration !== capturedGeneration)
+        return;
+    state.writerProjection = projection;
+}
+//# sourceMappingURL=writerProjectionGeneration.js.map

package/stores/documents/documentStore/writerProjectionGeneration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writerProjectionGeneration.js","sourceRoot":"","sources":["writerProjectionGeneration.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,UAAU,kCAAkC,CAChD,KAAyB;IAEzB,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAC9B,KAAK,CAAC,0BAA0B,IAAI,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAC7C,KAAyB,EACzB,UAAmD,EACnD,kBAA0B;IAE1B,IAAI,KAAK,CAAC,0BAA0B,KAAK,kBAAkB;QAAE,OAAO;IACpE,KAAK,CAAC,gBAAgB,GAAG,UAAU,CAAC;AACtC,CAAC","sourcesContent":["import type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport type { DocumentStoreState } from \"./state\";\n\n/**\n * A realtime hint says a manifest this document's projection cites may have\n * moved. Drop the held projection and advance the generation so an operation\n * already in flight cannot reinstall what it fetched before the hint.\n */\nexport function invalidateDocumentWriterProjection(\n  state: DocumentStoreState,\n): void {\n  state.writerProjection = null;\n  state.writerProjectionGeneration += 1;\n}\n\n/**\n * Install a projection an operation fetched or was handed back, unless a hint\n * invalidated the document while that operation ran: its answer may predate\n * the hint, so the slot stays empty and the next operation fetches fresh.\n */\nexport function installDocumentWriterProjection(\n  state: DocumentStoreState,\n  projection: DocumentWriterProjectionResponse | null,\n  capturedGeneration: number,\n): void {\n  if (state.writerProjectionGeneration !== capturedGeneration) return;\n  state.writerProjection = projection;\n}\n"]}

package/stores/documents/documentStore.d.ts

@@ -0,0 +1,8 @@
+import type { StoredDocumentKind } from "../../data/documents/documentKinds.js";
+import type { DomainScope } from "../../data/domainScope.js";
+import { type DocumentsPersistence } from "../../workflows/documents/index.js";
+import type { DocumentStore, DocumentStoreFacade, DocumentsRuntime } from "./types.js";
+export { discardRegisteredDocumentLocalState, requestDomainDocumentSync, subscribeToPersistedDocuments, } from "./registry.js";
+export declare function createDocumentStore(localId: string, initialRuntime: DocumentsRuntime, persistence?: DocumentsPersistence, initialDocumentId?: string | null, initialText?: string, initialDocumentKind?: StoredDocumentKind, remoteSyncMode?: "on-demand" | "startup"): DocumentStoreFacade;
+export declare function getOrCreateDocumentStore(domainScope: DomainScope, localId: string, runtime: DocumentsRuntime, initialDocumentId?: string | null, initialText?: string, initialDocumentKind?: StoredDocumentKind, remoteSyncMode?: "on-demand" | "startup"): DocumentStore;
+export declare function openDocumentStore(domainScope: DomainScope, localId: string, runtime: DocumentsRuntime, initialDocumentId?: string | null, initialText?: string, initialDocumentKind?: StoredDocumentKind, remoteSyncMode?: "on-demand" | "startup"): DocumentStore;

package/stores/documents/documentStore.js

@@ -0,0 +1,212 @@
+import { DEFAULT_DOCUMENT_KIND } from "../../data/documents/documentConstants.js";
+import { createDocumentProjectionUserKeyResolver, defaultDocumentsPersistence, didDocumentProjectionKeyRuntimeChange, didRegainSyncPrerequisites, requestDocumentSyncLaneAndWait, } from "../../workflows/documents/index.js";
+import { attachFilesToDocumentStore, removeAttachmentFromDocumentStore, replaceAttachmentInDocumentStore, } from "./documentStore/attachments.js";
+import { discardDocumentStoreLocalState } from "./documentStore/discard.js";
+import { ensureDocumentStoreInitialized, ensureDocumentStoreReady, relinkDocumentStore, } from "./documentStore/initialization.js";
+import { registerInternalDocumentRelink } from "./documentStore/internalRelink.js";
+import { setDocumentStructuredFields, setDocumentText, } from "./documentStore/mutations.js";
+import { logRevalidationScheduled } from "./documentStore/remoteRevalidationTelemetry.js";
+import { assertDocumentStoreCanRotateContentKey } from "./documentStore/rotation.js";
+import { addRowToDocumentStore, removeRowFromDocumentStore, updateRowInDocumentStore, } from "./documentStore/rows.js";
+import { createDocumentStoreState, refreshAttachabilitySnapshot, resetDocumentStore, subscribeToDocumentStore, } from "./documentStore/state.js";
+import { registerDocumentStoreSyncLane } from "./documentStore/sync.js";
+import { allowDocumentStoreRemoteSync, captureDocumentStoreRemoteSyncRequestGeneration, captureDocumentStoreSyncLaneGeneration, didDocumentStoreRemoteSyncRequestComplete, hasPendingIndependentDocumentStoreRemoteSync, invalidateDocumentStoreRemoteSync, invalidateDocumentStoreSyncLane, isDocumentStoreRemoteSyncBlocked, isDocumentStoreRemoteSyncRequestGenerationCurrent, markDocumentStoreRemoteSyncPending, registerDocumentStoreRemoteSyncWaiter, } from "./documentStore/syncGeneration.js";
+import { handleDocumentRemoteEvents } from "./documentStore/syncRemoteSignals.js";
+import { createDocumentStoreFacade, emitPersistedDocument, getOrCreateDocumentStoreRegistry, registerDocumentStore, registerDocumentStoreIdentity, requestDocumentStoreSync, resolveDocumentStoreKey, } from "./registry.js";
+export { discardRegisteredDocumentLocalState, requestDomainDocumentSync, subscribeToPersistedDocuments, } from "./registry.js";
+function refreshDocumentStoreSyncLane(state, force = false) {
+    if (!force && state.syncLane && !state.syncLane.isDisposed?.()) {
+        return;
+    }
+    if (state.syncLane) {
+        invalidateDocumentStoreSyncLane(state);
+    }
+    let syncLaneGeneration = null;
+    state.syncLane = registerDocumentStoreSyncLane(state, () => syncLaneGeneration);
+    syncLaneGeneration = captureDocumentStoreSyncLaneGeneration(state);
+}
+function updateDocumentStoreRuntime(state, nextRuntime, scheduleSync) {
+    const previousRuntime = state.runtime;
+    const serverEventsReconnected = (nextRuntime.state.serverEventsConnectionGeneration ?? 0) >
+        (previousRuntime.state.serverEventsConnectionGeneration ?? 0);
+    const domainScopeChanged = previousRuntime.state.domainScope !== nextRuntime.state.domainScope;
+    const projectionKeyRuntimeChanged = didDocumentProjectionKeyRuntimeChange(previousRuntime, nextRuntime);
+    if (projectionKeyRuntimeChanged) {
+        state.resolveProjectionUserKey =
+            createDocumentProjectionUserKeyResolver(nextRuntime);
+        state.writerProjection = null;
+    }
+    state.runtime = nextRuntime;
+    refreshDocumentStoreSyncLane(state, domainScopeChanged);
+    if (domainScopeChanged) {
+        state.locallyAcceptedUpdateIds = new Set();
+        state.remoteUpdatePending = false;
+        state.writerProjection = null;
+    }
+    if (nextRuntime.infra.dbStatus !== "ready") {
+        if (state.snapshot.ready || state.initialized || state.initializePromise) {
+            resetDocumentStore(state);
+        }
+        state.lastEventCount = nextRuntime.state.events.length;
+        return;
+    }
+    refreshAttachabilitySnapshot(state);
+    ensureDocumentStoreInitialized(state, scheduleSync);
+    handleDocumentRemoteEvents(state, scheduleSync);
+    if (state.snapshot.ready) {
+        if (serverEventsReconnected) {
+            // The invalidation stream is lossy while disconnected. Once the server
+            // has restored this session's interest baseline, every already-open
+            // remote document needs one HTTP probe to cover peer writes made during
+            // the gap. This also closes iOS background/resume reconnects where the
+            // native network source remained online throughout.
+            requestRemoteDocumentStoreSync(state, scheduleSync);
+            logRevalidationScheduled(state.runtime, "reconnect");
+        }
+        else if (didRegainSyncPrerequisites(previousRuntime, state.runtime)) {
+            scheduleSync();
+        }
+    }
+}
+function requestRemoteDocumentStoreSync(state, scheduleSync, owner = "independent") {
+    allowDocumentStoreRemoteSync(state);
+    const signalSequence = markDocumentStoreRemoteSyncPending(state, owner);
+    scheduleSync();
+    return signalSequence;
+}
+function requestOrdinaryDocumentStoreSync(state, scheduleSync) {
+    // A normal UI reopen is a fresh owner for remote-only work. It may recover
+    // a probe that an earlier, now-unmounted owner aborted.
+    if (isDocumentStoreRemoteSyncBlocked(state)) {
+        requestRemoteDocumentStoreSync(state, scheduleSync);
+        return;
+    }
+    scheduleSync();
+}
+function requestRemoteDocumentStoreSyncAndWait(state, scheduleSync, signal) {
+    let requestGeneration = null;
+    let requestedSignalSequence = 0;
+    let releaseWaiter = null;
+    const releaseRemoteSyncWaiter = (invalidate) => {
+        const releasedLastWaiter = releaseWaiter?.() ?? false;
+        if (invalidate &&
+            releasedLastWaiter &&
+            requestGeneration !== null &&
+            isDocumentStoreRemoteSyncRequestGenerationCurrent(state, requestGeneration) &&
+            !hasPendingIndependentDocumentStoreRemoteSync(state)) {
+            invalidateDocumentStoreRemoteSync(state);
+        }
+    };
+    // A coordinator can be disposed and recreated while this same-scope store
+    // remains registered. Refresh its handle before requesting work.
+    refreshDocumentStoreSyncLane(state);
+    return requestDocumentSyncLaneAndWait({
+        didCompleteRequest: () => requestGeneration !== null &&
+            didDocumentStoreRemoteSyncRequestComplete(state, requestGeneration, requestedSignalSequence),
+        domainScope: state.runtime.state.domainScope,
+        localId: state.localId,
+        request: () => {
+            requestGeneration =
+                captureDocumentStoreRemoteSyncRequestGeneration(state);
+            releaseWaiter = registerDocumentStoreRemoteSyncWaiter(state, requestGeneration);
+            requestedSignalSequence = requestRemoteDocumentStoreSync(state, scheduleSync, "waiter");
+        },
+        onInvalidated: () => releaseRemoteSyncWaiter(true),
+        signal,
+    }).then((completed) => {
+        releaseRemoteSyncWaiter(!completed);
+        return completed;
+    }, (error) => {
+        releaseRemoteSyncWaiter(true);
+        throw error;
+    });
+}
+async function assertBackingDocumentStoreCanRotate(state, scheduleSync) {
+    if (!(await ensureDocumentStoreReady(state, scheduleSync)) || !state.doc) {
+        throw new Error("Document must finish loading before its content key can rotate");
+    }
+    return assertDocumentStoreCanRotateContentKey(state);
+}
+async function discardBackingDocumentStoreLocalState(state, scheduleSync, expectedDocumentId) {
+    try {
+        return await discardDocumentStoreLocalState(state, expectedDocumentId);
+    }
+    finally {
+        // Restart hydration whenever the attempt reset the store. This runs outside
+        // its identity-chained task because initialization also chains writes.
+        ensureDocumentStoreInitialized(state, scheduleSync);
+        scheduleSync();
+    }
+}
+function createLiveSyncLaneRequest(state) {
+    return (request) => {
+        refreshDocumentStoreSyncLane(state);
+        return request();
+    };
+}
+function registerBackingStoreInternalRelink(input) {
+    registerInternalDocumentRelink(input.store, (relinkInput, commitSideEffect) => input.withLiveSyncLane(() => relinkDocumentStore(input.state, relinkInput, input.scheduleSync, commitSideEffect)));
+    return input.store;
+}
+function createBackingStoreContext(localId, runtime, persistence, documentId, text, documentKind, remoteSyncMode) {
+    const state = createDocumentStoreState(localId, runtime, persistence, {
+        emitPersistedDocument,
+        registerDocumentIdentity: registerDocumentStoreIdentity,
+    }, documentId, text, documentKind, remoteSyncMode === "startup");
+    refreshDocumentStoreSyncLane(state);
+    const scheduleSync = () => requestDocumentStoreSync(state);
+    return {
+        scheduleSync,
+        state,
+        withLiveSyncLane: createLiveSyncLaneRequest(state),
+    };
+}
+function createBackingDocumentStore(localId, initialRuntime, persistence = defaultDocumentsPersistence, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, remoteSyncMode = "startup") {
+    const { scheduleSync, state, withLiveSyncLane } = createBackingStoreContext(localId, initialRuntime, persistence, initialDocumentId, initialText, initialDocumentKind, remoteSyncMode);
+    const store = {
+        addRow: (fields) => withLiveSyncLane(() => addRowToDocumentStore(state, scheduleSync, fields)),
+        assertCanRotateContentKey: () => withLiveSyncLane(() => assertBackingDocumentStoreCanRotate(state, scheduleSync)),
+        attachFiles: (files) => withLiveSyncLane(() => attachFilesToDocumentStore(state, scheduleSync, files)),
+        discardLocalState: (expectedDocumentId) => withLiveSyncLane(() => discardBackingDocumentStoreLocalState(state, scheduleSync, expectedDocumentId)),
+        ensureInitialized: () => withLiveSyncLane(() => ensureDocumentStoreReady(state, scheduleSync)),
+        getSnapshot: () => state.snapshot,
+        removeAttachment: (slotId) => withLiveSyncLane(() => removeAttachmentFromDocumentStore(state, scheduleSync, slotId)),
+        removeRow: (id) => withLiveSyncLane(() => removeRowFromDocumentStore(state, scheduleSync, id)),
+        replaceAttachment: (slotId, file) => withLiveSyncLane(() => replaceAttachmentInDocumentStore(state, scheduleSync, slotId, file)),
+        requestRemoteSync: () => withLiveSyncLane(() => requestRemoteDocumentStoreSync(state, scheduleSync)),
+        requestRemoteSyncAndWait: (signal) => requestRemoteDocumentStoreSyncAndWait(state, scheduleSync, signal),
+        requestSync: () => withLiveSyncLane(() => requestOrdinaryDocumentStoreSync(state, scheduleSync)),
+        relink: (input) => withLiveSyncLane(() => relinkDocumentStore(state, input, scheduleSync)),
+        setStructuredFields: (kind, patch, options) => withLiveSyncLane(() => setDocumentStructuredFields(state, scheduleSync, kind, patch, options)),
+        setText: (value) => withLiveSyncLane(() => setDocumentText(state, scheduleSync, value)),
+        subscribe: (listener) => subscribeToDocumentStore(state, listener),
+        updateRowFields: (id, patch) => withLiveSyncLane(() => updateRowInDocumentStore(state, scheduleSync, id, patch)),
+        updateRuntime: (runtime) => updateDocumentStoreRuntime(state, runtime, scheduleSync),
+    };
+    return registerBackingStoreInternalRelink({
+        scheduleSync,
+        state,
+        store,
+        withLiveSyncLane,
+    });
+}
+export function createDocumentStore(localId, initialRuntime, persistence = defaultDocumentsPersistence, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, remoteSyncMode = "startup") {
+    return createDocumentStoreFacade(createBackingDocumentStore(localId, initialRuntime, persistence, initialDocumentId, initialText, initialDocumentKind, remoteSyncMode));
+}
+export function getOrCreateDocumentStore(domainScope, localId, runtime, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, remoteSyncMode = "startup") {
+    const registry = getOrCreateDocumentStoreRegistry(domainScope);
+    const existingStore = registry.storesByKey.get(resolveDocumentStoreKey(registry, localId, initialDocumentId));
+    if (existingStore) {
+        registerDocumentStore(domainScope, localId, existingStore, initialDocumentId);
+        return existingStore;
+    }
+    const nextStore = createDocumentStore(localId, runtime, defaultDocumentsPersistence, initialDocumentId, initialText, initialDocumentKind, remoteSyncMode);
+    registerDocumentStore(domainScope, localId, nextStore, initialDocumentId);
+    return nextStore;
+}
+export function openDocumentStore(domainScope, localId, runtime, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, remoteSyncMode = "startup") {
+    const store = getOrCreateDocumentStore(domainScope, localId, runtime, initialDocumentId, initialText, initialDocumentKind, remoteSyncMode);
+    store.updateRuntime(runtime);
+    return store;
+}
+//# sourceMappingURL=documentStore.js.map

package/stores/documents/documentStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentStore.js","sourceRoot":"","sources":["documentStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAG/E,OAAO,EACL,uCAAuC,EAEvC,2BAA2B,EAC3B,qCAAqC,EACrC,0BAA0B,EAC1B,8BAA8B,GAC/B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,0BAA0B,EAC1B,iCAAiC,EACjC,gCAAgC,GACjC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EACL,8BAA8B,EAC9B,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EACL,2BAA2B,EAC3B,eAAe,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,wBAAwB,EAAE,MAAM,6CAA6C,CAAC;AACvF,OAAO,EAAE,sCAAsC,EAAE,MAAM,0BAA0B,CAAC;AAClF,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,wBAAwB,EAExB,4BAA4B,EAC5B,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EACL,4BAA4B,EAC5B,+CAA+C,EAC/C,sCAAsC,EAGtC,yCAAyC,EACzC,4CAA4C,EAC5C,iCAAiC,EACjC,+BAA+B,EAC/B,gCAAgC,EAChC,iDAAiD,EACjD,kCAAkC,EAClC,qCAAqC,GACtC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,gCAAgC,EAChC,qBAAqB,EACrB,6BAA6B,EAC7B,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAQpB,OAAO,EACL,mCAAmC,EACnC,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,YAAY,CAAC;AAEpB,SAAS,4BAA4B,CACnC,KAAyB,EACzB,KAAK,GAAG,KAAK;IAEb,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,EAAE,CAAC;QAC/D,OAAO;IACT,CAAC;IACD,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACnB,+BAA+B,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IACD,IAAI,kBAAkB,GAA2C,IAAI,CAAC;IACtE,KAAK,CAAC,QAAQ,GAAG,6BAA6B,CAC5C,KAAK,EACL,GAAG,EAAE,CAAC,kBAAkB,CACzB,CAAC;IACF,kBAAkB,GAAG,sCAAsC,CAAC,KAAK,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,0BAA0B,CACjC,KAAyB,EACzB,WAA6B,EAC7B,YAAwB;IAExB,MAAM,eAAe,GAAG,KAAK,CAAC,OAAO,CAAC;IACtC,MAAM,uBAAuB,GAC3B,CAAC,WAAW,CAAC,KAAK,CAAC,gCAAgC,IAAI,CAAC,CAAC;QACzD,CAAC,eAAe,CAAC,KAAK,CAAC,gCAAgC,IAAI,CAAC,CAAC,CAAC;IAChE,MAAM,kBAAkB,GACtB,eAAe,CAAC,KAAK,CAAC,WAAW,KAAK,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC;IACtE,MAAM,2BAA2B,GAAG,qCAAqC,CACvE,eAAe,EACf,WAAW,CACZ,CAAC;IACF,IAAI,2BAA2B,EAAE,CAAC;QAChC,KAAK,CAAC,wBAAwB;YAC5B,uCAAuC,CAAC,WAAW,CAAC,CAAC;QACvD,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAChC,CAAC;IACD,KAAK,CAAC,OAAO,GAAG,WAAW,CAAC;IAC5B,4BAA4B,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;IACxD,IAAI,kBAAkB,EAAE,CAAC;QACvB,KAAK,CAAC,wBAAwB,GAAG,IAAI,GAAG,EAAE,CAAC;QAC3C,KAAK,CAAC,mBAAmB,GAAG,KAAK,CAAC;QAClC,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,IAAI,WAAW,CAAC,KAAK,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;QAC3C,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;YACzE,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QACD,KAAK,CAAC,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;QACvD,OAAO;IACT,CAAC;IAED,4BAA4B,CAAC,KAAK,CAAC,CAAC;IACpC,8BAA8B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACpD,0BAA0B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IAEhD,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,uBAAuB,EAAE,CAAC;YAC5B,uEAAuE;YACvE,oEAAoE;YACpE,wEAAwE;YACxE,uEAAuE;YACvE,oDAAoD;YACpD,8BAA8B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;YACpD,wBAAwB,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACvD,CAAC;aAAM,IAAI,0BAA0B,CAAC,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YACtE,YAAY,EAAE,CAAC;QACjB,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,8BAA8B,CACrC,KAAyB,EACzB,YAAwB,EACxB,QAAkC,aAAa;IAE/C,4BAA4B,CAAC,KAAK,CAAC,CAAC;IACpC,MAAM,cAAc,GAAG,kCAAkC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxE,YAAY,EAAE,CAAC;IACf,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,SAAS,gCAAgC,CACvC,KAAyB,EACzB,YAAwB;IAExB,2EAA2E;IAC3E,wDAAwD;IACxD,IAAI,gCAAgC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5C,8BAA8B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QACpD,OAAO;IACT,CAAC;IACD,YAAY,EAAE,CAAC;AACjB,CAAC;AAED,SAAS,qCAAqC,CAC5C,KAAyB,EACzB,YAAwB,EACxB,MAAoB;IAEpB,IAAI,iBAAiB,GAAoD,IAAI,CAAC;IAC9E,IAAI,uBAAuB,GAAG,CAAC,CAAC;IAChC,IAAI,aAAa,GAA2B,IAAI,CAAC;IACjD,MAAM,uBAAuB,GAAG,CAAC,UAAmB,EAAE,EAAE;QACtD,MAAM,kBAAkB,GAAG,aAAa,EAAE,EAAE,IAAI,KAAK,CAAC;QACtD,IACE,UAAU;YACV,kBAAkB;YAClB,iBAAiB,KAAK,IAAI;YAC1B,iDAAiD,CAC/C,KAAK,EACL,iBAAiB,CAClB;YACD,CAAC,4CAA4C,CAAC,KAAK,CAAC,EACpD,CAAC;YACD,iCAAiC,CAAC,KAAK,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC,CAAC;IACF,0EAA0E;IAC1E,iEAAiE;IACjE,4BAA4B,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,8BAA8B,CAAC;QACpC,kBAAkB,EAAE,GAAG,EAAE,CACvB,iBAAiB,KAAK,IAAI;YAC1B,yCAAyC,CACvC,KAAK,EACL,iBAAiB,EACjB,uBAAuB,CACxB;QACH,WAAW,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW;QAC5C,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,OAAO,EAAE,GAAG,EAAE;YACZ,iBAAiB;gBACf,+CAA+C,CAAC,KAAK,CAAC,CAAC;YACzD,aAAa,GAAG,qCAAqC,CACnD,KAAK,EACL,iBAAiB,CAClB,CAAC;YACF,uBAAuB,GAAG,8BAA8B,CACtD,KAAK,EACL,YAAY,EACZ,QAAQ,CACT,CAAC;QACJ,CAAC;QACD,aAAa,EAAE,GAAG,EAAE,CAAC,uBAAuB,CAAC,IAAI,CAAC;QAClD,MAAM;KACP,CAAC,CAAC,IAAI,CACL,CAAC,SAAS,EAAE,EAAE;QACZ,uBAAuB,CAAC,CAAC,SAAS,CAAC,CAAC;QACpC,OAAO,SAAS,CAAC;IACnB,CAAC,EACD,CAAC,KAAc,EAAE,EAAE;QACjB,uBAAuB,CAAC,IAAI,CAAC,CAAC;QAC9B,MAAM,KAAK,CAAC;IACd,CAAC,CACF,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,mCAAmC,CAChD,KAAyB,EACzB,YAAwB;IAExB,IAAI,CAAC,CAAC,MAAM,wBAAwB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QACzE,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;IACJ,CAAC;IACD,OAAO,sCAAsC,CAAC,KAAK,CAAC,CAAC;AACvD,CAAC;AAED,KAAK,UAAU,qCAAqC,CAClD,KAAyB,EACzB,YAAwB,EACxB,kBAA0B;IAE1B,IAAI,CAAC;QACH,OAAO,MAAM,8BAA8B,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;IACzE,CAAC;YAAS,CAAC;QACT,4EAA4E;QAC5E,uEAAuE;QACvE,8BAA8B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QACpD,YAAY,EAAE,CAAC;IACjB,CAAC;AACH,CAAC;AAED,SAAS,yBAAyB,CAAC,KAAyB;IAC1D,OAAO,CAAS,OAAqB,EAAU,EAAE;QAC/C,4BAA4B,CAAC,KAAK,CAAC,CAAC;QACpC,OAAO,OAAO,EAAE,CAAC;IACnB,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,kCAAkC,CAAC,KAK3C;IACC,8BAA8B,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,gBAAgB,EAAE,EAAE,CAC5E,KAAK,CAAC,gBAAgB,CAAC,GAAG,EAAE,CAC1B,mBAAmB,CACjB,KAAK,CAAC,KAAK,EACX,WAAW,EACX,KAAK,CAAC,YAAY,EAClB,gBAAgB,CACjB,CACF,CACF,CAAC;IACF,OAAO,KAAK,CAAC,KAAK,CAAC;AACrB,CAAC;AAED,SAAS,yBAAyB,CAChC,OAAe,EACf,OAAyB,EACzB,WAAiC,EACjC,UAAyB,EACzB,IAAY,EACZ,YAAgC,EAChC,cAAuC;IAEvC,MAAM,KAAK,GAAG,wBAAwB,CACpC,OAAO,EACP,OAAO,EACP,WAAW,EACX;QACE,qBAAqB;QACrB,wBAAwB,EAAE,6BAA6B;KACxD,EACD,UAAU,EACV,IAAI,EACJ,YAAY,EACZ,cAAc,KAAK,SAAS,CAC7B,CAAC;IACF,4BAA4B,CAAC,KAAK,CAAC,CAAC;IACpC,MAAM,YAAY,GAAG,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;IAC3D,OAAO;QACL,YAAY;QACZ,KAAK;QACL,gBAAgB,EAAE,yBAAyB,CAAC,KAAK,CAAC;KACnD,CAAC;AACJ,CAAC;AAED,SAAS,0BAA0B,CACjC,OAAe,EACf,cAAgC,EAChC,cAAoC,2BAA2B,EAC/D,oBAAmC,IAAI,EACvC,WAAW,GAAG,EAAE,EAChB,sBAA0C,qBAAqB,EAC/D,iBAA0C,SAAS;IAEnD,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,gBAAgB,EAAE,GAAG,yBAAyB,CACzE,OAAO,EACP,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,cAAc,CACf,CAAC;IAEF,MAAM,KAAK,GAAkB;QAC3B,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,CACjB,gBAAgB,CAAC,GAAG,EAAE,CACpB,qBAAqB,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,CACnD;QACH,yBAAyB,EAAE,GAAG,EAAE,CAC9B,gBAAgB,CAAC,GAAG,EAAE,CACpB,mCAAmC,CAAC,KAAK,EAAE,YAAY,CAAC,CACzD;QACH,WAAW,EAAE,CAAC,KAA8C,EAAE,EAAE,CAC9D,gBAAgB,CAAC,GAAG,EAAE,CACpB,0BAA0B,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,CAAC,CACvD;QACH,iBAAiB,EAAE,CAAC,kBAA0B,EAAE,EAAE,CAChD,gBAAgB,CAAC,GAAG,EAAE,CACpB,qCAAqC,CACnC,KAAK,EACL,YAAY,EACZ,kBAAkB,CACnB,CACF;QACH,iBAAiB,EAAE,GAAG,EAAE,CACtB,gBAAgB,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QACvE,WAAW,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,QAAQ;QACjC,gBAAgB,EAAE,CAAC,MAAc,EAAE,EAAE,CACnC,gBAAgB,CAAC,GAAG,EAAE,CACpB,iCAAiC,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,CAC/D;QACH,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,CAChB,gBAAgB,CAAC,GAAG,EAAE,CACpB,0BAA0B,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,CAAC,CACpD;QACH,iBAAiB,EAAE,CAAC,MAAc,EAAE,IAA8B,EAAE,EAAE,CACpE,gBAAgB,CAAC,GAAG,EAAE,CACpB,gCAAgC,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,CAAC,CACpE;QACH,iBAAiB,EAAE,GAAG,EAAE,CACtB,gBAAgB,CAAC,GAAG,EAAE,CACpB,8BAA8B,CAAC,KAAK,EAAE,YAAY,CAAC,CACpD;QACH,wBAAwB,EAAE,CAAC,MAAM,EAAE,EAAE,CACnC,qCAAqC,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC;QACpE,WAAW,EAAE,GAAG,EAAE,CAChB,gBAAgB,CAAC,GAAG,EAAE,CACpB,gCAAgC,CAAC,KAAK,EAAE,YAAY,CAAC,CACtD;QACH,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAChB,gBAAgB,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;QACzE,mBAAmB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,CAC5C,gBAAgB,CAAC,GAAG,EAAE,CACpB,2BAA2B,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CACvE;QACH,OAAO,EAAE,CAAC,KAAa,EAAE,EAAE,CACzB,gBAAgB,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC;QACrE,SAAS,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,wBAAwB,CAAC,KAAK,EAAE,QAAQ,CAAC;QAClE,eAAe,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,CAC7B,gBAAgB,CAAC,GAAG,EAAE,CACpB,wBAAwB,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,KAAK,CAAC,CACzD;QACH,aAAa,EAAE,CAAC,OAAyB,EAAE,EAAE,CAC3C,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,CAAC;KAC3D,CAAC;IACF,OAAO,kCAAkC,CAAC;QACxC,YAAY;QACZ,KAAK;QACL,KAAK;QACL,gBAAgB;KACjB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,mBAAmB,CACjC,OAAe,EACf,cAAgC,EAChC,cAAoC,2BAA2B,EAC/D,oBAAmC,IAAI,EACvC,WAAW,GAAG,EAAE,EAChB,sBAA0C,qBAAqB,EAC/D,iBAA0C,SAAS;IAEnD,OAAO,yBAAyB,CAC9B,0BAA0B,CACxB,OAAO,EACP,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,cAAc,CACf,CACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,wBAAwB,CACtC,WAAwB,EACxB,OAAe,EACf,OAAyB,EACzB,oBAAmC,IAAI,EACvC,WAAW,GAAG,EAAE,EAChB,sBAA0C,qBAAqB,EAC/D,iBAA0C,SAAS;IAEnD,MAAM,QAAQ,GAAG,gCAAgC,CAAC,WAAW,CAAC,CAAC;IAC/D,MAAM,aAAa,GAAG,QAAQ,CAAC,WAAW,CAAC,GAAG,CAC5C,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAC9D,CAAC;IACF,IAAI,aAAa,EAAE,CAAC;QAClB,qBAAqB,CACnB,WAAW,EACX,OAAO,EACP,aAAa,EACb,iBAAiB,CAClB,CAAC;QACF,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,MAAM,SAAS,GAAG,mBAAmB,CACnC,OAAO,EACP,OAAO,EACP,2BAA2B,EAC3B,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,cAAc,CACf,CAAC;IACF,qBAAqB,CAAC,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC;IAC1E,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,iBAAiB,CAC/B,WAAwB,EACxB,OAAe,EACf,OAAyB,EACzB,oBAAmC,IAAI,EACvC,WAAW,GAAG,EAAE,EAChB,sBAA0C,qBAAqB,EAC/D,iBAA0C,SAAS;IAEnD,MAAM,KAAK,GAAG,wBAAwB,CACpC,WAAW,EACX,OAAO,EACP,OAAO,EACP,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,cAAc,CACf,CAAC;IACF,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import { DEFAULT_DOCUMENT_KIND } from \"../../data/documents/documentConstants\";\nimport type { StoredDocumentKind } from \"../../data/documents/documentKinds\";\nimport type { DomainScope } from \"../../data/domainScope\";\nimport {\n  createDocumentProjectionUserKeyResolver,\n  type DocumentsPersistence,\n  defaultDocumentsPersistence,\n  didDocumentProjectionKeyRuntimeChange,\n  didRegainSyncPrerequisites,\n  requestDocumentSyncLaneAndWait,\n} from \"../../workflows/documents\";\nimport {\n  attachFilesToDocumentStore,\n  removeAttachmentFromDocumentStore,\n  replaceAttachmentInDocumentStore,\n} from \"./documentStore/attachments\";\nimport { discardDocumentStoreLocalState } from \"./documentStore/discard\";\nimport {\n  ensureDocumentStoreInitialized,\n  ensureDocumentStoreReady,\n  relinkDocumentStore,\n} from \"./documentStore/initialization\";\nimport { registerInternalDocumentRelink } from \"./documentStore/internalRelink\";\nimport {\n  setDocumentStructuredFields,\n  setDocumentText,\n} from \"./documentStore/mutations\";\nimport { logRevalidationScheduled } from \"./documentStore/remoteRevalidationTelemetry\";\nimport { assertDocumentStoreCanRotateContentKey } from \"./documentStore/rotation\";\nimport {\n  addRowToDocumentStore,\n  removeRowFromDocumentStore,\n  updateRowInDocumentStore,\n} from \"./documentStore/rows\";\nimport {\n  createDocumentStoreState,\n  type DocumentStoreState,\n  refreshAttachabilitySnapshot,\n  resetDocumentStore,\n  subscribeToDocumentStore,\n} from \"./documentStore/state\";\nimport { registerDocumentStoreSyncLane } from \"./documentStore/sync\";\nimport {\n  allowDocumentStoreRemoteSync,\n  captureDocumentStoreRemoteSyncRequestGeneration,\n  captureDocumentStoreSyncLaneGeneration,\n  type DocumentStoreRemoteSyncRequestGeneration,\n  type DocumentStoreSyncLaneGeneration,\n  didDocumentStoreRemoteSyncRequestComplete,\n  hasPendingIndependentDocumentStoreRemoteSync,\n  invalidateDocumentStoreRemoteSync,\n  invalidateDocumentStoreSyncLane,\n  isDocumentStoreRemoteSyncBlocked,\n  isDocumentStoreRemoteSyncRequestGenerationCurrent,\n  markDocumentStoreRemoteSyncPending,\n  registerDocumentStoreRemoteSyncWaiter,\n} from \"./documentStore/syncGeneration\";\nimport { handleDocumentRemoteEvents } from \"./documentStore/syncRemoteSignals\";\nimport {\n  createDocumentStoreFacade,\n  emitPersistedDocument,\n  getOrCreateDocumentStoreRegistry,\n  registerDocumentStore,\n  registerDocumentStoreIdentity,\n  requestDocumentStoreSync,\n  resolveDocumentStoreKey,\n} from \"./registry\";\nimport type {\n  DocumentAttachmentUpload,\n  DocumentStore,\n  DocumentStoreFacade,\n  DocumentsRuntime,\n} from \"./types\";\n\nexport {\n  discardRegisteredDocumentLocalState,\n  requestDomainDocumentSync,\n  subscribeToPersistedDocuments,\n} from \"./registry\";\n\nfunction refreshDocumentStoreSyncLane(\n  state: DocumentStoreState,\n  force = false,\n): void {\n  if (!force && state.syncLane && !state.syncLane.isDisposed?.()) {\n    return;\n  }\n  if (state.syncLane) {\n    invalidateDocumentStoreSyncLane(state);\n  }\n  let syncLaneGeneration: DocumentStoreSyncLaneGeneration | null = null;\n  state.syncLane = registerDocumentStoreSyncLane(\n    state,\n    () => syncLaneGeneration,\n  );\n  syncLaneGeneration = captureDocumentStoreSyncLaneGeneration(state);\n}\n\nfunction updateDocumentStoreRuntime(\n  state: DocumentStoreState,\n  nextRuntime: DocumentsRuntime,\n  scheduleSync: () => void,\n) {\n  const previousRuntime = state.runtime;\n  const serverEventsReconnected =\n    (nextRuntime.state.serverEventsConnectionGeneration ?? 0) >\n    (previousRuntime.state.serverEventsConnectionGeneration ?? 0);\n  const domainScopeChanged =\n    previousRuntime.state.domainScope !== nextRuntime.state.domainScope;\n  const projectionKeyRuntimeChanged = didDocumentProjectionKeyRuntimeChange(\n    previousRuntime,\n    nextRuntime,\n  );\n  if (projectionKeyRuntimeChanged) {\n    state.resolveProjectionUserKey =\n      createDocumentProjectionUserKeyResolver(nextRuntime);\n    state.writerProjection = null;\n  }\n  state.runtime = nextRuntime;\n  refreshDocumentStoreSyncLane(state, domainScopeChanged);\n  if (domainScopeChanged) {\n    state.locallyAcceptedUpdateIds = new Set();\n    state.remoteUpdatePending = false;\n    state.writerProjection = null;\n  }\n\n  if (nextRuntime.infra.dbStatus !== \"ready\") {\n    if (state.snapshot.ready || state.initialized || state.initializePromise) {\n      resetDocumentStore(state);\n    }\n    state.lastEventCount = nextRuntime.state.events.length;\n    return;\n  }\n\n  refreshAttachabilitySnapshot(state);\n  ensureDocumentStoreInitialized(state, scheduleSync);\n  handleDocumentRemoteEvents(state, scheduleSync);\n\n  if (state.snapshot.ready) {\n    if (serverEventsReconnected) {\n      // The invalidation stream is lossy while disconnected. Once the server\n      // has restored this session's interest baseline, every already-open\n      // remote document needs one HTTP probe to cover peer writes made during\n      // the gap. This also closes iOS background/resume reconnects where the\n      // native network source remained online throughout.\n      requestRemoteDocumentStoreSync(state, scheduleSync);\n      logRevalidationScheduled(state.runtime, \"reconnect\");\n    } else if (didRegainSyncPrerequisites(previousRuntime, state.runtime)) {\n      scheduleSync();\n    }\n  }\n}\n\nfunction requestRemoteDocumentStoreSync(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  owner: \"independent\" | \"waiter\" = \"independent\",\n): number {\n  allowDocumentStoreRemoteSync(state);\n  const signalSequence = markDocumentStoreRemoteSyncPending(state, owner);\n  scheduleSync();\n  return signalSequence;\n}\n\nfunction requestOrdinaryDocumentStoreSync(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n): void {\n  // A normal UI reopen is a fresh owner for remote-only work. It may recover\n  // a probe that an earlier, now-unmounted owner aborted.\n  if (isDocumentStoreRemoteSyncBlocked(state)) {\n    requestRemoteDocumentStoreSync(state, scheduleSync);\n    return;\n  }\n  scheduleSync();\n}\n\nfunction requestRemoteDocumentStoreSyncAndWait(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  signal?: AbortSignal,\n): Promise<boolean> {\n  let requestGeneration: DocumentStoreRemoteSyncRequestGeneration | null = null;\n  let requestedSignalSequence = 0;\n  let releaseWaiter: (() => boolean) | null = null;\n  const releaseRemoteSyncWaiter = (invalidate: boolean) => {\n    const releasedLastWaiter = releaseWaiter?.() ?? false;\n    if (\n      invalidate &&\n      releasedLastWaiter &&\n      requestGeneration !== null &&\n      isDocumentStoreRemoteSyncRequestGenerationCurrent(\n        state,\n        requestGeneration,\n      ) &&\n      !hasPendingIndependentDocumentStoreRemoteSync(state)\n    ) {\n      invalidateDocumentStoreRemoteSync(state);\n    }\n  };\n  // A coordinator can be disposed and recreated while this same-scope store\n  // remains registered. Refresh its handle before requesting work.\n  refreshDocumentStoreSyncLane(state);\n  return requestDocumentSyncLaneAndWait({\n    didCompleteRequest: () =>\n      requestGeneration !== null &&\n      didDocumentStoreRemoteSyncRequestComplete(\n        state,\n        requestGeneration,\n        requestedSignalSequence,\n      ),\n    domainScope: state.runtime.state.domainScope,\n    localId: state.localId,\n    request: () => {\n      requestGeneration =\n        captureDocumentStoreRemoteSyncRequestGeneration(state);\n      releaseWaiter = registerDocumentStoreRemoteSyncWaiter(\n        state,\n        requestGeneration,\n      );\n      requestedSignalSequence = requestRemoteDocumentStoreSync(\n        state,\n        scheduleSync,\n        \"waiter\",\n      );\n    },\n    onInvalidated: () => releaseRemoteSyncWaiter(true),\n    signal,\n  }).then(\n    (completed) => {\n      releaseRemoteSyncWaiter(!completed);\n      return completed;\n    },\n    (error: unknown) => {\n      releaseRemoteSyncWaiter(true);\n      throw error;\n    },\n  );\n}\n\nasync function assertBackingDocumentStoreCanRotate(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n) {\n  if (!(await ensureDocumentStoreReady(state, scheduleSync)) || !state.doc) {\n    throw new Error(\n      \"Document must finish loading before its content key can rotate\",\n    );\n  }\n  return assertDocumentStoreCanRotateContentKey(state);\n}\n\nasync function discardBackingDocumentStoreLocalState(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  expectedDocumentId: string,\n) {\n  try {\n    return await discardDocumentStoreLocalState(state, expectedDocumentId);\n  } finally {\n    // Restart hydration whenever the attempt reset the store. This runs outside\n    // its identity-chained task because initialization also chains writes.\n    ensureDocumentStoreInitialized(state, scheduleSync);\n    scheduleSync();\n  }\n}\n\nfunction createLiveSyncLaneRequest(state: DocumentStoreState) {\n  return <Result>(request: () => Result): Result => {\n    refreshDocumentStoreSyncLane(state);\n    return request();\n  };\n}\n\nfunction registerBackingStoreInternalRelink(input: {\n  scheduleSync: () => void;\n  state: DocumentStoreState;\n  store: DocumentStore;\n  withLiveSyncLane: ReturnType<typeof createLiveSyncLaneRequest>;\n}): DocumentStore {\n  registerInternalDocumentRelink(input.store, (relinkInput, commitSideEffect) =>\n    input.withLiveSyncLane(() =>\n      relinkDocumentStore(\n        input.state,\n        relinkInput,\n        input.scheduleSync,\n        commitSideEffect,\n      ),\n    ),\n  );\n  return input.store;\n}\n\nfunction createBackingStoreContext(\n  localId: string,\n  runtime: DocumentsRuntime,\n  persistence: DocumentsPersistence,\n  documentId: string | null,\n  text: string,\n  documentKind: StoredDocumentKind,\n  remoteSyncMode: \"on-demand\" | \"startup\",\n) {\n  const state = createDocumentStoreState(\n    localId,\n    runtime,\n    persistence,\n    {\n      emitPersistedDocument,\n      registerDocumentIdentity: registerDocumentStoreIdentity,\n    },\n    documentId,\n    text,\n    documentKind,\n    remoteSyncMode === \"startup\",\n  );\n  refreshDocumentStoreSyncLane(state);\n  const scheduleSync = () => requestDocumentStoreSync(state);\n  return {\n    scheduleSync,\n    state,\n    withLiveSyncLane: createLiveSyncLaneRequest(state),\n  };\n}\n\nfunction createBackingDocumentStore(\n  localId: string,\n  initialRuntime: DocumentsRuntime,\n  persistence: DocumentsPersistence = defaultDocumentsPersistence,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  remoteSyncMode: \"on-demand\" | \"startup\" = \"startup\",\n): DocumentStore {\n  const { scheduleSync, state, withLiveSyncLane } = createBackingStoreContext(\n    localId,\n    initialRuntime,\n    persistence,\n    initialDocumentId,\n    initialText,\n    initialDocumentKind,\n    remoteSyncMode,\n  );\n\n  const store: DocumentStore = {\n    addRow: (fields) =>\n      withLiveSyncLane(() =>\n        addRowToDocumentStore(state, scheduleSync, fields),\n      ),\n    assertCanRotateContentKey: () =>\n      withLiveSyncLane(() =>\n        assertBackingDocumentStoreCanRotate(state, scheduleSync),\n      ),\n    attachFiles: (files: ReadonlyArray<DocumentAttachmentUpload>) =>\n      withLiveSyncLane(() =>\n        attachFilesToDocumentStore(state, scheduleSync, files),\n      ),\n    discardLocalState: (expectedDocumentId: string) =>\n      withLiveSyncLane(() =>\n        discardBackingDocumentStoreLocalState(\n          state,\n          scheduleSync,\n          expectedDocumentId,\n        ),\n      ),\n    ensureInitialized: () =>\n      withLiveSyncLane(() => ensureDocumentStoreReady(state, scheduleSync)),\n    getSnapshot: () => state.snapshot,\n    removeAttachment: (slotId: string) =>\n      withLiveSyncLane(() =>\n        removeAttachmentFromDocumentStore(state, scheduleSync, slotId),\n      ),\n    removeRow: (id) =>\n      withLiveSyncLane(() =>\n        removeRowFromDocumentStore(state, scheduleSync, id),\n      ),\n    replaceAttachment: (slotId: string, file: DocumentAttachmentUpload) =>\n      withLiveSyncLane(() =>\n        replaceAttachmentInDocumentStore(state, scheduleSync, slotId, file),\n      ),\n    requestRemoteSync: () =>\n      withLiveSyncLane(() =>\n        requestRemoteDocumentStoreSync(state, scheduleSync),\n      ),\n    requestRemoteSyncAndWait: (signal) =>\n      requestRemoteDocumentStoreSyncAndWait(state, scheduleSync, signal),\n    requestSync: () =>\n      withLiveSyncLane(() =>\n        requestOrdinaryDocumentStoreSync(state, scheduleSync),\n      ),\n    relink: (input) =>\n      withLiveSyncLane(() => relinkDocumentStore(state, input, scheduleSync)),\n    setStructuredFields: (kind, patch, options) =>\n      withLiveSyncLane(() =>\n        setDocumentStructuredFields(state, scheduleSync, kind, patch, options),\n      ),\n    setText: (value: string) =>\n      withLiveSyncLane(() => setDocumentText(state, scheduleSync, value)),\n    subscribe: (listener) => subscribeToDocumentStore(state, listener),\n    updateRowFields: (id, patch) =>\n      withLiveSyncLane(() =>\n        updateRowInDocumentStore(state, scheduleSync, id, patch),\n      ),\n    updateRuntime: (runtime: DocumentsRuntime) =>\n      updateDocumentStoreRuntime(state, runtime, scheduleSync),\n  };\n  return registerBackingStoreInternalRelink({\n    scheduleSync,\n    state,\n    store,\n    withLiveSyncLane,\n  });\n}\n\nexport function createDocumentStore(\n  localId: string,\n  initialRuntime: DocumentsRuntime,\n  persistence: DocumentsPersistence = defaultDocumentsPersistence,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  remoteSyncMode: \"on-demand\" | \"startup\" = \"startup\",\n): DocumentStoreFacade {\n  return createDocumentStoreFacade(\n    createBackingDocumentStore(\n      localId,\n      initialRuntime,\n      persistence,\n      initialDocumentId,\n      initialText,\n      initialDocumentKind,\n      remoteSyncMode,\n    ),\n  );\n}\n\nexport function getOrCreateDocumentStore(\n  domainScope: DomainScope,\n  localId: string,\n  runtime: DocumentsRuntime,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  remoteSyncMode: \"on-demand\" | \"startup\" = \"startup\",\n): DocumentStore {\n  const registry = getOrCreateDocumentStoreRegistry(domainScope);\n  const existingStore = registry.storesByKey.get(\n    resolveDocumentStoreKey(registry, localId, initialDocumentId),\n  );\n  if (existingStore) {\n    registerDocumentStore(\n      domainScope,\n      localId,\n      existingStore,\n      initialDocumentId,\n    );\n    return existingStore;\n  }\n\n  const nextStore = createDocumentStore(\n    localId,\n    runtime,\n    defaultDocumentsPersistence,\n    initialDocumentId,\n    initialText,\n    initialDocumentKind,\n    remoteSyncMode,\n  );\n  registerDocumentStore(domainScope, localId, nextStore, initialDocumentId);\n  return nextStore;\n}\n\nexport function openDocumentStore(\n  domainScope: DomainScope,\n  localId: string,\n  runtime: DocumentsRuntime,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  remoteSyncMode: \"on-demand\" | \"startup\" = \"startup\",\n): DocumentStore {\n  const store = getOrCreateDocumentStore(\n    domainScope,\n    localId,\n    runtime,\n    initialDocumentId,\n    initialText,\n    initialDocumentKind,\n    remoteSyncMode,\n  );\n  store.updateRuntime(runtime);\n  return store;\n}\n"]}

package/stores/documents/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./documentStore.js";
+export * from "./types.js";

package/stores/documents/index.js

@@ -0,0 +1,3 @@
+export * from "./documentStore.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/stores/documents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC","sourcesContent":["export * from \"./documentStore\";\nexport * from \"./types\";\n"]}

package/stores/documents/registry.d.ts

@@ -0,0 +1,43 @@
+import type { DomainScope } from "../../data/domainScope.js";
+import type { DocumentStore, DocumentStoreFacade, PersistedDocumentListener } from "./types.js";
+interface DocumentStoreRegistry {
+    storeKeysByDocumentId: Map<string, string>;
+    storeKeysByLocalId: Map<string, string>;
+    storesByKey: Map<string, DocumentStoreFacade>;
+}
+type PersistedDocumentDeletionListener = (localId: string) => void;
+export declare function getOrCreateDocumentStoreRegistry(domainScope: DomainScope): DocumentStoreRegistry;
+export declare function resolveDocumentStoreKey(registry: DocumentStoreRegistry, localId: string, documentId: string | null): string;
+export declare function registerDocumentStore(domainScope: DomainScope, localId: string, store: DocumentStoreFacade, documentId: string | null): void;
+export declare function registerDocumentStoreIdentity(domainScope: DomainScope, localId: string, documentId: string | null): void;
+export declare function requestDocumentStoreSync(state: {
+    syncLane: {
+        requestSync: () => void;
+    } | null;
+}): void;
+export declare function requestRegisteredDocumentRemoteSync(domainScope: DomainScope, localId: string, documentId: string | null): boolean;
+/**
+ * Discard a registered document's local edits through its store, so the
+ * teardown serializes on the store's write machinery instead of racing an
+ * in-flight persist that would resurrect the deleted rows. Only registered
+ * stores qualify — an unregistered document has no lane submitting its queue,
+ * so there is nothing this escape hatch could unstick. No deletion is
+ * emitted: the document survives as a re-seeded shell that keeps its listing
+ * entry, and the re-pull's own persist announces the restored content.
+ *
+ * Resolution is strict, unlike the read-side lookups: a destructive action
+ * must never run against whichever store won a lookup priority. Both
+ * identifiers must map to the SAME registered store — an unknown or stale
+ * documentId refuses rather than trusting the localId alone — and the store
+ * revalidates the expected documentId against its persisted record inside
+ * the teardown's serialized mutation, so even a stale registry mapping
+ * cannot discard a different identity's edits.
+ */
+export declare function discardRegisteredDocumentLocalState(domainScope: DomainScope, localId: string, documentId: string): Promise<boolean>;
+export declare function createDocumentStoreFacade(initialStore: DocumentStore): DocumentStoreFacade;
+export declare function emitPersistedDocument(domainScope: DomainScope, persistedDocument: Parameters<PersistedDocumentListener>[0], placementChanged?: boolean): void;
+export declare function subscribeToPersistedDocuments(domainScope: DomainScope, listener: PersistedDocumentListener): () => void;
+export declare function emitPersistedDocumentDeletion(domainScope: DomainScope, localId: string): void;
+export declare function subscribeToPersistedDocumentDeletions(domainScope: DomainScope, listener: PersistedDocumentDeletionListener): () => void;
+export declare function requestDomainDocumentSync(domainScope: DomainScope): void;
+export {};

package/stores/documents/registry.js

@@ -0,0 +1,206 @@
+import { registerInternalDocumentRelink, relinkDocumentStoreWithCommitSideEffect, } from "./documentStore/internalRelink.js";
+const documentStoreRegistriesByScope = new WeakMap();
+// Per-scope listener plumbing shared by the persisted-document and
+// persisted-document-deletion channels: emit fans out to the scope's
+// listeners, and unsubscribing the last listener drops the scope entry.
+function createScopedListenerRegistry() {
+    const listenersByScope = new WeakMap();
+    return {
+        emit: (domainScope, ...args) => {
+            const listeners = listenersByScope.get(domainScope);
+            if (!listeners) {
+                return;
+            }
+            for (const listener of listeners) {
+                listener(...args);
+            }
+        },
+        subscribe: (domainScope, listener) => {
+            const listeners = listenersByScope.get(domainScope) ?? new Set();
+            listeners.add(listener);
+            listenersByScope.set(domainScope, listeners);
+            return () => {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    listenersByScope.delete(domainScope);
+                }
+            };
+        },
+    };
+}
+const persistedDocumentListeners = createScopedListenerRegistry();
+const persistedDocumentDeletionListeners = createScopedListenerRegistry();
+export function getOrCreateDocumentStoreRegistry(domainScope) {
+    const existingRegistry = documentStoreRegistriesByScope.get(domainScope);
+    if (existingRegistry) {
+        return existingRegistry;
+    }
+    const nextRegistry = {
+        storeKeysByDocumentId: new Map(),
+        storeKeysByLocalId: new Map(),
+        storesByKey: new Map(),
+    };
+    documentStoreRegistriesByScope.set(domainScope, nextRegistry);
+    return nextRegistry;
+}
+export function resolveDocumentStoreKey(registry, localId, documentId) {
+    return ((documentId ? registry.storeKeysByDocumentId.get(documentId) : undefined) ??
+        registry.storeKeysByLocalId.get(localId) ??
+        localId);
+}
+export function registerDocumentStore(domainScope, localId, store, documentId) {
+    const registry = getOrCreateDocumentStoreRegistry(domainScope);
+    const storeKey = resolveDocumentStoreKey(registry, localId, documentId);
+    registry.storeKeysByLocalId.set(localId, storeKey);
+    if (documentId) {
+        registry.storeKeysByDocumentId.set(documentId, storeKey);
+    }
+    registry.storesByKey.set(storeKey, store);
+}
+export function registerDocumentStoreIdentity(domainScope, localId, documentId) {
+    if (!documentId) {
+        return;
+    }
+    const registry = getOrCreateDocumentStoreRegistry(domainScope);
+    const localStoreKey = registry.storeKeysByLocalId.get(localId) ?? localId;
+    const documentStoreKey = registry.storeKeysByDocumentId.get(documentId) ?? documentId;
+    registry.storeKeysByLocalId.set(localId, documentStoreKey);
+    registry.storeKeysByDocumentId.set(documentId, documentStoreKey);
+    if (documentStoreKey === localStoreKey) {
+        return;
+    }
+    const localStore = registry.storesByKey.get(localStoreKey);
+    const documentStore = registry.storesByKey.get(documentStoreKey);
+    if (localStore) {
+        documentStore?.rebindTo(localStore);
+        registry.storesByKey.set(documentStoreKey, localStore);
+    }
+    registry.storesByKey.delete(localStoreKey);
+}
+export function requestDocumentStoreSync(state) {
+    state.syncLane?.requestSync();
+}
+export function requestRegisteredDocumentRemoteSync(domainScope, localId, documentId) {
+    const registry = documentStoreRegistriesByScope.get(domainScope);
+    if (!registry) {
+        return false;
+    }
+    const store = registry.storesByKey.get(resolveDocumentStoreKey(registry, localId, documentId));
+    if (!store) {
+        return false;
+    }
+    // Explicit refresh uses this path to recover missed websocket invalidations
+    // without instantiating every unopened document discovered in the container.
+    store.requestRemoteSync();
+    return true;
+}
+/**
+ * Discard a registered document's local edits through its store, so the
+ * teardown serializes on the store's write machinery instead of racing an
+ * in-flight persist that would resurrect the deleted rows. Only registered
+ * stores qualify — an unregistered document has no lane submitting its queue,
+ * so there is nothing this escape hatch could unstick. No deletion is
+ * emitted: the document survives as a re-seeded shell that keeps its listing
+ * entry, and the re-pull's own persist announces the restored content.
+ *
+ * Resolution is strict, unlike the read-side lookups: a destructive action
+ * must never run against whichever store won a lookup priority. Both
+ * identifiers must map to the SAME registered store — an unknown or stale
+ * documentId refuses rather than trusting the localId alone — and the store
+ * revalidates the expected documentId against its persisted record inside
+ * the teardown's serialized mutation, so even a stale registry mapping
+ * cannot discard a different identity's edits.
+ */
+export async function discardRegisteredDocumentLocalState(domainScope, localId, documentId) {
+    const registry = documentStoreRegistriesByScope.get(domainScope);
+    if (!registry) {
+        return false;
+    }
+    const localStoreKey = registry.storeKeysByLocalId.get(localId);
+    const documentStoreKey = registry.storeKeysByDocumentId.get(documentId);
+    if (!localStoreKey ||
+        !documentStoreKey ||
+        documentStoreKey !== localStoreKey) {
+        return false;
+    }
+    const store = registry.storesByKey.get(localStoreKey);
+    if (!store) {
+        return false;
+    }
+    return store.discardLocalState(documentId);
+}
+export function createDocumentStoreFacade(initialStore) {
+    let targetStore = initialStore;
+    const listeners = new Set();
+    const emitFacade = () => {
+        for (const listener of listeners) {
+            listener();
+        }
+    };
+    let unsubscribeTarget = targetStore.subscribe(() => {
+        emitFacade();
+    });
+    const connectTarget = (nextStore) => {
+        if (targetStore === nextStore) {
+            return;
+        }
+        unsubscribeTarget();
+        targetStore = nextStore;
+        unsubscribeTarget = targetStore.subscribe(() => {
+            emitFacade();
+        });
+        emitFacade();
+    };
+    const facade = {
+        addRow: (fields) => targetStore.addRow(fields),
+        assertCanRotateContentKey: () => targetStore.assertCanRotateContentKey(),
+        attachFiles: (files) => targetStore.attachFiles(files),
+        discardLocalState: (expectedDocumentId) => targetStore.discardLocalState(expectedDocumentId),
+        ensureInitialized: () => targetStore.ensureInitialized(),
+        getSnapshot: () => targetStore.getSnapshot(),
+        removeAttachment: (slotId) => targetStore.removeAttachment(slotId),
+        removeRow: (id) => targetStore.removeRow(id),
+        replaceAttachment: (slotId, file) => targetStore.replaceAttachment(slotId, file),
+        requestRemoteSync: () => targetStore.requestRemoteSync(),
+        requestRemoteSyncAndWait: (signal) => targetStore.requestRemoteSyncAndWait(signal),
+        requestSync: () => targetStore.requestSync(),
+        relink: (input) => targetStore.relink(input),
+        rebindTo: (store) => connectTarget(store),
+        setStructuredFields: (kind, patch, options) => targetStore.setStructuredFields(kind, patch, options),
+        setText: (value) => targetStore.setText(value),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        updateRowFields: (id, patch) => targetStore.updateRowFields(id, patch),
+        updateRuntime: (runtime) => targetStore.updateRuntime(runtime),
+    };
+    registerInternalDocumentRelink(facade, (input, commitSideEffect) => relinkDocumentStoreWithCommitSideEffect(targetStore, input, commitSideEffect));
+    return facade;
+}
+export function emitPersistedDocument(domainScope, persistedDocument, placementChanged = false) {
+    persistedDocumentListeners.emit(domainScope, persistedDocument, {
+        placementChanged,
+    });
+}
+export function subscribeToPersistedDocuments(domainScope, listener) {
+    return persistedDocumentListeners.subscribe(domainScope, listener);
+}
+export function emitPersistedDocumentDeletion(domainScope, localId) {
+    persistedDocumentDeletionListeners.emit(domainScope, localId);
+}
+export function subscribeToPersistedDocumentDeletions(domainScope, listener) {
+    return persistedDocumentDeletionListeners.subscribe(domainScope, listener);
+}
+export function requestDomainDocumentSync(domainScope) {
+    const registry = documentStoreRegistriesByScope.get(domainScope);
+    if (!registry) {
+        return;
+    }
+    for (const store of new Set(registry.storesByKey.values())) {
+        store.requestSync();
+    }
+}
+//# sourceMappingURL=registry.js.map