@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/container-contents/info/documentInfoTypes.d.ts

@@ -0,0 +1,92 @@
+import type { DocumentEditAttributionResponse } from "../../../internal/validators/response/index.js";
+import type { StoredDocumentKind } from "../../../data/documents/documentKinds.js";
+import type { DocumentBlameRange, DocumentCharacterBlameSummary, DocumentContributor, DocumentFieldBlame } from "../../../data/documents/editAttribution.js";
+export type DocumentInfoRemoteMode = "if-synced" | "never";
+export interface DocumentInfoLocalDetails {
+    accessEpoch: number | null;
+    accessStateHash: string | null;
+    containerId: string | null;
+    documentId: string | null;
+    documentKind: StoredDocumentKind | null;
+    hasContentKeyBundle: boolean;
+    hasDocumentKekTargets: boolean;
+    hasDocumentManifestBundle: boolean;
+    lastCommitLsn: string | null;
+    localDocumentManifestHash: string | null;
+    localId: string;
+    pendingAttachmentByteLength: number;
+    pendingAttachmentCount: number;
+    pendingUpdateCount: number;
+    title: string | null;
+    updatedAt: string | null;
+}
+export interface DocumentInfoAttachment {
+    attachmentKind: "local" | "pending";
+    blobId: string | null;
+    byteLength: number;
+    createdAt: string | null;
+    localId: string;
+    mimeType: string | null;
+    name: string | null;
+    slotId: string;
+    storageKey: string;
+    updatedAt: string | null;
+}
+export interface DocumentInfoRemoteAttachmentBinding {
+    bindingId: string;
+    blobId: string;
+    slotId: string;
+}
+export interface DocumentInfoAuthorizingContainerPath {
+    containerId: string;
+    containerKeyEpoch: number | null;
+    containerKeyEpochId: string | null;
+    leafManifestHash: string | null;
+    organizationId: string;
+    pathLength: number;
+}
+export interface DocumentInfoRemoteDetails {
+    activeAttachmentBindings: DocumentInfoRemoteAttachmentBinding[];
+    attributionRevision: number | null;
+    attributionStatus: "available" | "truncated" | "unavailable";
+    attributionSegments: DocumentEditAttributionResponse["segments"];
+    authorizingContainerPaths: DocumentInfoAuthorizingContainerPath[];
+    /**
+     * Contiguous per-writer runs of the current prose — the read-only "blame"
+     * view that tints each phrase by who wrote it. Shares its `null` conditions
+     * (and its single snapshot reconstruction) with {@link characterBlame}.
+     */
+    blameRanges: DocumentBlameRange[] | null;
+    /**
+     * Per-writer live-character blame, or `null` when it could not be computed —
+     * the document has no local snapshot, the snapshot is too large to extract
+     * op ids from cheaply, or the snapshot was unreadable.
+     */
+    characterBlame: DocumentCharacterBlameSummary | null;
+    /**
+     * Per-field blame for a structured document (who last set each field), or
+     * `null` when it could not be computed. A note yields `[]` (no fields).
+     */
+    fieldBlame: DocumentFieldBlame[] | null;
+    contentKeyEpoch: number;
+    contentKeyTargetCount: number;
+    contentKeyTargetHash: string;
+    contributors: DocumentContributor[];
+    currentManifestHash: string;
+    documentContainerManifestHistoryCount: number;
+    documentKekTargetCount: number;
+    documentKeyTargetHash: string;
+    documentManifestContainerPathCount: number;
+    documentManifestHistoryCount: number;
+    linkedContainerKeyEpochCount: number;
+    linkedContainerManifestCount: number;
+    linkSetManifestHash: string;
+    manifestEpoch: number | null;
+    previousManifestHash: string | null;
+    referencedPrincipalCount: number | null;
+}
+export interface DocumentInfo {
+    attachments: DocumentInfoAttachment[];
+    local: DocumentInfoLocalDetails;
+    remoteInfo: DocumentInfoRemoteDetails | null;
+}

package/workflows/container-contents/info/documentInfoTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentInfoTypes.js","sourceRoot":"","sources":["documentInfoTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { DocumentEditAttributionResponse } from \"@tearleads/validators/response\";\nimport type { StoredDocumentKind } from \"../../../data/documents/documentKinds\";\nimport type {\n  DocumentBlameRange,\n  DocumentCharacterBlameSummary,\n  DocumentContributor,\n  DocumentFieldBlame,\n} from \"../../../data/documents/editAttribution\";\n\nexport type DocumentInfoRemoteMode = \"if-synced\" | \"never\";\n\nexport interface DocumentInfoLocalDetails {\n  accessEpoch: number | null;\n  accessStateHash: string | null;\n  containerId: string | null;\n  documentId: string | null;\n  documentKind: StoredDocumentKind | null;\n  hasContentKeyBundle: boolean;\n  hasDocumentKekTargets: boolean;\n  hasDocumentManifestBundle: boolean;\n  lastCommitLsn: string | null;\n  localDocumentManifestHash: string | null;\n  localId: string;\n  pendingAttachmentByteLength: number;\n  pendingAttachmentCount: number;\n  pendingUpdateCount: number;\n  title: string | null;\n  updatedAt: string | null;\n}\n\nexport interface DocumentInfoAttachment {\n  attachmentKind: \"local\" | \"pending\";\n  blobId: string | null;\n  byteLength: number;\n  createdAt: string | null;\n  localId: string;\n  mimeType: string | null;\n  name: string | null;\n  slotId: string;\n  storageKey: string;\n  updatedAt: string | null;\n}\n\nexport interface DocumentInfoRemoteAttachmentBinding {\n  bindingId: string;\n  blobId: string;\n  slotId: string;\n}\n\nexport interface DocumentInfoAuthorizingContainerPath {\n  containerId: string;\n  containerKeyEpoch: number | null;\n  containerKeyEpochId: string | null;\n  leafManifestHash: string | null;\n  organizationId: string;\n  pathLength: number;\n}\n\nexport interface DocumentInfoRemoteDetails {\n  activeAttachmentBindings: DocumentInfoRemoteAttachmentBinding[];\n  attributionRevision: number | null;\n  attributionStatus: \"available\" | \"truncated\" | \"unavailable\";\n  attributionSegments: DocumentEditAttributionResponse[\"segments\"];\n  authorizingContainerPaths: DocumentInfoAuthorizingContainerPath[];\n  /**\n   * Contiguous per-writer runs of the current prose — the read-only \"blame\"\n   * view that tints each phrase by who wrote it. Shares its `null` conditions\n   * (and its single snapshot reconstruction) with {@link characterBlame}.\n   */\n  blameRanges: DocumentBlameRange[] | null;\n  /**\n   * Per-writer live-character blame, or `null` when it could not be computed —\n   * the document has no local snapshot, the snapshot is too large to extract\n   * op ids from cheaply, or the snapshot was unreadable.\n   */\n  characterBlame: DocumentCharacterBlameSummary | null;\n  /**\n   * Per-field blame for a structured document (who last set each field), or\n   * `null` when it could not be computed. A note yields `[]` (no fields).\n   */\n  fieldBlame: DocumentFieldBlame[] | null;\n  contentKeyEpoch: number;\n  contentKeyTargetCount: number;\n  contentKeyTargetHash: string;\n  contributors: DocumentContributor[];\n  currentManifestHash: string;\n  documentContainerManifestHistoryCount: number;\n  documentKekTargetCount: number;\n  documentKeyTargetHash: string;\n  documentManifestContainerPathCount: number;\n  documentManifestHistoryCount: number;\n  linkedContainerKeyEpochCount: number;\n  linkedContainerManifestCount: number;\n  linkSetManifestHash: string;\n  manifestEpoch: number | null;\n  previousManifestHash: string | null;\n  referencedPrincipalCount: number | null;\n}\n\nexport interface DocumentInfo {\n  attachments: DocumentInfoAttachment[];\n  local: DocumentInfoLocalDetails;\n  remoteInfo: DocumentInfoRemoteDetails | null;\n}\n"]}

package/workflows/container-contents/metadata/index.d.ts

@@ -0,0 +1,25 @@
+import type { ProjectionUserKeyResolver } from "../../../data/keyingProjectionVerification/index.js";
+import type { ContainerContentsPersistence } from "../../../data/persistence/container-contents/containerContentsPersistence.js";
+import { type ContainerMetadataSyncAttempt, type ContainerMetadataSyncRuntime } from "./metadataRemoteSync.js";
+export { hasContainerMetadataDocumentUpdateEvent, listContainerMetadataDocumentUpdateIds, } from "./metadataEvents.js";
+export { installContainerMetadataRecord, persistContainerMetadataStateFromRuntime, renameContainerMetadataStateFromRuntime, setContainerIconMetadataStateFromRuntime, } from "./metadataPersistence.js";
+import type { ContainerMetadataState, MissingContainerMetadataState, SyncedContainerMetadataState } from "./metadataTypes.js";
+export { cleanupContainerMetadataRegistrationsOnFailure, preRegisterMaterializedContainerMetadataUpdateIds, } from "./metadataSyncRegistrations.js";
+export type { ContainerMetadataPatch } from "./metadataTypes.js";
+export declare function settleContainerMetadataOutgoingPass(metadataState: ContainerMetadataState, attempt: ContainerMetadataSyncAttempt): boolean;
+interface SyncContainerMetadataStateInput {
+    forceReadSync?: boolean | undefined;
+    isCurrent: () => boolean;
+    /**
+     * Register sent ids before the network await so early self echoes cannot arm
+     * a redundant read-sync. Shared with {@link listContainerMetadataDocumentUpdateIds}.
+     */
+    locallyAcceptedUpdateIds?: Set<string> | undefined;
+    metadataState: ContainerMetadataState;
+    onDurableStateNeedsReload?: (() => void) | undefined;
+    persistence: ContainerContentsPersistence;
+    resolveProjectionUserKey: ProjectionUserKeyResolver;
+    runtime: ContainerMetadataSyncRuntime;
+    targetSecretKey: Uint8Array;
+}
+export declare function syncContainerMetadataState(input: SyncContainerMetadataStateInput): Promise<SyncedContainerMetadataState | MissingContainerMetadataState | null>;

package/workflows/container-contents/metadata/index.js

@@ -0,0 +1,217 @@
+import { encodeVersionVector, exportFullHistorySnapshot, } from "../../../internal/loro/index.js";
+import { readPullContinuation } from "../../../data/documents/shared/syncPagination.js";
+import { settleOutgoingPassAndDecideReArm } from "../../../data/sync/outgoingUpdateSettlement.js";
+import { shouldClearDocumentSyncFailureAfterPass } from "../../documents/index.js";
+import { applyIncomingContainerMetadataUpdates } from "./metadataIncomingUpdateIsolation.js";
+import { currentMetadataPullContinuation, hasCurrentContainerMetadataReadState, installContainerMetadataRecord, persistContainerMetadataStateFromRuntime, } from "./metadataPersistence.js";
+import { syncRemoteContainerMetadata, } from "./metadataRemoteSync.js";
+import { createDetachedContainerMetadataState, installDetachedContainerMetadataState, } from "./metadataStateIsolation.js";
+import { shouldRequestContainerMetadataFollowup } from "./metadataSyncFollowup.js";
+export { hasContainerMetadataDocumentUpdateEvent, listContainerMetadataDocumentUpdateIds, } from "./metadataEvents.js";
+export { installContainerMetadataRecord, persistContainerMetadataStateFromRuntime, renameContainerMetadataStateFromRuntime, setContainerIconMetadataStateFromRuntime, } from "./metadataPersistence.js";
+import { invalidateContainerMetadataPullContinuation } from "./metadataPullContinuationInvalidation.js";
+import { cleanupContainerMetadataRegistrationsOnFailure, discardUnacceptedContainerMetadataUpdateIds, preRegisterMaterializedContainerMetadataUpdateIds, } from "./metadataSyncRegistrations.js";
+export { cleanupContainerMetadataRegistrationsOnFailure, preRegisterMaterializedContainerMetadataUpdateIds, } from "./metadataSyncRegistrations.js";
+export function settleContainerMetadataOutgoingPass(metadataState, attempt) {
+    const shouldReArmOutgoing = settleOutgoingPassAndDecideReArm(metadataState, {
+        exhaustedPendingUpdateCount: attempt.synced.exhaustedPendingUpdateCount,
+        outgoingUpdateCount: attempt.outgoingUpdateCount,
+        rekeyedUpdateCount: attempt.synced.rekeyedPendingUpdateIds.length,
+        settledUpdateCount: attempt.synced.settledPendingUpdateIds.length,
+        acceptedRecoveryBaseline: attempt.synced.acceptedRecoveryBaseline,
+    });
+    return (attempt.synced.hasDeferredPendingUpdates ||
+        shouldReArmOutgoing ||
+        attempt.synced.hasIncompletePull);
+}
+function documentWriterProjectionMatchesMetadataSyncResponse(writerProjection, synced) {
+    return (writerProjection.contentKeyBundle.contentKeyEpoch ===
+        synced.response.contentKeyBundle.contentKeyEpoch &&
+        writerProjection.contentKeyBundle.linkSetManifestHash ===
+            synced.response.contentKeyBundle.linkSetManifestHash &&
+        writerProjection.contentKeyBundle.targetHash ===
+            synced.response.contentKeyBundle.targetHash &&
+        writerProjection.documentKekTargets.linkSetManifestHash ===
+            synced.response.documentKekTargets.linkSetManifestHash &&
+        writerProjection.documentKekTargets.documentKeyTargetHash ===
+            synced.response.documentKekTargets.documentKeyTargetHash);
+}
+function resolveSyncedContainerMetadataWriterProjection(metadataState, synced) {
+    const writerProjection = synced.writerProjection ??
+        (metadataState.metadataWriterProjection?.documentId ===
+            synced.plan.documentId
+            ? metadataState.metadataWriterProjection
+            : null);
+    return writerProjection &&
+        documentWriterProjectionMatchesMetadataSyncResponse(writerProjection, synced)
+        ? writerProjection
+        : null;
+}
+/**
+ * Heals a stale metadata content-key bundle by rotating to a fresh content
+ * key anchored by this full-history snapshot.
+ */
+function metadataRotationSnapshotProvider(metadataState) {
+    return async () => exportFullHistorySnapshot(metadataState.doc);
+}
+async function requestContainerMetadataSync(input) {
+    const { metadataState, sentUpdateIds, syncInput } = input;
+    const { isCurrent, persistence, runtime } = syncInput;
+    return cleanupContainerMetadataRegistrationsOnFailure(syncInput.locallyAcceptedUpdateIds, sentUpdateIds, () => syncRemoteContainerMetadata({
+        buildRotationSnapshot: metadataRotationSnapshotProvider(metadataState),
+        containerId: metadataState.container.id,
+        currentDocument: metadataState.doc,
+        documentId: input.documentId,
+        isCurrent,
+        lastCommitLsn: metadataState.record.lastCommitLsn,
+        localVersionVector: encodeVersionVector(metadataState.doc),
+        onOutgoingUpdatesMaterialized: (updateIds) => {
+            if (isCurrent()) {
+                preRegisterMaterializedContainerMetadataUpdateIds(syncInput.locallyAcceptedUpdateIds, sentUpdateIds, updateIds);
+            }
+        },
+        onPullContinuationInvalidated: (continuation) => invalidateContainerMetadataPullContinuation({
+            continuation,
+            isCurrent,
+            metadataState,
+            persistence,
+            runtime,
+        }),
+        pendingUpdates: input.pendingUpdates,
+        persistedState: metadataState.record,
+        pullContinuation: currentMetadataPullContinuation(metadataState) ?? undefined,
+        rekeyPendingUpdate: persistence.rekeyPendingUpdate,
+        resolveProjectionUserKey: syncInput.resolveProjectionUserKey,
+        runtime,
+        targetSecretKey: syncInput.targetSecretKey,
+        writerProjection: metadataState.metadataWriterProjection?.documentId ===
+            input.documentId
+            ? metadataState.metadataWriterProjection
+            : undefined,
+    }));
+}
+export async function syncContainerMetadataState(input) {
+    const { persistence, runtime } = input;
+    const liveMetadataState = input.metadataState;
+    const { isCurrent } = input;
+    if (!isCurrent()) {
+        return null;
+    }
+    const { documentId } = liveMetadataState.record;
+    if (!documentId) {
+        return null;
+    }
+    const execSql = runtime.infra.execSql;
+    const pendingUpdates = await persistence.listPendingUpdates(execSql, liveMetadataState.container.id);
+    if (!isCurrent()) {
+        return null;
+    }
+    if (pendingUpdates.length === 0 &&
+        currentMetadataPullContinuation(liveMetadataState) === null &&
+        !liveMetadataState.record.pullContinuationRecoveryRequired &&
+        !input.forceReadSync &&
+        hasCurrentContainerMetadataReadState(liveMetadataState.record)) {
+        return null;
+    }
+    const metadataState = await createDetachedContainerMetadataState(liveMetadataState);
+    if (!isCurrent()) {
+        return null;
+    }
+    const sentUpdateIds = [];
+    const syncAttempt = await requestContainerMetadataSync({
+        documentId,
+        metadataState,
+        pendingUpdates,
+        sentUpdateIds,
+        syncInput: input,
+    });
+    if (!syncAttempt) {
+        return null;
+    }
+    if (!isCurrent()) {
+        discardUnacceptedContainerMetadataUpdateIds(input.locallyAcceptedUpdateIds, sentUpdateIds, []);
+        return null;
+    }
+    const finalized = await finalizeContainerMetadataSync({
+        documentId,
+        isCurrent,
+        locallyAcceptedUpdateIds: input.locallyAcceptedUpdateIds,
+        metadataState,
+        onDurableStateNeedsReload: input.onDurableStateNeedsReload,
+        persistence,
+        runtime,
+        sentUpdateIds,
+        syncAttempt,
+    });
+    if (!isCurrent() || !finalized) {
+        return null;
+    }
+    if (!("missing" in finalized)) {
+        installDetachedContainerMetadataState(liveMetadataState, metadataState, {
+            preserveConcurrentMetadataEdit: true,
+        });
+    }
+    return finalized;
+}
+async function finalizeContainerMetadataSync(input) {
+    const { metadataState, syncAttempt } = input;
+    const { outgoingUpdateCount, synced } = syncAttempt;
+    if (!input.isCurrent()) {
+        discardUnacceptedContainerMetadataUpdateIds(input.locallyAcceptedUpdateIds, input.sentUpdateIds, []);
+        return null;
+    }
+    // An id sent but not accepted will never be echoed. Accepted ids stay
+    // registered until their realtime echo consumes them.
+    discardUnacceptedContainerMetadataUpdateIds(input.locallyAcceptedUpdateIds, input.sentUpdateIds, synced.response.acceptedOutgoingUpdateIds);
+    metadataState.metadataWriterProjection =
+        resolveSyncedContainerMetadataWriterProjection(metadataState, synced);
+    if (synced.decryptedUpdates.length > 0) {
+        applyIncomingContainerMetadataUpdates(metadataState.doc, synced);
+    }
+    const persisted = await persistContainerMetadataStateFromRuntime({
+        acceptedPendingUpdateIds: synced.settledPendingUpdateIds,
+        clearSyncFailure: shouldClearDocumentSyncFailureAfterPass(synced, outgoingUpdateCount),
+        expectedSyncState: {
+            pullContinuation: syncAttempt.consumedPullContinuation ?? null,
+            record: syncAttempt.requestRecord,
+        },
+        metadataState,
+        onDurableStateNeedsReload: input.onDurableStateNeedsReload,
+        patch: {
+            ...synced.persistedState,
+            documentId: input.documentId,
+            lastCommitLsn: synced.response.commitLsn ?? metadataState.record.lastCommitLsn ?? null,
+            metadataDocumentId: input.documentId,
+            pullContinuation: readPullContinuation(synced.response),
+        },
+        persistence: input.persistence,
+        runtime: input.runtime,
+        stillCurrent: input.isCurrent,
+    });
+    if (!input.isCurrent()) {
+        discardUnacceptedContainerMetadataUpdateIds(input.locallyAcceptedUpdateIds, input.sentUpdateIds, []);
+        return null;
+    }
+    if (!persisted) {
+        discardUnacceptedContainerMetadataUpdateIds(input.locallyAcceptedUpdateIds, input.sentUpdateIds, []);
+        metadataState.metadataWriterProjection = null;
+        return { missing: true };
+    }
+    metadataState.container = persisted.container;
+    installContainerMetadataRecord(metadataState, persisted.record);
+    if (persisted.pullContinuationSuperseded) {
+        // The response's accepted IDs were not durably settled. Treat every
+        // pre-registration as unapplied so an early echo cannot hide work that the
+        // forced follow-up still needs to reconcile.
+        discardUnacceptedContainerMetadataUpdateIds(input.locallyAcceptedUpdateIds, input.sentUpdateIds, []);
+        metadataState.metadataWriterProjection = null;
+    }
+    return {
+        ...persisted,
+        shouldRequestFollowupSync: shouldRequestContainerMetadataFollowup({
+            persisted,
+            settleOutgoingPass: () => settleContainerMetadataOutgoingPass(metadataState, syncAttempt),
+        }),
+    };
+}
+//# sourceMappingURL=index.js.map

package/workflows/container-contents/metadata/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAIrF,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,uCAAuC,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,qCAAqC,EAAE,MAAM,mCAAmC,CAAC;AAC1F,OAAO,EACL,+BAA+B,EAC/B,oCAAoC,EACpC,8BAA8B,EAC9B,wCAAwC,GACzC,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAGL,2BAA2B,GAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,oCAAoC,EACpC,qCAAqC,GACtC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,sCAAsC,EAAE,MAAM,wBAAwB,CAAC;AAEhF,OAAO,EACL,uCAAuC,EACvC,sCAAsC,GACvC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,8BAA8B,EAC9B,wCAAwC,EACxC,uCAAuC,EACvC,wCAAwC,GACzC,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,2CAA2C,EAAE,MAAM,wCAAwC,CAAC;AACrG,OAAO,EACL,8CAA8C,EAC9C,2CAA2C,EAC3C,iDAAiD,GAClD,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,8CAA8C,EAC9C,iDAAiD,GAClD,MAAM,6BAA6B,CAAC;AAGrC,MAAM,UAAU,mCAAmC,CACjD,aAAqC,EACrC,OAAqC;IAErC,MAAM,mBAAmB,GAAG,gCAAgC,CAAC,aAAa,EAAE;QAC1E,2BAA2B,EAAE,OAAO,CAAC,MAAM,CAAC,2BAA2B;QACvE,mBAAmB,EAAE,OAAO,CAAC,mBAAmB;QAChD,kBAAkB,EAAE,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAC,MAAM;QACjE,kBAAkB,EAAE,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAC,MAAM;QACjE,wBAAwB,EAAE,OAAO,CAAC,MAAM,CAAC,wBAAwB;KAClE,CAAC,CAAC;IACH,OAAO,CACL,OAAO,CAAC,MAAM,CAAC,yBAAyB;QACxC,mBAAmB;QACnB,OAAO,CAAC,MAAM,CAAC,iBAAiB,CACjC,CAAC;AACJ,CAAC;AAED,SAAS,mDAAmD,CAC1D,gBAAkD,EAClD,MAA8C;IAE9C,OAAO,CACL,gBAAgB,CAAC,gBAAgB,CAAC,eAAe;QAC/C,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,eAAe;QAClD,gBAAgB,CAAC,gBAAgB,CAAC,mBAAmB;YACnD,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,mBAAmB;QACtD,gBAAgB,CAAC,gBAAgB,CAAC,UAAU;YAC1C,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,UAAU;QAC7C,gBAAgB,CAAC,kBAAkB,CAAC,mBAAmB;YACrD,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,mBAAmB;QACxD,gBAAgB,CAAC,kBAAkB,CAAC,qBAAqB;YACvD,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,qBAAqB,CAC3D,CAAC;AACJ,CAAC;AAED,SAAS,8CAA8C,CACrD,aAAqC,EACrC,MAA8C;IAE9C,MAAM,gBAAgB,GACpB,MAAM,CAAC,gBAAgB;QACvB,CAAC,aAAa,CAAC,wBAAwB,EAAE,UAAU;YACnD,MAAM,CAAC,IAAI,CAAC,UAAU;YACpB,CAAC,CAAC,aAAa,CAAC,wBAAwB;YACxC,CAAC,CAAC,IAAI,CAAC,CAAC;IACZ,OAAO,gBAAgB;QACrB,mDAAmD,CACjD,gBAAgB,EAChB,MAAM,CACP;QACD,CAAC,CAAC,gBAAgB;QAClB,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED;;;GAGG;AACH,SAAS,gCAAgC,CACvC,aAAqC;IAErC,OAAO,KAAK,IAAI,EAAE,CAAC,yBAAyB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;AAClE,CAAC;AAkBD,KAAK,UAAU,4BAA4B,CAAC,KAM3C;IACC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC;IAC1D,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;IACtD,OAAO,8CAA8C,CACnD,SAAS,CAAC,wBAAwB,EAClC,aAAa,EACb,GAAG,EAAE,CACH,2BAA2B,CAAC;QAC1B,qBAAqB,EAAE,gCAAgC,CAAC,aAAa,CAAC;QACtE,WAAW,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE;QACvC,eAAe,EAAE,aAAa,CAAC,GAAG;QAClC,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,SAAS;QACT,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,aAAa;QACjD,kBAAkB,EAAE,mBAAmB,CAAC,aAAa,CAAC,GAAG,CAAC;QAC1D,6BAA6B,EAAE,CAAC,SAAS,EAAE,EAAE;YAC3C,IAAI,SAAS,EAAE,EAAE,CAAC;gBAChB,iDAAiD,CAC/C,SAAS,CAAC,wBAAwB,EAClC,aAAa,EACb,SAAS,CACV,CAAC;YACJ,CAAC;QACH,CAAC;QACD,6BAA6B,EAAE,CAAC,YAAY,EAAE,EAAE,CAC9C,2CAA2C,CAAC;YAC1C,YAAY;YACZ,SAAS;YACT,aAAa;YACb,WAAW;YACX,OAAO;SACR,CAAC;QACJ,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,cAAc,EAAE,aAAa,CAAC,MAAM;QACpC,gBAAgB,EACd,+BAA+B,CAAC,aAAa,CAAC,IAAI,SAAS;QAC7D,kBAAkB,EAAE,WAAW,CAAC,kBAAkB;QAClD,wBAAwB,EAAE,SAAS,CAAC,wBAAwB;QAC5D,OAAO;QACP,eAAe,EAAE,SAAS,CAAC,eAAe;QAC1C,gBAAgB,EACd,aAAa,CAAC,wBAAwB,EAAE,UAAU;YAClD,KAAK,CAAC,UAAU;YACd,CAAC,CAAC,aAAa,CAAC,wBAAwB;YACxC,CAAC,CAAC,SAAS;KAChB,CAAC,CACL,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,KAAsC;IAItC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IACvC,MAAM,iBAAiB,GAAG,KAAK,CAAC,aAAa,CAAC;IAC9C,MAAM,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC;IAC5B,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,EAAE,UAAU,EAAE,GAAG,iBAAiB,CAAC,MAAM,CAAC;IAChD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;IAEtC,MAAM,cAAc,GAAG,MAAM,WAAW,CAAC,kBAAkB,CACzD,OAAO,EACP,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAC/B,CAAC;IACF,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IACE,cAAc,CAAC,MAAM,KAAK,CAAC;QAC3B,+BAA+B,CAAC,iBAAiB,CAAC,KAAK,IAAI;QAC3D,CAAC,iBAAiB,CAAC,MAAM,CAAC,gCAAgC;QAC1D,CAAC,KAAK,CAAC,aAAa;QACpB,oCAAoC,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAC9D,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,aAAa,GACjB,MAAM,oCAAoC,CAAC,iBAAiB,CAAC,CAAC;IAChE,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,aAAa,GAAa,EAAE,CAAC;IAEnC,MAAM,WAAW,GAAG,MAAM,4BAA4B,CAAC;QACrD,UAAU;QACV,aAAa;QACb,cAAc;QACd,aAAa;QACb,SAAS,EAAE,KAAK;KACjB,CAAC,CAAC;IACH,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;QACjB,2CAA2C,CACzC,KAAK,CAAC,wBAAwB,EAC9B,aAAa,EACb,EAAE,CACH,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,6BAA6B,CAAC;QACpD,UAAU;QACV,SAAS;QACT,wBAAwB,EAAE,KAAK,CAAC,wBAAwB;QACxD,aAAa;QACb,yBAAyB,EAAE,KAAK,CAAC,yBAAyB;QAC1D,WAAW;QACX,OAAO;QACP,aAAa;QACb,WAAW;KACZ,CAAC,CAAC;IACH,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,CAAC,SAAS,IAAI,SAAS,CAAC,EAAE,CAAC;QAC9B,qCAAqC,CAAC,iBAAiB,EAAE,aAAa,EAAE;YACtE,8BAA8B,EAAE,IAAI;SACrC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,KAAK,UAAU,6BAA6B,CAAC,KAU5C;IAGC,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC;IAC7C,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC;IACpD,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC;QACvB,2CAA2C,CACzC,KAAK,CAAC,wBAAwB,EAC9B,KAAK,CAAC,aAAa,EACnB,EAAE,CACH,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,sEAAsE;IACtE,sDAAsD;IACtD,2CAA2C,CACzC,KAAK,CAAC,wBAAwB,EAC9B,KAAK,CAAC,aAAa,EACnB,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAC1C,CAAC;IACF,aAAa,CAAC,wBAAwB;QACpC,8CAA8C,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IACxE,IAAI,MAAM,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvC,qCAAqC,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,wCAAwC,CAAC;QAC/D,wBAAwB,EAAE,MAAM,CAAC,uBAAuB;QACxD,gBAAgB,EAAE,uCAAuC,CACvD,MAAM,EACN,mBAAmB,CACpB;QACD,iBAAiB,EAAE;YACjB,gBAAgB,EAAE,WAAW,CAAC,wBAAwB,IAAI,IAAI;YAC9D,MAAM,EAAE,WAAW,CAAC,aAAa;SAClC;QACD,aAAa;QACb,yBAAyB,EAAE,KAAK,CAAC,yBAAyB;QAC1D,KAAK,EAAE;YACL,GAAG,MAAM,CAAC,cAAc;YACxB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,aAAa,EACX,MAAM,CAAC,QAAQ,CAAC,SAAS,IAAI,aAAa,CAAC,MAAM,CAAC,aAAa,IAAI,IAAI;YACzE,kBAAkB,EAAE,KAAK,CAAC,UAAU;YACpC,gBAAgB,EAAE,oBAAoB,CAAC,MAAM,CAAC,QAAQ,CAAC;SACxD;QACD,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,YAAY,EAAE,KAAK,CAAC,SAAS;KAC9B,CAAC,CAAC;IACH,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC;QACvB,2CAA2C,CACzC,KAAK,CAAC,wBAAwB,EAC9B,KAAK,CAAC,aAAa,EACnB,EAAE,CACH,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,2CAA2C,CACzC,KAAK,CAAC,wBAAwB,EAC9B,KAAK,CAAC,aAAa,EACnB,EAAE,CACH,CAAC;QACF,aAAa,CAAC,wBAAwB,GAAG,IAAI,CAAC;QAC9C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC3B,CAAC;IACD,aAAa,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC;IAC9C,8BAA8B,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAChE,IAAI,SAAS,CAAC,0BAA0B,EAAE,CAAC;QACzC,oEAAoE;QACpE,2EAA2E;QAC3E,6CAA6C;QAC7C,2CAA2C,CACzC,KAAK,CAAC,wBAAwB,EAC9B,KAAK,CAAC,aAAa,EACnB,EAAE,CACH,CAAC;QACF,aAAa,CAAC,wBAAwB,GAAG,IAAI,CAAC;IAChD,CAAC;IAED,OAAO;QACL,GAAG,SAAS;QACZ,yBAAyB,EAAE,sCAAsC,CAAC;YAChE,SAAS;YACT,kBAAkB,EAAE,GAAG,EAAE,CACvB,mCAAmC,CAAC,aAAa,EAAE,WAAW,CAAC;SAClE,CAAC;KACH,CAAC;AACJ,CAAC","sourcesContent":["import {\n  encodeVersionVector,\n  exportFullHistorySnapshot,\n} from \"@tearleads/loro\";\nimport type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { readPullContinuation } from \"../../../data/documents/shared/syncPagination\";\nimport type { ProjectionUserKeyResolver } from \"../../../data/keyingProjectionVerification\";\nimport type { ContainerContentsPersistence } from \"../../../data/persistence/container-contents/containerContentsPersistence\";\nimport type { PendingUpdateRecord } from \"../../../data/sqlite/documentPersistence\";\nimport { settleOutgoingPassAndDecideReArm } from \"../../../data/sync/outgoingUpdateSettlement\";\nimport { shouldClearDocumentSyncFailureAfterPass } from \"../../documents\";\nimport { applyIncomingContainerMetadataUpdates } from \"./metadataIncomingUpdateIsolation\";\nimport {\n  currentMetadataPullContinuation,\n  hasCurrentContainerMetadataReadState,\n  installContainerMetadataRecord,\n  persistContainerMetadataStateFromRuntime,\n} from \"./metadataPersistence\";\nimport {\n  type ContainerMetadataSyncAttempt,\n  type ContainerMetadataSyncRuntime,\n  syncRemoteContainerMetadata,\n} from \"./metadataRemoteSync\";\nimport {\n  createDetachedContainerMetadataState,\n  installDetachedContainerMetadataState,\n} from \"./metadataStateIsolation\";\nimport { shouldRequestContainerMetadataFollowup } from \"./metadataSyncFollowup\";\n\nexport {\n  hasContainerMetadataDocumentUpdateEvent,\n  listContainerMetadataDocumentUpdateIds,\n} from \"./metadataEvents\";\nexport {\n  installContainerMetadataRecord,\n  persistContainerMetadataStateFromRuntime,\n  renameContainerMetadataStateFromRuntime,\n  setContainerIconMetadataStateFromRuntime,\n} from \"./metadataPersistence\";\n\nimport { invalidateContainerMetadataPullContinuation } from \"./metadataPullContinuationInvalidation\";\nimport {\n  cleanupContainerMetadataRegistrationsOnFailure,\n  discardUnacceptedContainerMetadataUpdateIds,\n  preRegisterMaterializedContainerMetadataUpdateIds,\n} from \"./metadataSyncRegistrations\";\nimport type {\n  ContainerMetadataState,\n  MissingContainerMetadataState,\n  SyncedContainerMetadataState,\n} from \"./metadataTypes\";\n\nexport {\n  cleanupContainerMetadataRegistrationsOnFailure,\n  preRegisterMaterializedContainerMetadataUpdateIds,\n} from \"./metadataSyncRegistrations\";\nexport type { ContainerMetadataPatch } from \"./metadataTypes\";\n\nexport function settleContainerMetadataOutgoingPass(\n  metadataState: ContainerMetadataState,\n  attempt: ContainerMetadataSyncAttempt,\n): boolean {\n  const shouldReArmOutgoing = settleOutgoingPassAndDecideReArm(metadataState, {\n    exhaustedPendingUpdateCount: attempt.synced.exhaustedPendingUpdateCount,\n    outgoingUpdateCount: attempt.outgoingUpdateCount,\n    rekeyedUpdateCount: attempt.synced.rekeyedPendingUpdateIds.length,\n    settledUpdateCount: attempt.synced.settledPendingUpdateIds.length,\n    acceptedRecoveryBaseline: attempt.synced.acceptedRecoveryBaseline,\n  });\n  return (\n    attempt.synced.hasDeferredPendingUpdates ||\n    shouldReArmOutgoing ||\n    attempt.synced.hasIncompletePull\n  );\n}\n\nfunction documentWriterProjectionMatchesMetadataSyncResponse(\n  writerProjection: DocumentWriterProjectionResponse,\n  synced: ContainerMetadataSyncAttempt[\"synced\"],\n): boolean {\n  return (\n    writerProjection.contentKeyBundle.contentKeyEpoch ===\n      synced.response.contentKeyBundle.contentKeyEpoch &&\n    writerProjection.contentKeyBundle.linkSetManifestHash ===\n      synced.response.contentKeyBundle.linkSetManifestHash &&\n    writerProjection.contentKeyBundle.targetHash ===\n      synced.response.contentKeyBundle.targetHash &&\n    writerProjection.documentKekTargets.linkSetManifestHash ===\n      synced.response.documentKekTargets.linkSetManifestHash &&\n    writerProjection.documentKekTargets.documentKeyTargetHash ===\n      synced.response.documentKekTargets.documentKeyTargetHash\n  );\n}\n\nfunction resolveSyncedContainerMetadataWriterProjection(\n  metadataState: ContainerMetadataState,\n  synced: ContainerMetadataSyncAttempt[\"synced\"],\n): DocumentWriterProjectionResponse | null {\n  const writerProjection =\n    synced.writerProjection ??\n    (metadataState.metadataWriterProjection?.documentId ===\n    synced.plan.documentId\n      ? metadataState.metadataWriterProjection\n      : null);\n  return writerProjection &&\n    documentWriterProjectionMatchesMetadataSyncResponse(\n      writerProjection,\n      synced,\n    )\n    ? writerProjection\n    : null;\n}\n\n/**\n * Heals a stale metadata content-key bundle by rotating to a fresh content\n * key anchored by this full-history snapshot.\n */\nfunction metadataRotationSnapshotProvider(\n  metadataState: ContainerMetadataState,\n): () => Promise<Uint8Array | null> {\n  return async () => exportFullHistorySnapshot(metadataState.doc);\n}\n\ninterface SyncContainerMetadataStateInput {\n  forceReadSync?: boolean | undefined;\n  isCurrent: () => boolean;\n  /**\n   * Register sent ids before the network await so early self echoes cannot arm\n   * a redundant read-sync. Shared with {@link listContainerMetadataDocumentUpdateIds}.\n   */\n  locallyAcceptedUpdateIds?: Set<string> | undefined;\n  metadataState: ContainerMetadataState;\n  onDurableStateNeedsReload?: (() => void) | undefined;\n  persistence: ContainerContentsPersistence;\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  runtime: ContainerMetadataSyncRuntime;\n  targetSecretKey: Uint8Array;\n}\n\nasync function requestContainerMetadataSync(input: {\n  documentId: string;\n  metadataState: ContainerMetadataState;\n  pendingUpdates: readonly PendingUpdateRecord[];\n  sentUpdateIds: string[];\n  syncInput: SyncContainerMetadataStateInput;\n}): Promise<ContainerMetadataSyncAttempt | null> {\n  const { metadataState, sentUpdateIds, syncInput } = input;\n  const { isCurrent, persistence, runtime } = syncInput;\n  return cleanupContainerMetadataRegistrationsOnFailure(\n    syncInput.locallyAcceptedUpdateIds,\n    sentUpdateIds,\n    () =>\n      syncRemoteContainerMetadata({\n        buildRotationSnapshot: metadataRotationSnapshotProvider(metadataState),\n        containerId: metadataState.container.id,\n        currentDocument: metadataState.doc,\n        documentId: input.documentId,\n        isCurrent,\n        lastCommitLsn: metadataState.record.lastCommitLsn,\n        localVersionVector: encodeVersionVector(metadataState.doc),\n        onOutgoingUpdatesMaterialized: (updateIds) => {\n          if (isCurrent()) {\n            preRegisterMaterializedContainerMetadataUpdateIds(\n              syncInput.locallyAcceptedUpdateIds,\n              sentUpdateIds,\n              updateIds,\n            );\n          }\n        },\n        onPullContinuationInvalidated: (continuation) =>\n          invalidateContainerMetadataPullContinuation({\n            continuation,\n            isCurrent,\n            metadataState,\n            persistence,\n            runtime,\n          }),\n        pendingUpdates: input.pendingUpdates,\n        persistedState: metadataState.record,\n        pullContinuation:\n          currentMetadataPullContinuation(metadataState) ?? undefined,\n        rekeyPendingUpdate: persistence.rekeyPendingUpdate,\n        resolveProjectionUserKey: syncInput.resolveProjectionUserKey,\n        runtime,\n        targetSecretKey: syncInput.targetSecretKey,\n        writerProjection:\n          metadataState.metadataWriterProjection?.documentId ===\n          input.documentId\n            ? metadataState.metadataWriterProjection\n            : undefined,\n      }),\n  );\n}\n\nexport async function syncContainerMetadataState(\n  input: SyncContainerMetadataStateInput,\n): Promise<\n  SyncedContainerMetadataState | MissingContainerMetadataState | null\n> {\n  const { persistence, runtime } = input;\n  const liveMetadataState = input.metadataState;\n  const { isCurrent } = input;\n  if (!isCurrent()) {\n    return null;\n  }\n  const { documentId } = liveMetadataState.record;\n  if (!documentId) {\n    return null;\n  }\n  const execSql = runtime.infra.execSql;\n\n  const pendingUpdates = await persistence.listPendingUpdates(\n    execSql,\n    liveMetadataState.container.id,\n  );\n  if (!isCurrent()) {\n    return null;\n  }\n  if (\n    pendingUpdates.length === 0 &&\n    currentMetadataPullContinuation(liveMetadataState) === null &&\n    !liveMetadataState.record.pullContinuationRecoveryRequired &&\n    !input.forceReadSync &&\n    hasCurrentContainerMetadataReadState(liveMetadataState.record)\n  ) {\n    return null;\n  }\n  const metadataState =\n    await createDetachedContainerMetadataState(liveMetadataState);\n  if (!isCurrent()) {\n    return null;\n  }\n\n  const sentUpdateIds: string[] = [];\n\n  const syncAttempt = await requestContainerMetadataSync({\n    documentId,\n    metadataState,\n    pendingUpdates,\n    sentUpdateIds,\n    syncInput: input,\n  });\n  if (!syncAttempt) {\n    return null;\n  }\n  if (!isCurrent()) {\n    discardUnacceptedContainerMetadataUpdateIds(\n      input.locallyAcceptedUpdateIds,\n      sentUpdateIds,\n      [],\n    );\n    return null;\n  }\n  const finalized = await finalizeContainerMetadataSync({\n    documentId,\n    isCurrent,\n    locallyAcceptedUpdateIds: input.locallyAcceptedUpdateIds,\n    metadataState,\n    onDurableStateNeedsReload: input.onDurableStateNeedsReload,\n    persistence,\n    runtime,\n    sentUpdateIds,\n    syncAttempt,\n  });\n  if (!isCurrent() || !finalized) {\n    return null;\n  }\n  if (!(\"missing\" in finalized)) {\n    installDetachedContainerMetadataState(liveMetadataState, metadataState, {\n      preserveConcurrentMetadataEdit: true,\n    });\n  }\n  return finalized;\n}\n\nasync function finalizeContainerMetadataSync(input: {\n  documentId: string;\n  isCurrent: () => boolean;\n  locallyAcceptedUpdateIds: Set<string> | undefined;\n  metadataState: ContainerMetadataState;\n  onDurableStateNeedsReload?: (() => void) | undefined;\n  persistence: ContainerContentsPersistence;\n  runtime: ContainerMetadataSyncRuntime;\n  sentUpdateIds: readonly string[];\n  syncAttempt: ContainerMetadataSyncAttempt;\n}): Promise<\n  SyncedContainerMetadataState | MissingContainerMetadataState | null\n> {\n  const { metadataState, syncAttempt } = input;\n  const { outgoingUpdateCount, synced } = syncAttempt;\n  if (!input.isCurrent()) {\n    discardUnacceptedContainerMetadataUpdateIds(\n      input.locallyAcceptedUpdateIds,\n      input.sentUpdateIds,\n      [],\n    );\n    return null;\n  }\n  // An id sent but not accepted will never be echoed. Accepted ids stay\n  // registered until their realtime echo consumes them.\n  discardUnacceptedContainerMetadataUpdateIds(\n    input.locallyAcceptedUpdateIds,\n    input.sentUpdateIds,\n    synced.response.acceptedOutgoingUpdateIds,\n  );\n  metadataState.metadataWriterProjection =\n    resolveSyncedContainerMetadataWriterProjection(metadataState, synced);\n  if (synced.decryptedUpdates.length > 0) {\n    applyIncomingContainerMetadataUpdates(metadataState.doc, synced);\n  }\n  const persisted = await persistContainerMetadataStateFromRuntime({\n    acceptedPendingUpdateIds: synced.settledPendingUpdateIds,\n    clearSyncFailure: shouldClearDocumentSyncFailureAfterPass(\n      synced,\n      outgoingUpdateCount,\n    ),\n    expectedSyncState: {\n      pullContinuation: syncAttempt.consumedPullContinuation ?? null,\n      record: syncAttempt.requestRecord,\n    },\n    metadataState,\n    onDurableStateNeedsReload: input.onDurableStateNeedsReload,\n    patch: {\n      ...synced.persistedState,\n      documentId: input.documentId,\n      lastCommitLsn:\n        synced.response.commitLsn ?? metadataState.record.lastCommitLsn ?? null,\n      metadataDocumentId: input.documentId,\n      pullContinuation: readPullContinuation(synced.response),\n    },\n    persistence: input.persistence,\n    runtime: input.runtime,\n    stillCurrent: input.isCurrent,\n  });\n  if (!input.isCurrent()) {\n    discardUnacceptedContainerMetadataUpdateIds(\n      input.locallyAcceptedUpdateIds,\n      input.sentUpdateIds,\n      [],\n    );\n    return null;\n  }\n  if (!persisted) {\n    discardUnacceptedContainerMetadataUpdateIds(\n      input.locallyAcceptedUpdateIds,\n      input.sentUpdateIds,\n      [],\n    );\n    metadataState.metadataWriterProjection = null;\n    return { missing: true };\n  }\n  metadataState.container = persisted.container;\n  installContainerMetadataRecord(metadataState, persisted.record);\n  if (persisted.pullContinuationSuperseded) {\n    // The response's accepted IDs were not durably settled. Treat every\n    // pre-registration as unapplied so an early echo cannot hide work that the\n    // forced follow-up still needs to reconcile.\n    discardUnacceptedContainerMetadataUpdateIds(\n      input.locallyAcceptedUpdateIds,\n      input.sentUpdateIds,\n      [],\n    );\n    metadataState.metadataWriterProjection = null;\n  }\n\n  return {\n    ...persisted,\n    shouldRequestFollowupSync: shouldRequestContainerMetadataFollowup({\n      persisted,\n      settleOutgoingPass: () =>\n        settleContainerMetadataOutgoingPass(metadataState, syncAttempt),\n    }),\n  };\n}\n"]}

package/workflows/container-contents/metadata/metadataEvents.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentRecord } from "../../../data/sqlite/documentPersistence.js";
+export declare function hasContainerMetadataDocumentUpdateEvent(events: ReadonlyArray<unknown>, metadataStates: Iterable<{
+    record: Pick<DocumentRecord, "documentId">;
+}>, locallyAcceptedUpdateIds?: Set<string>): boolean;
+export declare function listContainerMetadataDocumentUpdateIds(events: ReadonlyArray<unknown>, metadataStates: Iterable<{
+    record: Pick<DocumentRecord, "documentId">;
+}>, locallyAcceptedUpdateIds?: Set<string>): string[];

package/workflows/container-contents/metadata/metadataEvents.js

@@ -0,0 +1,47 @@
+import { isDocumentUpdateCreatedEvent } from "../../../data/documents/documentSync.js";
+export function hasContainerMetadataDocumentUpdateEvent(events, metadataStates, locallyAcceptedUpdateIds) {
+    // A boolean predicate must not consume self-echo ids before the real list
+    // pass classifies the same events.
+    return (listContainerMetadataDocumentUpdateIds(events, metadataStates, locallyAcceptedUpdateIds ? new Set(locallyAcceptedUpdateIds) : undefined).length > 0);
+}
+/** Consume local ids and report whether an event still contains a peer id. */
+function metadataEventHasRemoteUpdate(event, locallyAcceptedUpdateIds) {
+    if (!locallyAcceptedUpdateIds ||
+        !event.updateIds ||
+        event.updateIds.length === 0) {
+        return true;
+    }
+    let remoteUpdateFound = false;
+    for (const updateId of event.updateIds) {
+        if (locallyAcceptedUpdateIds.has(updateId)) {
+            locallyAcceptedUpdateIds.delete(updateId);
+        }
+        else {
+            remoteUpdateFound = true;
+        }
+    }
+    return remoteUpdateFound;
+}
+export function listContainerMetadataDocumentUpdateIds(events, metadataStates, locallyAcceptedUpdateIds) {
+    const metadataDocumentIds = new Set();
+    for (const metadataState of metadataStates) {
+        if (typeof metadataState.record.documentId === "string") {
+            metadataDocumentIds.add(metadataState.record.documentId);
+        }
+    }
+    if (metadataDocumentIds.size === 0)
+        return [];
+    const eventDocumentIds = new Set();
+    for (const event of events) {
+        if (!isDocumentUpdateCreatedEvent(event) ||
+            !metadataDocumentIds.has(event.documentId)) {
+            continue;
+        }
+        if (!metadataEventHasRemoteUpdate(event, locallyAcceptedUpdateIds)) {
+            continue;
+        }
+        eventDocumentIds.add(event.documentId);
+    }
+    return Array.from(eventDocumentIds);
+}
+//# sourceMappingURL=metadataEvents.js.map

package/workflows/container-contents/metadata/metadataEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataEvents.js","sourceRoot":"","sources":["metadataEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AAGpF,MAAM,UAAU,uCAAuC,CACrD,MAA8B,EAC9B,cAAwE,EACxE,wBAAsC;IAEtC,0EAA0E;IAC1E,mCAAmC;IACnC,OAAO,CACL,sCAAsC,CACpC,MAAM,EACN,cAAc,EACd,wBAAwB,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC,SAAS,CACzE,CAAC,MAAM,GAAG,CAAC,CACb,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,SAAS,4BAA4B,CACnC,KAAoD,EACpD,wBAAiD;IAEjD,IACE,CAAC,wBAAwB;QACzB,CAAC,KAAK,CAAC,SAAS;QAChB,KAAK,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAC5B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,iBAAiB,GAAG,KAAK,CAAC;IAC9B,KAAK,MAAM,QAAQ,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACvC,IAAI,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC3C,wBAAwB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5C,CAAC;aAAM,CAAC;YACN,iBAAiB,GAAG,IAAI,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED,MAAM,UAAU,sCAAsC,CACpD,MAA8B,EAC9B,cAAwE,EACxE,wBAAsC;IAEtC,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9C,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;QAC3C,IAAI,OAAO,aAAa,CAAC,MAAM,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;YACxD,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IACD,IAAI,mBAAmB,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAE9C,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC3C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IACE,CAAC,4BAA4B,CAAC,KAAK,CAAC;YACpC,CAAC,mBAAmB,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,EAC1C,CAAC;YACD,SAAS;QACX,CAAC;QACD,IAAI,CAAC,4BAA4B,CAAC,KAAK,EAAE,wBAAwB,CAAC,EAAE,CAAC;YACnE,SAAS;QACX,CAAC;QACD,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACzC,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;AACtC,CAAC","sourcesContent":["import { isDocumentUpdateCreatedEvent } from \"../../../data/documents/documentSync\";\nimport type { DocumentRecord } from \"../../../data/sqlite/documentPersistence\";\n\nexport function hasContainerMetadataDocumentUpdateEvent(\n  events: ReadonlyArray<unknown>,\n  metadataStates: Iterable<{ record: Pick<DocumentRecord, \"documentId\"> }>,\n  locallyAcceptedUpdateIds?: Set<string>,\n): boolean {\n  // A boolean predicate must not consume self-echo ids before the real list\n  // pass classifies the same events.\n  return (\n    listContainerMetadataDocumentUpdateIds(\n      events,\n      metadataStates,\n      locallyAcceptedUpdateIds ? new Set(locallyAcceptedUpdateIds) : undefined,\n    ).length > 0\n  );\n}\n\n/** Consume local ids and report whether an event still contains a peer id. */\nfunction metadataEventHasRemoteUpdate(\n  event: { updateIds?: readonly string[] | undefined },\n  locallyAcceptedUpdateIds: Set<string> | undefined,\n): boolean {\n  if (\n    !locallyAcceptedUpdateIds ||\n    !event.updateIds ||\n    event.updateIds.length === 0\n  ) {\n    return true;\n  }\n\n  let remoteUpdateFound = false;\n  for (const updateId of event.updateIds) {\n    if (locallyAcceptedUpdateIds.has(updateId)) {\n      locallyAcceptedUpdateIds.delete(updateId);\n    } else {\n      remoteUpdateFound = true;\n    }\n  }\n  return remoteUpdateFound;\n}\n\nexport function listContainerMetadataDocumentUpdateIds(\n  events: ReadonlyArray<unknown>,\n  metadataStates: Iterable<{ record: Pick<DocumentRecord, \"documentId\"> }>,\n  locallyAcceptedUpdateIds?: Set<string>,\n): string[] {\n  const metadataDocumentIds = new Set<string>();\n  for (const metadataState of metadataStates) {\n    if (typeof metadataState.record.documentId === \"string\") {\n      metadataDocumentIds.add(metadataState.record.documentId);\n    }\n  }\n  if (metadataDocumentIds.size === 0) return [];\n\n  const eventDocumentIds = new Set<string>();\n  for (const event of events) {\n    if (\n      !isDocumentUpdateCreatedEvent(event) ||\n      !metadataDocumentIds.has(event.documentId)\n    ) {\n      continue;\n    }\n    if (!metadataEventHasRemoteUpdate(event, locallyAcceptedUpdateIds)) {\n      continue;\n    }\n    eventDocumentIds.add(event.documentId);\n  }\n\n  return Array.from(eventDocumentIds);\n}\n"]}

package/workflows/container-contents/metadata/metadataIncomingUpdateIsolation.js

@@ -0,0 +1,40 @@
+import { importDecryptedDocumentSyncUpdates, validateDocumentSyncUpdateImports, } from "../../../data/documents/shared/documentSyncUpdateIsolation.js";
+import { recordDocumentSyncFailure } from "../../../data/sqlite/documentPersistence.js";
+import { getClientSQLitePersistenceRuntime } from "../../../data/sqlite/sqlitePersistenceRuntime.js";
+import { runSerializedSqlMutation, } from "../../../data/sqlite/sqlSchema.js";
+import { reportDocumentSyncQuarantine } from "../../documents/sync/reportDocumentSyncQuarantine.js";
+export async function recordCurrentMetadataSyncFailure(input) {
+    await runSerializedSqlMutation(input.execSql, async (lockedExecSql) => {
+        await getClientSQLitePersistenceRuntime(lockedExecSql).guardedTransaction(async () => {
+            if (input.isCurrent?.() === false)
+                return;
+            await recordDocumentSyncFailure(lockedExecSql, input.metadataScope, input.failure);
+        }, () => input.isCurrent?.() !== false);
+    });
+}
+export function applyIncomingContainerMetadataUpdates(currentDocument, result) {
+    importDecryptedDocumentSyncUpdates(currentDocument, result.decryptedUpdates);
+}
+export function metadataIncomingUpdateIsolation(input) {
+    return {
+        onIncomingUpdateIsolationFailure: async (failure) => {
+            await recordCurrentMetadataSyncFailure({
+                ...input,
+                failure: {
+                    attemptedAt: new Date().toISOString(),
+                    message: failure.message,
+                    status: null,
+                },
+            });
+            if (input.isCurrent?.() === false)
+                return;
+            reportDocumentSyncQuarantine(input.currentDocument, input.logError, failure);
+        },
+        validateIncomingUpdates: (result) => validateDocumentSyncUpdateImports({
+            currentDocument: input.currentDocument,
+            decryptedUpdates: result.decryptedUpdates,
+            responseUpdates: result.response.updates,
+        }),
+    };
+}
+//# sourceMappingURL=metadataIncomingUpdateIsolation.js.map

package/workflows/container-contents/metadata/metadataIncomingUpdateIsolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataIncomingUpdateIsolation.js","sourceRoot":"","sources":["metadataIncomingUpdateIsolation.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,kCAAkC,EAClC,iCAAiC,GAClC,MAAM,4DAA4D,CAAC;AAEpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,EAAE,iCAAiC,EAAE,MAAM,+CAA+C,CAAC;AAClG,OAAO,EAEL,wBAAwB,GACzB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,4BAA4B,EAAE,MAAM,mDAAmD,CAAC;AAIjG,MAAM,CAAC,KAAK,UAAU,gCAAgC,CAAC,KAStD;IACC,MAAM,wBAAwB,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE;QACpE,MAAM,iCAAiC,CAAC,aAAa,CAAC,CAAC,kBAAkB,CACvE,KAAK,IAAI,EAAE;YACT,IAAI,KAAK,CAAC,SAAS,EAAE,EAAE,KAAK,KAAK;gBAAE,OAAO;YAC1C,MAAM,yBAAyB,CAC7B,aAAa,EACb,KAAK,CAAC,aAAa,EACnB,KAAK,CAAC,OAAO,CACd,CAAC;QACJ,CAAC,EACD,GAAG,EAAE,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,KAAK,KAAK,CACpC,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,qCAAqC,CACnD,eAA8C,EAC9C,MAA0D;IAE1D,kCAAkC,CAAC,eAAe,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAC/E,CAAC;AAED,MAAM,UAAU,+BAA+B,CAAC,KAM/C;IACC,OAAO;QACL,gCAAgC,EAAE,KAAK,EACrC,OAAyC,EACzC,EAAE;YACF,MAAM,gCAAgC,CAAC;gBACrC,GAAG,KAAK;gBACR,OAAO,EAAE;oBACP,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;oBACrC,OAAO,EAAE,OAAO,CAAC,OAAO;oBACxB,MAAM,EAAE,IAAI;iBACb;aACF,CAAC,CAAC;YACH,IAAI,KAAK,CAAC,SAAS,EAAE,EAAE,KAAK,KAAK;gBAAE,OAAO;YAC1C,4BAA4B,CAC1B,KAAK,CAAC,eAAe,EACrB,KAAK,CAAC,QAAQ,EACd,OAAO,CACR,CAAC;QACJ,CAAC;QACD,uBAAuB,EAAE,CACvB,MAAuE,EACvE,EAAE,CACF,iCAAiC,CAAC;YAChC,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;YACzC,eAAe,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO;SACzC,CAAC;KACL,CAAC;AACJ,CAAC","sourcesContent":["import {\n  type DocumentSyncUpdateIsolationError,\n  importDecryptedDocumentSyncUpdates,\n  validateDocumentSyncUpdateImports,\n} from \"../../../data/documents/shared/documentSyncUpdateIsolation\";\nimport type { SyncRemoteDocumentResult } from \"../../../data/documents/shared/types\";\nimport { recordDocumentSyncFailure } from \"../../../data/sqlite/documentPersistence\";\nimport { getClientSQLitePersistenceRuntime } from \"../../../data/sqlite/sqlitePersistenceRuntime\";\nimport {\n  type ExecSql,\n  runSerializedSqlMutation,\n} from \"../../../data/sqlite/sqlSchema\";\nimport { reportDocumentSyncQuarantine } from \"../../documents/sync/reportDocumentSyncQuarantine\";\nimport type { WorkflowRuntimeUtilInput } from \"../../shared/runtimeInput\";\nimport type { ContainerMetadataState } from \"./metadataTypes\";\n\nexport async function recordCurrentMetadataSyncFailure(input: {\n  execSql: ExecSql;\n  failure: {\n    readonly attemptedAt: string;\n    readonly message: string;\n    readonly status: number | null;\n  };\n  isCurrent?: (() => boolean) | undefined;\n  metadataScope: { appKind: string; localId: string };\n}): Promise<void> {\n  await runSerializedSqlMutation(input.execSql, async (lockedExecSql) => {\n    await getClientSQLitePersistenceRuntime(lockedExecSql).guardedTransaction(\n      async () => {\n        if (input.isCurrent?.() === false) return;\n        await recordDocumentSyncFailure(\n          lockedExecSql,\n          input.metadataScope,\n          input.failure,\n        );\n      },\n      () => input.isCurrent?.() !== false,\n    );\n  });\n}\n\nexport function applyIncomingContainerMetadataUpdates(\n  currentDocument: ContainerMetadataState[\"doc\"],\n  result: Pick<SyncRemoteDocumentResult, \"decryptedUpdates\">,\n): void {\n  importDecryptedDocumentSyncUpdates(currentDocument, result.decryptedUpdates);\n}\n\nexport function metadataIncomingUpdateIsolation(input: {\n  currentDocument: ContainerMetadataState[\"doc\"];\n  execSql: ExecSql;\n  isCurrent?: (() => boolean) | undefined;\n  logError?: WorkflowRuntimeUtilInput[\"logError\"] | undefined;\n  metadataScope: { appKind: string; localId: string };\n}) {\n  return {\n    onIncomingUpdateIsolationFailure: async (\n      failure: DocumentSyncUpdateIsolationError,\n    ) => {\n      await recordCurrentMetadataSyncFailure({\n        ...input,\n        failure: {\n          attemptedAt: new Date().toISOString(),\n          message: failure.message,\n          status: null,\n        },\n      });\n      if (input.isCurrent?.() === false) return;\n      reportDocumentSyncQuarantine(\n        input.currentDocument,\n        input.logError,\n        failure,\n      );\n    },\n    validateIncomingUpdates: (\n      result: Pick<SyncRemoteDocumentResult, \"decryptedUpdates\" | \"response\">,\n    ) =>\n      validateDocumentSyncUpdateImports({\n        currentDocument: input.currentDocument,\n        decryptedUpdates: result.decryptedUpdates,\n        responseUpdates: result.response.updates,\n      }),\n  };\n}\n"]}

package/workflows/container-contents/metadata/metadataMutationPreparation.d.ts

@@ -0,0 +1,75 @@
+import type { ContainerContentsPersistence } from "../../../data/persistence/container-contents/containerContentsPersistence.js";
+import type { ExecSql } from "../../../data/sqlite/sqlSchema.js";
+import type { ContainerDocumentRecord as DocumentRecord } from "../containerPersistence.js";
+import { type ExpectedContainerMetadataSyncState } from "./metadataSyncSettlement.js";
+import type { ContainerMetadataPatch, ContainerMetadataState } from "./metadataTypes.js";
+export interface PersistContainerMetadataStateInput {
+    acceptedPendingUpdateIds?: readonly string[] | undefined;
+    clearSyncFailure?: boolean | undefined;
+    execSql: ExecSql;
+    expectedSyncState?: ExpectedContainerMetadataSyncState | undefined;
+    localMetadataPatch?: Partial<Pick<ContainerMetadataPatch, "icon" | "name">> | undefined;
+    localUpdate?: Uint8Array | undefined;
+    metadataState: ContainerMetadataState;
+    createIntentSettlement?: Parameters<ContainerContentsPersistence["commitMetadataMutation"]>[1]["createIntentSettlement"];
+    moveIntentSettlement?: Parameters<ContainerContentsPersistence["commitMetadataMutation"]>[1]["moveIntentSettlement"];
+    patch?: Partial<ContainerMetadataPatch> | undefined;
+    persistence: ContainerContentsPersistence;
+    preserveDurableStructureWhenPending?: boolean | undefined;
+    saveOptions?: Parameters<ContainerContentsPersistence["saveContainer"]>[3] | undefined;
+    stillCurrent?: (() => boolean) | undefined;
+}
+export declare function currentMetadataPullContinuation(metadataState: ContainerMetadataState): import("../../documents/index.js").DocumentSyncPullContinuation | null;
+export declare function resolveMetadataSecurityContext(metadataState: ContainerMetadataState, patch: Partial<ContainerMetadataPatch>): {
+    accessEpoch: number;
+    changed: boolean;
+    documentId: string | null;
+    documentIdChanged: boolean;
+};
+export declare function loadAuthoritativeContainerMetadataState(input: {
+    containerId: string;
+    execSql: ExecSql;
+    persistence: ContainerContentsPersistence;
+}): Promise<{
+    container: import("../containerPersistence.js").ContainerRecord;
+    record: DocumentRecord;
+} | null>;
+export declare function prepareContainerMetadataMutation(input: PersistContainerMetadataStateInput, execSql: ExecSql, patch: Partial<ContainerMetadataPatch>): Promise<{
+    authoritativeState: null;
+    pullContinuationSuperseded: boolean;
+    securityContextMatches: boolean;
+    durableRecord?: never;
+    mutationContainer?: never;
+    mutationMetadataState?: never;
+    mutationPatch?: never;
+    pendingLocalUpdate?: never;
+    securityContext?: never;
+} | {
+    authoritativeState: {
+        container: import("../containerPersistence.js").ContainerRecord;
+        record: DocumentRecord;
+    };
+    pullContinuationSuperseded: boolean;
+    securityContextMatches: boolean;
+    durableRecord?: never;
+    mutationContainer?: never;
+    mutationMetadataState?: never;
+    mutationPatch?: never;
+    pendingLocalUpdate?: never;
+    securityContext?: never;
+} | {
+    durableRecord: DocumentRecord;
+    mutationContainer: import("../containerPersistence.js").ContainerRecord;
+    mutationMetadataState: ContainerMetadataState;
+    mutationPatch: Partial<ContainerMetadataPatch>;
+    pendingLocalUpdate: Uint8Array<ArrayBufferLike> | undefined;
+    pullContinuationSuperseded: boolean;
+    securityContext: {
+        accessEpoch: number;
+        changed: boolean;
+        documentId: string | null;
+        documentIdChanged: boolean;
+    };
+    securityContextMatches: boolean;
+    authoritativeState?: never;
+}>;