@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/container-contents/metadata.js

@@ -1,217 +0,0 @@
-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=metadata.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"metadata.js","sourceRoot":"","sources":["metadata.ts"],"names":[],"mappings":"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","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/metadataEvents.d.ts

@@ -1,7 +0,0 @@
-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/metadataEvents.js

@@ -1,47 +0,0 @@
-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/metadataEvents.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"metadataEvents.js","sourceRoot":"","sources":["metadataEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AAGjF,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/metadataIncomingUpdateIsolation.js

@@ -1,40 +0,0 @@
-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/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/metadataIncomingUpdateIsolation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"metadataIncomingUpdateIsolation.js","sourceRoot":"","sources":["metadataIncomingUpdateIsolation.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,kCAAkC,EAClC,iCAAiC,GAClC,MAAM,yDAAyD,CAAC;AAEjE,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AAC/F,OAAO,EAEL,wBAAwB,GACzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AAIzF,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/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/metadataMutationPreparation.d.ts

@@ -1,75 +0,0 @@
-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;
-}>;

package/workflows/container-contents/metadataMutationPreparation.js

@@ -1,177 +0,0 @@
-import { base64ToBytes } from "../../internal/encoding/index.js";
-import { encodeVersionVector, exportUpdatesSince, importUpdates, } from "../../internal/loro/index.js";
-import { getDefaultContainerName, readContainerMetadataValue, writeContainerMetadataValue, } from "../../data/containers/containerMetadataDocument.js";
-import { documentSyncPullContinuationsEqual } from "../../data/documents/shared/syncPagination.js";
-import { canWriteEffectiveAccessLevel } from "../../data/keying/accessLevel.js";
-import { metadataSyncSecurityContextMatches, replaceSupersededMetadataIdentity, sameNullableMetadataValue, } from "./metadataSyncSettlement.js";
-export function currentMetadataPullContinuation(metadataState) {
-    return Object.hasOwn(metadataState, "pullContinuation")
-        ? (metadataState.pullContinuation ?? null)
-        : (metadataState.record.pullContinuation ?? null);
-}
-export function resolveMetadataSecurityContext(metadataState, patch) {
-    const currentDocumentId = metadataState.record.documentId ?? null;
-    const documentId = patch.documentId !== undefined ? patch.documentId : currentDocumentId;
-    const accessEpoch = patch.accessEpoch ?? metadataState.record.accessEpoch;
-    const documentIdChanged = documentId !== currentDocumentId;
-    return {
-        accessEpoch,
-        changed: documentIdChanged || accessEpoch !== metadataState.record.accessEpoch,
-        documentId,
-        documentIdChanged,
-    };
-}
-function mergeDurableMetadataCheckpoint(input) {
-    const { durableRecord, metadataState, securityContext } = input;
-    if (!durableRecord?.metadataUpdates ||
-        durableRecord.documentId !== metadataState.record.documentId ||
-        durableRecord.documentId !== securityContext.documentId ||
-        durableRecord.accessEpoch !== metadataState.record.accessEpoch ||
-        durableRecord.accessEpoch !== securityContext.accessEpoch) {
-        return;
-    }
-    importUpdates(metadataState.doc, [
-        base64ToBytes(durableRecord.metadataUpdates),
-    ]);
-}
-export async function loadAuthoritativeContainerMetadataState(input) {
-    const stored = await input.persistence.loadContainerMetadataState(input.execSql, input.containerId);
-    return stored?.record
-        ? { container: stored.container, record: stored.record }
-        : null;
-}
-function localMetadataWriteAccessWasRevoked(input) {
-    return (input.mutationInput.expectedSyncState === undefined &&
-        input.mutationInput.localUpdate !== undefined &&
-        canWriteEffectiveAccessLevel(input.mutationInput.metadataState.container.effectiveAccessLevel) &&
-        !canWriteEffectiveAccessLevel(input.authoritativeState.container.effectiveAccessLevel));
-}
-async function prepareRebasedLocalMetadataMutation(input) {
-    const { authoritativeState, metadataState, patch } = input;
-    const replacementVersion = encodeVersionVector(metadataState.doc);
-    const replacementMetadata = readContainerMetadataValue(metadataState.doc, getDefaultContainerName(authoritativeState.container.parentId));
-    writeContainerMetadataValue(metadataState.doc, {
-        ...replacementMetadata,
-        ...input.localMetadataPatch,
-    });
-    const rebasedMetadataState = {
-        ...metadataState,
-        container: authoritativeState.container,
-        pullContinuation: authoritativeState.record.pullContinuation ?? null,
-        record: authoritativeState.record,
-    };
-    return {
-        durableRecord: authoritativeState.record,
-        mutationContainer: authoritativeState.container,
-        mutationMetadataState: rebasedMetadataState,
-        mutationPatch: patch,
-        pendingLocalUpdate: exportUpdatesSince(metadataState.doc, replacementVersion),
-        pullContinuationSuperseded: false,
-        securityContext: resolveMetadataSecurityContext(rebasedMetadataState, patch),
-        securityContextMatches: true,
-    };
-}
-function resolveMetadataSettlementMatch(expectedSyncState, durableRecord) {
-    if (!expectedSyncState) {
-        return {
-            contentStateSuperseded: false,
-            pullContinuationSuperseded: false,
-            securityContextMatches: true,
-        };
-    }
-    const securityContextMatches = metadataSyncSecurityContextMatches(durableRecord, expectedSyncState.record);
-    const progressStateMatches = securityContextMatches &&
-        sameNullableMetadataValue(durableRecord?.lastCommitLsn, expectedSyncState.record.lastCommitLsn) &&
-        Boolean(durableRecord?.pullContinuationRecoveryRequired) ===
-            Boolean(expectedSyncState.record.pullContinuationRecoveryRequired) &&
-        documentSyncPullContinuationsEqual(durableRecord?.pullContinuation, expectedSyncState.pullContinuation);
-    const contentStateMatches = progressStateMatches &&
-        sameNullableMetadataValue(durableRecord?.metadataUpdates, expectedSyncState.record.metadataUpdates) &&
-        sameNullableMetadataValue(durableRecord?.snapshotEndVersion, expectedSyncState.record.snapshotEndVersion);
-    return {
-        contentStateSuperseded: progressStateMatches && !contentStateMatches,
-        pullContinuationSuperseded: !progressStateMatches,
-        securityContextMatches,
-    };
-}
-export async function prepareContainerMetadataMutation(input, execSql, patch) {
-    const { metadataState, persistence } = input;
-    const authoritativeState = await loadAuthoritativeContainerMetadataState({
-        containerId: metadataState.container.id,
-        execSql,
-        persistence,
-    });
-    if (!authoritativeState) {
-        return {
-            authoritativeState: null,
-            pullContinuationSuperseded: true,
-            securityContextMatches: false,
-        };
-    }
-    if (localMetadataWriteAccessWasRevoked({
-        authoritativeState,
-        mutationInput: input,
-    })) {
-        await replaceSupersededMetadataIdentity({
-            durableRecord: authoritativeState.record,
-            metadataState,
-        });
-        return {
-            authoritativeState,
-            pullContinuationSuperseded: true,
-            securityContextMatches: false,
-        };
-    }
-    const durableRecord = authoritativeState.record;
-    const mutationMetadataState = durableRecord
-        ? {
-            ...metadataState,
-            pullContinuation: durableRecord.pullContinuation ?? null,
-            record: durableRecord,
-        }
-        : metadataState;
-    const capturedSecurityContextMatches = durableRecord !== null &&
-        metadataSyncSecurityContextMatches(durableRecord, metadataState.record);
-    const { contentStateSuperseded, pullContinuationSuperseded, securityContextMatches, } = resolveMetadataSettlementMatch(input.expectedSyncState, durableRecord);
-    if (input.expectedSyncState === undefined &&
-        !capturedSecurityContextMatches) {
-        await replaceSupersededMetadataIdentity({
-            durableRecord: authoritativeState.record,
-            metadataState,
-        });
-        if (input.localUpdate === undefined) {
-            return {
-                authoritativeState,
-                pullContinuationSuperseded: true,
-                securityContextMatches: false,
-            };
-        }
-        return prepareRebasedLocalMetadataMutation({
-            authoritativeState,
-            localMetadataPatch: input.localMetadataPatch,
-            metadataState,
-            patch,
-        });
-    }
-    const mutationPatch = pullContinuationSuperseded ? {} : patch;
-    const securityContext = resolveMetadataSecurityContext(mutationMetadataState, mutationPatch);
-    if (securityContextMatches &&
-        (input.expectedSyncState === undefined || contentStateSuperseded)) {
-        mergeDurableMetadataCheckpoint({
-            durableRecord,
-            metadataState,
-            securityContext,
-        });
-    }
-    return {
-        durableRecord,
-        mutationContainer: authoritativeState.container,
-        mutationMetadataState,
-        mutationPatch,
-        pendingLocalUpdate: input.localUpdate,
-        pullContinuationSuperseded,
-        securityContext,
-        securityContextMatches,
-    };
-}
-//# sourceMappingURL=metadataMutationPreparation.js.map