@tearleads/client-sdk 0.1.62 → 0.1.64

package/workflows/documents/sync/index.js

@@ -0,0 +1,287 @@
+import { KeyingVerificationError } from "../../../internal/crypto/index.js";
+import { isDocumentUpdateCreatedEvent } from "../../../data/documents/documentSync.js";
+import { isDocumentSyncUpdateIsolationError } from "../../../data/documents/shared/documentSyncUpdateIsolation.js";
+import { InvalidDocumentSyncPullContinuationError, } from "../../../data/documents/shared/syncPagination.js";
+import { isProjectionVerificationCancelledError, requireProjectionUserKeyResolver, } from "../../../data/keyingProjectionVerification/index.js";
+import { createVerifiedRemoteDocumentDeletionHandler } from "../purge/index.js";
+import { assertRawContinuationCanRetry, resolveSyncAttemptWriterProjection, submitDocumentSyncAttemptIfAllowed, } from "../syncFailures/index.js";
+import { abandonAfterRetryableConflicts, abandonBlockedSync, } from "../syncFailures/syncAbandon.js";
+import { recoverablePendingUpdates } from "../syncPlan/syncPlanRequestBounds.js";
+import { requireStandaloneAncestorRepairs } from "../syncRekeys/syncContainerRekeyPreparation.js";
+import { tryPersistedReadOnlyDocumentSync, } from "./readOnlySync.js";
+import { planDocumentSyncAttempt, projectionFailureHandler, } from "./syncAttemptPlanning.js";
+import { resolveSubmittedDocumentSyncResult } from "./syncSubmittedResult.js";
+export function hasDocumentUpdateEvent(events, documentId) {
+    if (!documentId)
+        return false;
+    return events.some((event) => isDocumentUpdateCreatedEvent(event) && event.documentId === documentId);
+}
+/**
+ * A retryable stale-projection conflict means this writer projection is behind
+ * the server. Evict only this document so the next attempt re-derives targets.
+ */
+function evictStaleProjectionForRetry(input) {
+    input.apiClient.evictDocumentWriterProjection?.(input.documentId);
+}
+/**
+ * A pass may repair a covering-baseline rejection by regenerating queued
+ * rotation checkpoints — but only when there is something to regenerate FROM
+ * (a snapshot provider and queued checkpoint rows), the failed pass was not
+ * already a heal or a regeneration (whose fresh baseline proves this device
+ * is simply behind), and an attempt remains.
+ */
+function canRegenerateQueuedCheckpoints(input) {
+    return (!input.regenerateQueuedCheckpoints &&
+        !input.materializedPlan.healedStaleContentKeyBundle &&
+        input.sync.buildRotationSnapshot !== undefined &&
+        input.pendingUpdates.some((update) => update.sourceVersionVector != null));
+}
+async function submitPlannedSyncAttempt(args) {
+    try {
+        return await submitDocumentSyncAttemptIfAllowed({
+            apiClient: args.sync.apiClient,
+            attempt: args.attempt,
+            canRegenerateQueuedCheckpoints: canRegenerateQueuedCheckpoints({
+                materializedPlan: args.materializedPlan,
+                pendingUpdates: args.pendingUpdates,
+                regenerateQueuedCheckpoints: args.regenerateQueuedCheckpoints,
+                sync: args.sync,
+            }),
+            documentId: args.sync.documentId,
+            expectedCommitLsnMode: args.pullContinuation?.commitLsnMode,
+            isRemoteSyncBlocked: args.sync.isRemoteSyncBlocked,
+            maxAttempts: args.maxAttempts,
+            onInlineRepairRefused: () => requireStandaloneAncestorRepairs(args.sync),
+            onRemoteDocumentDeleted: args.sync.onRemoteDocumentDeleted,
+            onOutgoingUpdatesMaterialized: args.sync.onOutgoingUpdatesMaterialized,
+            onSyncTrace: args.sync.onSyncTrace,
+            onTerminalSubmitFailure: args.sync.onTerminalSubmitFailure,
+            pendingUpdates: args.pendingUpdates,
+            plan: args.materializedPlan.plan,
+            failureBlocksQueuedWrites: args.failureBlocksQueuedWrites,
+            stillCurrent: args.sync.stillCurrent,
+            warmReferencedPrincipalPolicies: args.sync.warmReferencedPrincipalPolicies,
+        });
+    }
+    catch (error) {
+        if (error instanceof InvalidDocumentSyncPullContinuationError &&
+            args.pullContinuation !== undefined &&
+            args.sync.historyMode !== "raw") {
+            return "retry";
+        }
+        throw error;
+    }
+}
+function resolveAttemptProjection(input, failureBlocksQueuedWrites, reusableWriterProjection) {
+    return resolveSyncAttemptWriterProjection({
+        apiClient: input.apiClient,
+        documentId: input.documentId,
+        onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,
+        onSyncAbandoned: input.onSyncAbandoned,
+        onSyncTrace: input.onSyncTrace,
+        onTerminalFailure: projectionFailureHandler(input, failureBlocksQueuedWrites),
+        reusableWriterProjection,
+        stillCurrent: input.stillCurrent,
+    });
+}
+function resolveRemoteSyncProjectionUserKey(input) {
+    return requireProjectionUserKeyResolver(input.resolveProjectionUserKey, "Remote document sync");
+}
+async function invalidatePullCursor(input, pullContinuation) {
+    if (pullContinuation !== undefined) {
+        await input.onPullContinuationInvalidated?.(pullContinuation);
+    }
+    return undefined;
+}
+async function preparePersistedDocumentSync(input, resolveProjectionUserKey) {
+    let pullContinuation = input.pullContinuation;
+    try {
+        const persisted = await tryPersistedReadOnlyDocumentSync(input, resolveProjectionUserKey);
+        if (persisted?.kind === "completed")
+            return persisted;
+        if (persisted?.kind === "not_completed" && input.historyMode !== "raw") {
+            pullContinuation = await invalidatePullCursor(input, pullContinuation);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof InvalidDocumentSyncPullContinuationError) ||
+            pullContinuation === undefined ||
+            input.historyMode === "raw") {
+            throw error;
+        }
+        pullContinuation = await invalidatePullCursor(input, pullContinuation);
+    }
+    return { kind: "continue", pullContinuation };
+}
+function failureBlocksQueuedWrites(input) {
+    return (input.pendingUpdates.length > 0 || input.recoveryPendingUpdateCount > 0);
+}
+async function retryRemoteSyncAttempt(sync, continuation) {
+    evictStaleProjectionForRetry(sync);
+    return {
+        kind: "retry",
+        pullContinuation: await invalidatePullCursor(sync, continuation),
+    };
+}
+async function runRemoteDocumentSyncAttempt(input) {
+    if (input.sync.stillCurrent?.() === false) {
+        return { kind: "complete", result: null };
+    }
+    const blocksQueuedWrites = failureBlocksQueuedWrites({
+        pendingUpdates: input.state.pendingUpdates,
+        recoveryPendingUpdateCount: input.state.recoveryPendingUpdatesById.size,
+    });
+    const writerProjection = await resolveAttemptProjection(input.sync, blocksQueuedWrites, input.state.reusableWriterProjection);
+    if (input.sync.stillCurrent?.() === false || !writerProjection) {
+        return { kind: "complete", result: null };
+    }
+    const planned = await planDocumentSyncAttempt({
+        pendingUpdates: input.state.pendingUpdates,
+        pullContinuation: input.state.pullContinuation,
+        regenerateQueuedCheckpoints: input.state.regenerateQueuedCheckpoints,
+        sync: input.sync,
+        failureBlocksQueuedWrites: blocksQueuedWrites,
+        writerProjection,
+    });
+    if (planned === "retry") {
+        return retryRemoteSyncAttempt(input.sync, input.state.pullContinuation);
+    }
+    if (!planned || input.sync.stillCurrent?.() === false) {
+        return { kind: "complete", result: null };
+    }
+    const [materializedPlan] = planned;
+    const submitted = await submitPlannedSyncAttempt({
+        attempt: input.attempt,
+        materializedPlan,
+        maxAttempts: input.maxAttempts,
+        pendingUpdates: recoverablePendingUpdates(input.state.pendingUpdates, materializedPlan),
+        pullContinuation: input.state.pullContinuation,
+        regenerateQueuedCheckpoints: input.state.regenerateQueuedCheckpoints,
+        sync: input.sync,
+        failureBlocksQueuedWrites: blocksQueuedWrites,
+    });
+    if (input.sync.stillCurrent?.() === false || submitted === "cancelled") {
+        return { kind: "complete", result: null };
+    }
+    if (submitted === "retry") {
+        assertRawContinuationCanRetry(input.sync.historyMode, input.state.pullContinuation);
+        return retryRemoteSyncAttempt(input.sync, input.state.pullContinuation);
+    }
+    if (submitted === "blocked") {
+        abandonBlockedSync(input.sync);
+        return { kind: "complete", result: null };
+    }
+    if (submitted === "stop") {
+        input.sync.onSyncAbandoned?.("the sync submit failed terminally");
+        return { kind: "complete", result: null };
+    }
+    if (submitted.kind === "regenerate_queued_checkpoints") {
+        return { kind: "regenerate" };
+    }
+    if (submitted.kind === "recover_update_id_conflict") {
+        // A lost response may mean the server committed both this update id and an
+        // inline container rekey. Force the read-only recovery pass to observe that
+        // committed successor projection instead of reusing a cached predecessor.
+        evictStaleProjectionForRetry(input.sync);
+        return { kind: "recover", updates: submitted.recoveryPendingUpdatesById };
+    }
+    const result = await resolveSubmittedDocumentSyncResult({
+        materializedPlan,
+        pendingUpdateIds: input.pendingUpdateIds,
+        pullComplete: submitted.pullComplete,
+        recoveryPendingUpdatesById: input.state.recoveryPendingUpdatesById,
+        resolveProjectionUserKey: input.resolveProjectionUserKey,
+        response: submitted.response,
+        sync: input.sync,
+        writerProjection: materializedPlan.writerProjection,
+    });
+    return {
+        kind: "complete",
+        result: input.sync.stillCurrent?.() === false ? null : result,
+    };
+}
+async function syncRemoteDocumentInternal(input) {
+    if (input.stillCurrent?.() === false)
+        return null;
+    const resolveProjectionUserKey = resolveRemoteSyncProjectionUserKey(input);
+    const maxAttempts = 3;
+    let pendingUpdates = input.pendingUpdates ?? [];
+    const pendingUpdateIds = pendingUpdates.map((update) => update.id);
+    let recoveryPendingUpdatesById = new Map();
+    let regenerateQueuedCheckpoints = false;
+    let reusableWriterProjection = input.writerProjection ?? null;
+    const persistedSync = await preparePersistedDocumentSync(input, resolveProjectionUserKey);
+    if (input.stillCurrent?.() === false)
+        return null;
+    if (persistedSync.kind === "completed")
+        return persistedSync.result;
+    let pullContinuation = persistedSync.pullContinuation;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const outcome = await runRemoteDocumentSyncAttempt({
+            attempt,
+            maxAttempts,
+            pendingUpdateIds,
+            resolveProjectionUserKey,
+            state: {
+                pendingUpdates,
+                pullContinuation,
+                recoveryPendingUpdatesById,
+                regenerateQueuedCheckpoints,
+                reusableWriterProjection,
+            },
+            sync: input,
+        });
+        reusableWriterProjection = null;
+        if (outcome.kind === "complete")
+            return outcome.result;
+        if (outcome.kind === "retry") {
+            pullContinuation = outcome.pullContinuation;
+            if (input.stillCurrent?.() === false)
+                return null;
+            continue;
+        }
+        if (outcome.kind === "regenerate") {
+            regenerateQueuedCheckpoints = true;
+            continue;
+        }
+        recoveryPendingUpdatesById = outcome.updates;
+        pendingUpdates = [];
+    }
+    return abandonAfterRetryableConflicts(input);
+}
+export async function syncRemoteDocument(input) {
+    try {
+        return await syncRemoteDocumentInternal({
+            ...input,
+            onRemoteDocumentDeleted: createVerifiedRemoteDocumentDeletionHandler({
+                apiClient: input.apiClient,
+                execSql: input.execSql,
+                expectedOrganizationId: input.author.organizationId,
+                onVerifiedDeletion: ({ commitPurgeProof, documentId }) => {
+                    if (input.stillCurrent?.() === false)
+                        return;
+                    if (!input.onRemoteDocumentDeleted) {
+                        throw new KeyingVerificationError("missing_dependency", "Remote document deletion requires atomic local teardown");
+                    }
+                    return input.onRemoteDocumentDeleted({
+                        commitPurgeProof,
+                        documentId,
+                    });
+                },
+                resolveProjectionUserKey: input.resolveProjectionUserKey,
+                stillCurrent: input.stillCurrent,
+                warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,
+            }),
+        });
+    }
+    catch (error) {
+        if (isProjectionVerificationCancelledError(error))
+            return null;
+        if (input.stillCurrent?.() !== false &&
+            isDocumentSyncUpdateIsolationError(error)) {
+            await input.onIncomingUpdateIsolationFailure?.(error);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=index.js.map

package/workflows/documents/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyingVerificationError } from \"@tearleads/crypto\";\nimport type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { isDocumentUpdateCreatedEvent } from \"../../../data/documents/documentSync\";\nimport { isDocumentSyncUpdateIsolationError } from \"../../../data/documents/shared/documentSyncUpdateIsolation\";\nimport {\n  type DocumentSyncPullContinuation,\n  InvalidDocumentSyncPullContinuationError,\n} from \"../../../data/documents/shared/syncPagination\";\nimport type {\n  MaterializedDocumentSyncPlan,\n  SyncRemoteDocumentResult,\n} from \"../../../data/documents/shared/types\";\nimport {\n  isProjectionVerificationCancelledError,\n  type ProjectionUserKeyResolver,\n  requireProjectionUserKeyResolver,\n} from \"../../../data/keyingProjectionVerification\";\nimport type { PendingUpdateRecord } from \"../../../data/sqlite/documentPersistence\";\nimport { createVerifiedRemoteDocumentDeletionHandler } from \"../purge\";\nimport {\n  assertRawContinuationCanRetry,\n  resolveSyncAttemptWriterProjection,\n  submitDocumentSyncAttemptIfAllowed,\n} from \"../syncFailures\";\nimport {\n  abandonAfterRetryableConflicts,\n  abandonBlockedSync,\n} from \"../syncFailures/syncAbandon\";\nimport { recoverablePendingUpdates } from \"../syncPlan/syncPlanRequestBounds\";\nimport { requireStandaloneAncestorRepairs } from \"../syncRekeys/syncContainerRekeyPreparation\";\nimport {\n  type SyncRemoteDocumentInput,\n  tryPersistedReadOnlyDocumentSync,\n} from \"./readOnlySync\";\nimport {\n  planDocumentSyncAttempt,\n  projectionFailureHandler,\n} from \"./syncAttemptPlanning\";\nimport type {\n  RemoteDocumentSyncAttemptOutcome,\n  RemoteDocumentSyncAttemptState,\n} from \"./syncAttemptState\";\nimport { resolveSubmittedDocumentSyncResult } from \"./syncSubmittedResult\";\n\nexport function hasDocumentUpdateEvent(\n  events: ReadonlyArray<unknown>,\n  documentId: string | null | undefined,\n): boolean {\n  if (!documentId) return false;\n  return events.some(\n    (event) =>\n      isDocumentUpdateCreatedEvent(event) && event.documentId === documentId,\n  );\n}\n/**\n * A retryable stale-projection conflict means this writer projection is behind\n * the server. Evict only this document so the next attempt re-derives targets.\n */\nfunction evictStaleProjectionForRetry(input: SyncRemoteDocumentInput): void {\n  input.apiClient.evictDocumentWriterProjection?.(input.documentId);\n}\n\n/**\n * A pass may repair a covering-baseline rejection by regenerating queued\n * rotation checkpoints — but only when there is something to regenerate FROM\n * (a snapshot provider and queued checkpoint rows), the failed pass was not\n * already a heal or a regeneration (whose fresh baseline proves this device\n * is simply behind), and an attempt remains.\n */\nfunction canRegenerateQueuedCheckpoints(input: {\n  materializedPlan: MaterializedDocumentSyncPlan;\n  pendingUpdates: readonly PendingUpdateRecord[];\n  regenerateQueuedCheckpoints: boolean;\n  sync: SyncRemoteDocumentInput;\n}): boolean {\n  return (\n    !input.regenerateQueuedCheckpoints &&\n    !input.materializedPlan.healedStaleContentKeyBundle &&\n    input.sync.buildRotationSnapshot !== undefined &&\n    input.pendingUpdates.some((update) => update.sourceVersionVector != null)\n  );\n}\n\nasync function submitPlannedSyncAttempt(args: {\n  attempt: number;\n  materializedPlan: MaterializedDocumentSyncPlan;\n  maxAttempts: number;\n  pendingUpdates: readonly PendingUpdateRecord[];\n  pullContinuation?: DocumentSyncPullContinuation | undefined;\n  regenerateQueuedCheckpoints: boolean;\n  sync: SyncRemoteDocumentInput;\n  failureBlocksQueuedWrites: boolean;\n}) {\n  try {\n    return await submitDocumentSyncAttemptIfAllowed({\n      apiClient: args.sync.apiClient,\n      attempt: args.attempt,\n      canRegenerateQueuedCheckpoints: canRegenerateQueuedCheckpoints({\n        materializedPlan: args.materializedPlan,\n        pendingUpdates: args.pendingUpdates,\n        regenerateQueuedCheckpoints: args.regenerateQueuedCheckpoints,\n        sync: args.sync,\n      }),\n      documentId: args.sync.documentId,\n      expectedCommitLsnMode: args.pullContinuation?.commitLsnMode,\n      isRemoteSyncBlocked: args.sync.isRemoteSyncBlocked,\n      maxAttempts: args.maxAttempts,\n      onInlineRepairRefused: () => requireStandaloneAncestorRepairs(args.sync),\n      onRemoteDocumentDeleted: args.sync.onRemoteDocumentDeleted,\n      onOutgoingUpdatesMaterialized: args.sync.onOutgoingUpdatesMaterialized,\n      onSyncTrace: args.sync.onSyncTrace,\n      onTerminalSubmitFailure: args.sync.onTerminalSubmitFailure,\n      pendingUpdates: args.pendingUpdates,\n      plan: args.materializedPlan.plan,\n      failureBlocksQueuedWrites: args.failureBlocksQueuedWrites,\n      stillCurrent: args.sync.stillCurrent,\n      warmReferencedPrincipalPolicies:\n        args.sync.warmReferencedPrincipalPolicies,\n    });\n  } catch (error) {\n    if (\n      error instanceof InvalidDocumentSyncPullContinuationError &&\n      args.pullContinuation !== undefined &&\n      args.sync.historyMode !== \"raw\"\n    ) {\n      return \"retry\" as const;\n    }\n    throw error;\n  }\n}\n\nfunction resolveAttemptProjection(\n  input: SyncRemoteDocumentInput,\n  failureBlocksQueuedWrites: boolean,\n  reusableWriterProjection: DocumentWriterProjectionResponse | null,\n) {\n  return resolveSyncAttemptWriterProjection({\n    apiClient: input.apiClient,\n    documentId: input.documentId,\n    onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,\n    onSyncAbandoned: input.onSyncAbandoned,\n    onSyncTrace: input.onSyncTrace,\n    onTerminalFailure: projectionFailureHandler(\n      input,\n      failureBlocksQueuedWrites,\n    ),\n    reusableWriterProjection,\n    stillCurrent: input.stillCurrent,\n  });\n}\nfunction resolveRemoteSyncProjectionUserKey(input: SyncRemoteDocumentInput) {\n  return requireProjectionUserKeyResolver(\n    input.resolveProjectionUserKey,\n    \"Remote document sync\",\n  );\n}\n\nasync function invalidatePullCursor(\n  input: SyncRemoteDocumentInput,\n  pullContinuation: DocumentSyncPullContinuation | undefined,\n): Promise<undefined> {\n  if (pullContinuation !== undefined) {\n    await input.onPullContinuationInvalidated?.(pullContinuation);\n  }\n  return undefined;\n}\n\nasync function preparePersistedDocumentSync(\n  input: SyncRemoteDocumentInput,\n  resolveProjectionUserKey: ProjectionUserKeyResolver,\n): Promise<\n  | { readonly kind: \"completed\"; result: SyncRemoteDocumentResult | null }\n  | {\n      readonly kind: \"continue\";\n      pullContinuation: DocumentSyncPullContinuation | undefined;\n    }\n> {\n  let pullContinuation = input.pullContinuation;\n  try {\n    const persisted = await tryPersistedReadOnlyDocumentSync(\n      input,\n      resolveProjectionUserKey,\n    );\n    if (persisted?.kind === \"completed\") return persisted;\n    if (persisted?.kind === \"not_completed\" && input.historyMode !== \"raw\") {\n      pullContinuation = await invalidatePullCursor(input, pullContinuation);\n    }\n  } catch (error) {\n    if (\n      !(error instanceof InvalidDocumentSyncPullContinuationError) ||\n      pullContinuation === undefined ||\n      input.historyMode === \"raw\"\n    ) {\n      throw error;\n    }\n    pullContinuation = await invalidatePullCursor(input, pullContinuation);\n  }\n  return { kind: \"continue\", pullContinuation };\n}\n\nfunction failureBlocksQueuedWrites(input: {\n  readonly pendingUpdates: readonly PendingUpdateRecord[];\n  readonly recoveryPendingUpdateCount: number;\n}): boolean {\n  return (\n    input.pendingUpdates.length > 0 || input.recoveryPendingUpdateCount > 0\n  );\n}\n\nasync function retryRemoteSyncAttempt(\n  sync: SyncRemoteDocumentInput,\n  continuation: DocumentSyncPullContinuation | undefined,\n): Promise<RemoteDocumentSyncAttemptOutcome> {\n  evictStaleProjectionForRetry(sync);\n  return {\n    kind: \"retry\",\n    pullContinuation: await invalidatePullCursor(sync, continuation),\n  };\n}\n\nasync function runRemoteDocumentSyncAttempt(input: {\n  attempt: number;\n  maxAttempts: number;\n  pendingUpdateIds: readonly string[];\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  state: RemoteDocumentSyncAttemptState;\n  sync: SyncRemoteDocumentInput;\n}): Promise<RemoteDocumentSyncAttemptOutcome> {\n  if (input.sync.stillCurrent?.() === false) {\n    return { kind: \"complete\", result: null };\n  }\n  const blocksQueuedWrites = failureBlocksQueuedWrites({\n    pendingUpdates: input.state.pendingUpdates,\n    recoveryPendingUpdateCount: input.state.recoveryPendingUpdatesById.size,\n  });\n  const writerProjection = await resolveAttemptProjection(\n    input.sync,\n    blocksQueuedWrites,\n    input.state.reusableWriterProjection,\n  );\n  if (input.sync.stillCurrent?.() === false || !writerProjection) {\n    return { kind: \"complete\", result: null };\n  }\n  const planned = await planDocumentSyncAttempt({\n    pendingUpdates: input.state.pendingUpdates,\n    pullContinuation: input.state.pullContinuation,\n    regenerateQueuedCheckpoints: input.state.regenerateQueuedCheckpoints,\n    sync: input.sync,\n    failureBlocksQueuedWrites: blocksQueuedWrites,\n    writerProjection,\n  });\n  if (planned === \"retry\") {\n    return retryRemoteSyncAttempt(input.sync, input.state.pullContinuation);\n  }\n  if (!planned || input.sync.stillCurrent?.() === false) {\n    return { kind: \"complete\", result: null };\n  }\n  const [materializedPlan] = planned;\n  const submitted = await submitPlannedSyncAttempt({\n    attempt: input.attempt,\n    materializedPlan,\n    maxAttempts: input.maxAttempts,\n    pendingUpdates: recoverablePendingUpdates(\n      input.state.pendingUpdates,\n      materializedPlan,\n    ),\n    pullContinuation: input.state.pullContinuation,\n    regenerateQueuedCheckpoints: input.state.regenerateQueuedCheckpoints,\n    sync: input.sync,\n    failureBlocksQueuedWrites: blocksQueuedWrites,\n  });\n  if (input.sync.stillCurrent?.() === false || submitted === \"cancelled\") {\n    return { kind: \"complete\", result: null };\n  }\n  if (submitted === \"retry\") {\n    assertRawContinuationCanRetry(\n      input.sync.historyMode,\n      input.state.pullContinuation,\n    );\n    return retryRemoteSyncAttempt(input.sync, input.state.pullContinuation);\n  }\n  if (submitted === \"blocked\") {\n    abandonBlockedSync(input.sync);\n    return { kind: \"complete\", result: null };\n  }\n  if (submitted === \"stop\") {\n    input.sync.onSyncAbandoned?.(\"the sync submit failed terminally\");\n    return { kind: \"complete\", result: null };\n  }\n  if (submitted.kind === \"regenerate_queued_checkpoints\") {\n    return { kind: \"regenerate\" };\n  }\n  if (submitted.kind === \"recover_update_id_conflict\") {\n    // A lost response may mean the server committed both this update id and an\n    // inline container rekey. Force the read-only recovery pass to observe that\n    // committed successor projection instead of reusing a cached predecessor.\n    evictStaleProjectionForRetry(input.sync);\n    return { kind: \"recover\", updates: submitted.recoveryPendingUpdatesById };\n  }\n  const result = await resolveSubmittedDocumentSyncResult({\n    materializedPlan,\n    pendingUpdateIds: input.pendingUpdateIds,\n    pullComplete: submitted.pullComplete,\n    recoveryPendingUpdatesById: input.state.recoveryPendingUpdatesById,\n    resolveProjectionUserKey: input.resolveProjectionUserKey,\n    response: submitted.response,\n    sync: input.sync,\n    writerProjection: materializedPlan.writerProjection,\n  });\n  return {\n    kind: \"complete\",\n    result: input.sync.stillCurrent?.() === false ? null : result,\n  };\n}\n\nasync function syncRemoteDocumentInternal(\n  input: SyncRemoteDocumentInput,\n): Promise<SyncRemoteDocumentResult | null> {\n  if (input.stillCurrent?.() === false) return null;\n  const resolveProjectionUserKey = resolveRemoteSyncProjectionUserKey(input);\n  const maxAttempts = 3;\n  let pendingUpdates = input.pendingUpdates ?? [];\n  const pendingUpdateIds = pendingUpdates.map((update) => update.id);\n  let recoveryPendingUpdatesById = new Map<string, PendingUpdateRecord>();\n  let regenerateQueuedCheckpoints = false;\n  let reusableWriterProjection = input.writerProjection ?? null;\n  const persistedSync = await preparePersistedDocumentSync(\n    input,\n    resolveProjectionUserKey,\n  );\n  if (input.stillCurrent?.() === false) return null;\n  if (persistedSync.kind === \"completed\") return persistedSync.result;\n  let pullContinuation = persistedSync.pullContinuation;\n  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {\n    const outcome = await runRemoteDocumentSyncAttempt({\n      attempt,\n      maxAttempts,\n      pendingUpdateIds,\n      resolveProjectionUserKey,\n      state: {\n        pendingUpdates,\n        pullContinuation,\n        recoveryPendingUpdatesById,\n        regenerateQueuedCheckpoints,\n        reusableWriterProjection,\n      },\n      sync: input,\n    });\n    reusableWriterProjection = null;\n    if (outcome.kind === \"complete\") return outcome.result;\n    if (outcome.kind === \"retry\") {\n      pullContinuation = outcome.pullContinuation;\n      if (input.stillCurrent?.() === false) return null;\n      continue;\n    }\n    if (outcome.kind === \"regenerate\") {\n      regenerateQueuedCheckpoints = true;\n      continue;\n    }\n    recoveryPendingUpdatesById = outcome.updates;\n    pendingUpdates = [];\n  }\n  return abandonAfterRetryableConflicts(input);\n}\n\nexport async function syncRemoteDocument(\n  input: SyncRemoteDocumentInput,\n): Promise<SyncRemoteDocumentResult | null> {\n  try {\n    return await syncRemoteDocumentInternal({\n      ...input,\n      onRemoteDocumentDeleted: createVerifiedRemoteDocumentDeletionHandler({\n        apiClient: input.apiClient,\n        execSql: input.execSql,\n        expectedOrganizationId: input.author.organizationId,\n        onVerifiedDeletion: ({ commitPurgeProof, documentId }) => {\n          if (input.stillCurrent?.() === false) return;\n          if (!input.onRemoteDocumentDeleted) {\n            throw new KeyingVerificationError(\n              \"missing_dependency\",\n              \"Remote document deletion requires atomic local teardown\",\n            );\n          }\n          return input.onRemoteDocumentDeleted({\n            commitPurgeProof,\n            documentId,\n          });\n        },\n        resolveProjectionUserKey: input.resolveProjectionUserKey,\n        stillCurrent: input.stillCurrent,\n        warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,\n      }),\n    });\n  } catch (error) {\n    if (isProjectionVerificationCancelledError(error)) return null;\n    if (\n      input.stillCurrent?.() !== false &&\n      isDocumentSyncUpdateIsolationError(error)\n    ) {\n      await input.onIncomingUpdateIsolationFailure?.(error);\n    }\n    throw error;\n  }\n}\n"]}

package/workflows/documents/sync/initialSync.js

@@ -0,0 +1,65 @@
+import { createPendingUpdateFields } from "../../../data/documents/documentSync.js";
+import { importContentKeyMaterial } from "../../../data/documents/shared/contentRecordKeys.js";
+import { encryptDocumentPendingUpdate } from "../../../data/documents/shared/crypto.js";
+import { containerPathRefs } from "../../../data/documents/shared/projection.js";
+import { signDocumentOutgoingUpdate } from "../syncPlan/syncPlanIdentity.js";
+/**
+ * Builds the single encrypted initial write for a provisioned document. The
+ * server commits it with the organization and document manifest transaction.
+ */
+export async function buildInitialDocumentSyncRequest(input) {
+    const pendingFields = createPendingUpdateFields(input.initialUpdate);
+    if (!pendingFields) {
+        throw new Error("Initial document sync update is empty");
+    }
+    const documentId = input.materializedDocument.plan.documentId;
+    const contentKeyBundle = input.materializedDocument.plan.request.contentKeyBundle;
+    const pendingUpdate = {
+        id: crypto.randomUUID(),
+        ...pendingFields,
+    };
+    const encrypted = await encryptDocumentPendingUpdate({
+        contentKeyMaterial: await importContentKeyMaterial(input.materializedDocument.contentKey),
+        contentKeyEpoch: contentKeyBundle.contentKeyEpoch,
+        documentId,
+        organizationId: input.containerProjection.organizationId,
+        update: pendingUpdate,
+    });
+    const outgoingUpdate = await signDocumentOutgoingUpdate({
+        authorizingContainerPathRefs: [
+            containerPathRefs(input.containerProjection.path),
+        ],
+        author: input.author,
+        contentKeyEpoch: contentKeyBundle.contentKeyEpoch,
+        documentId,
+        expectedLinkSetManifestHash: contentKeyBundle.linkSetManifestHash,
+        expectedTargetHash: contentKeyBundle.targetHash,
+        organizationId: input.containerProjection.organizationId,
+        signedAt: new Date().toISOString(),
+        update: {
+            contentRecordId: encrypted.contentRecordId,
+            encryptedData: encrypted.encryptedData,
+            id: pendingUpdate.id,
+            partialEndVersionVector: pendingUpdate.partialEndVersionVector,
+            partialStartVersionVector: pendingUpdate.partialStartVersionVector,
+            metadataHash: encrypted.metadataHash,
+            ciphertextHash: encrypted.ciphertextHash,
+            plaintextHash: encrypted.plaintextHash,
+        },
+    });
+    return {
+        authorizingContainerPathRefs: [
+            containerPathRefs(input.containerProjection.path),
+        ],
+        contentKeyBundle,
+        contentKeyEpoch: contentKeyBundle.contentKeyEpoch,
+        expectedLinkSetManifestHash: contentKeyBundle.linkSetManifestHash,
+        expectedTargetHash: contentKeyBundle.targetHash,
+        // The provisioning device already holds this exact initialized snapshot,
+        // so it does not need the transaction response to echo the update back.
+        localVersionVector: pendingUpdate.partialEndVersionVector,
+        outgoingUpdates: [outgoingUpdate],
+        supportsPullPagination: true,
+    };
+}
+//# sourceMappingURL=initialSync.js.map

package/workflows/documents/sync/initialSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialSync.js","sourceRoot":"","sources":["initialSync.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AAC5F,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAM9E,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CAAC,KAKrD;IACC,MAAM,aAAa,GAAG,yBAAyB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IACrE,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC3D,CAAC;IAED,MAAM,UAAU,GAAG,KAAK,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,CAAC;IAC9D,MAAM,gBAAgB,GACpB,KAAK,CAAC,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC;IAC3D,MAAM,aAAa,GAAwB;QACzC,EAAE,EAAE,MAAM,CAAC,UAAU,EAAE;QACvB,GAAG,aAAa;KACjB,CAAC;IACF,MAAM,SAAS,GAAG,MAAM,4BAA4B,CAAC;QACnD,kBAAkB,EAAE,MAAM,wBAAwB,CAChD,KAAK,CAAC,oBAAoB,CAAC,UAAU,CACtC;QACD,eAAe,EAAE,gBAAgB,CAAC,eAAe;QACjD,UAAU;QACV,cAAc,EAAE,KAAK,CAAC,mBAAmB,CAAC,cAAc;QACxD,MAAM,EAAE,aAAa;KACtB,CAAC,CAAC;IACH,MAAM,cAAc,GAAG,MAAM,0BAA0B,CAAC;QACtD,4BAA4B,EAAE;YAC5B,iBAAiB,CAAC,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC;SAClD;QACD,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,eAAe,EAAE,gBAAgB,CAAC,eAAe;QACjD,UAAU;QACV,2BAA2B,EAAE,gBAAgB,CAAC,mBAAmB;QACjE,kBAAkB,EAAE,gBAAgB,CAAC,UAAU;QAC/C,cAAc,EAAE,KAAK,CAAC,mBAAmB,CAAC,cAAc;QACxD,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QAClC,MAAM,EAAE;YACN,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,aAAa,EAAE,SAAS,CAAC,aAAa;YACtC,EAAE,EAAE,aAAa,CAAC,EAAE;YACpB,uBAAuB,EAAE,aAAa,CAAC,uBAAuB;YAC9D,yBAAyB,EAAE,aAAa,CAAC,yBAAyB;YAClE,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,cAAc,EAAE,SAAS,CAAC,cAAc;YACxC,aAAa,EAAE,SAAS,CAAC,aAAa;SACvC;KACF,CAAC,CAAC;IAEH,OAAO;QACL,4BAA4B,EAAE;YAC5B,iBAAiB,CAAC,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC;SAClD;QACD,gBAAgB;QAChB,eAAe,EAAE,gBAAgB,CAAC,eAAe;QACjD,2BAA2B,EAAE,gBAAgB,CAAC,mBAAmB;QACjE,kBAAkB,EAAE,gBAAgB,CAAC,UAAU;QAC/C,yEAAyE;QACzE,wEAAwE;QACxE,kBAAkB,EAAE,aAAa,CAAC,uBAAuB;QACzD,eAAe,EAAE,CAAC,cAAc,CAAC;QACjC,sBAAsB,EAAE,IAAI;KAC7B,CAAC;AACJ,CAAC","sourcesContent":["import type { DocumentSyncRequest } from \"@tearleads/validators/request\";\nimport type { ContainerWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { createPendingUpdateFields } from \"../../../data/documents/documentSync\";\nimport { importContentKeyMaterial } from \"../../../data/documents/shared/contentRecordKeys\";\nimport { encryptDocumentPendingUpdate } from \"../../../data/documents/shared/crypto\";\nimport { containerPathRefs } from \"../../../data/documents/shared/projection\";\nimport type {\n  DocumentCreateAuthor,\n  MaterializedDocumentCreatePlan,\n} from \"../../../data/documents/shared/types\";\nimport type { PendingUpdateRecord } from \"../../../data/sqlite/documentPersistence\";\nimport { signDocumentOutgoingUpdate } from \"../syncPlan/syncPlanIdentity\";\n\n/**\n * Builds the single encrypted initial write for a provisioned document. The\n * server commits it with the organization and document manifest transaction.\n */\nexport async function buildInitialDocumentSyncRequest(input: {\n  readonly author: DocumentCreateAuthor;\n  readonly containerProjection: ContainerWriterProjectionResponse;\n  readonly initialUpdate: Uint8Array;\n  readonly materializedDocument: MaterializedDocumentCreatePlan;\n}): Promise<DocumentSyncRequest> {\n  const pendingFields = createPendingUpdateFields(input.initialUpdate);\n  if (!pendingFields) {\n    throw new Error(\"Initial document sync update is empty\");\n  }\n\n  const documentId = input.materializedDocument.plan.documentId;\n  const contentKeyBundle =\n    input.materializedDocument.plan.request.contentKeyBundle;\n  const pendingUpdate: PendingUpdateRecord = {\n    id: crypto.randomUUID(),\n    ...pendingFields,\n  };\n  const encrypted = await encryptDocumentPendingUpdate({\n    contentKeyMaterial: await importContentKeyMaterial(\n      input.materializedDocument.contentKey,\n    ),\n    contentKeyEpoch: contentKeyBundle.contentKeyEpoch,\n    documentId,\n    organizationId: input.containerProjection.organizationId,\n    update: pendingUpdate,\n  });\n  const outgoingUpdate = await signDocumentOutgoingUpdate({\n    authorizingContainerPathRefs: [\n      containerPathRefs(input.containerProjection.path),\n    ],\n    author: input.author,\n    contentKeyEpoch: contentKeyBundle.contentKeyEpoch,\n    documentId,\n    expectedLinkSetManifestHash: contentKeyBundle.linkSetManifestHash,\n    expectedTargetHash: contentKeyBundle.targetHash,\n    organizationId: input.containerProjection.organizationId,\n    signedAt: new Date().toISOString(),\n    update: {\n      contentRecordId: encrypted.contentRecordId,\n      encryptedData: encrypted.encryptedData,\n      id: pendingUpdate.id,\n      partialEndVersionVector: pendingUpdate.partialEndVersionVector,\n      partialStartVersionVector: pendingUpdate.partialStartVersionVector,\n      metadataHash: encrypted.metadataHash,\n      ciphertextHash: encrypted.ciphertextHash,\n      plaintextHash: encrypted.plaintextHash,\n    },\n  });\n\n  return {\n    authorizingContainerPathRefs: [\n      containerPathRefs(input.containerProjection.path),\n    ],\n    contentKeyBundle,\n    contentKeyEpoch: contentKeyBundle.contentKeyEpoch,\n    expectedLinkSetManifestHash: contentKeyBundle.linkSetManifestHash,\n    expectedTargetHash: contentKeyBundle.targetHash,\n    // The provisioning device already holds this exact initialized snapshot,\n    // so it does not need the transaction response to echo the update back.\n    localVersionVector: pendingUpdate.partialEndVersionVector,\n    outgoingUpdates: [outgoingUpdate],\n    supportsPullPagination: true,\n  };\n}\n"]}

package/workflows/documents/sync/readOnlyProjectionFailure.js

@@ -0,0 +1,30 @@
+import { KeyingVerificationError } from "../../../internal/crypto/index.js";
+import { isDocumentSyncUpdateIsolationError } from "../../../data/documents/shared/documentSyncUpdateIsolation.js";
+import { rethrowKeyingVerificationError } from "../../../data/keyingProjectionVerification/error.js";
+import { projectionIntegrityErrorCode } from "../syncFailures/syncFailureClassification.js";
+import { DocumentRawHistoryUnavailableError } from "../syncPlan/syncContentKeys.js";
+export const REFRESH_CACHED_PROJECTION = Symbol("refresh cached projection");
+export function handleReadOnlyProjectionCompletionError(error, input) {
+    if (isDocumentSyncUpdateIsolationError(error)) {
+        throw error;
+    }
+    if (error instanceof DocumentRawHistoryUnavailableError) {
+        if (input.allowCachedProjectionRefresh) {
+            return error;
+        }
+        throw error;
+    }
+    if (input.allowCachedProjectionRefresh &&
+        error instanceof KeyingVerificationError &&
+        error.code === "invalid_shape") {
+        return REFRESH_CACHED_PROJECTION;
+    }
+    // The document-store `document.sync` boundary owns durable reporting; this
+    // helper only decides whether an ordinary projection miss is retryable.
+    rethrowKeyingVerificationError(error);
+    if (projectionIntegrityErrorCode(error) || input.historyMode === "raw") {
+        throw error;
+    }
+    return null;
+}
+//# sourceMappingURL=readOnlyProjectionFailure.js.map

package/workflows/documents/sync/readOnlyProjectionFailure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readOnlyProjectionFailure.js","sourceRoot":"","sources":["readOnlyProjectionFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,kCAAkC,EAAE,MAAM,4DAA4D,CAAC;AAChH,OAAO,EAAE,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AAClG,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,kCAAkC,EAAE,MAAM,6BAA6B,CAAC;AAEjF,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,2BAA2B,CAAC,CAAC;AAE7E,MAAM,UAAU,uCAAuC,CACrD,KAAc,EACd,KAGC;IAKD,IAAI,kCAAkC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9C,MAAM,KAAK,CAAC;IACd,CAAC;IACD,IAAI,KAAK,YAAY,kCAAkC,EAAE,CAAC;QACxD,IAAI,KAAK,CAAC,4BAA4B,EAAE,CAAC;YACvC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,IACE,KAAK,CAAC,4BAA4B;QAClC,KAAK,YAAY,uBAAuB;QACxC,KAAK,CAAC,IAAI,KAAK,eAAe,EAC9B,CAAC;QACD,OAAO,yBAAyB,CAAC;IACnC,CAAC;IACD,2EAA2E;IAC3E,wEAAwE;IACxE,8BAA8B,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,4BAA4B,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,EAAE,CAAC;QACvE,MAAM,KAAK,CAAC;IACd,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["import { KeyingVerificationError } from \"@tearleads/crypto\";\nimport { isDocumentSyncUpdateIsolationError } from \"../../../data/documents/shared/documentSyncUpdateIsolation\";\nimport { rethrowKeyingVerificationError } from \"../../../data/keyingProjectionVerification/error\";\nimport { projectionIntegrityErrorCode } from \"../syncFailures/syncFailureClassification\";\nimport { DocumentRawHistoryUnavailableError } from \"../syncPlan/syncContentKeys\";\n\nexport const REFRESH_CACHED_PROJECTION = Symbol(\"refresh cached projection\");\n\nexport function handleReadOnlyProjectionCompletionError(\n  error: unknown,\n  input: {\n    allowCachedProjectionRefresh: boolean;\n    historyMode?: \"raw\" | undefined;\n  },\n):\n  | DocumentRawHistoryUnavailableError\n  | null\n  | typeof REFRESH_CACHED_PROJECTION {\n  if (isDocumentSyncUpdateIsolationError(error)) {\n    throw error;\n  }\n  if (error instanceof DocumentRawHistoryUnavailableError) {\n    if (input.allowCachedProjectionRefresh) {\n      return error;\n    }\n    throw error;\n  }\n  if (\n    input.allowCachedProjectionRefresh &&\n    error instanceof KeyingVerificationError &&\n    error.code === \"invalid_shape\"\n  ) {\n    return REFRESH_CACHED_PROJECTION;\n  }\n  // The document-store `document.sync` boundary owns durable reporting; this\n  // helper only decides whether an ordinary projection miss is retryable.\n  rethrowKeyingVerificationError(error);\n  if (projectionIntegrityErrorCode(error) || input.historyMode === \"raw\") {\n    throw error;\n  }\n  return null;\n}\n"]}

package/workflows/documents/sync/readOnlySync.d.ts

@@ -0,0 +1,71 @@
+import type { DocumentWriterProjectionResponse } from "../../../internal/validators/response/index.js";
+import type { DocumentSyncUpdateIsolationError, IncomingDocumentSyncUpdateValidator } from "../../../data/documents/shared/documentSyncUpdateIsolation.js";
+import { type DocumentSyncPullContinuation } from "../../../data/documents/shared/syncPagination.js";
+import type { DocumentCreateAuthor, DocumentSyncApi, DocumentWriterPublicKeyResolver, PersistedDocumentSyncState, SyncRemoteDocumentResult } from "../../../data/documents/shared/types.js";
+import type { ProjectionUserKeyResolver, ReferencedPrincipalPolicyWarmer } from "../../../data/keyingProjectionVerification/index.js";
+import type { PendingUpdateRecord } from "../../../data/sqlite/documentPersistence.js";
+import type { ExecSql } from "../../../data/sqlite/sqlSchema.js";
+import { type RemoteDocumentDeletionHandler, type TerminalSubmitFailureHandler } from "../syncFailures/syncFailureClassification.js";
+import type { RekeyPendingUpdate } from "../syncRekeys/syncRecoveryRekey.js";
+import type { DocumentSyncContainerRekeyBuilder } from "./syncAttemptState.js";
+import { type DocumentSyncTraceEmitter } from "./syncTrace.js";
+type PersistedReadOnlyDocumentSyncResult = {
+    kind: "completed";
+    result: SyncRemoteDocumentResult | null;
+} | {
+    kind: "not_completed";
+};
+export interface SyncRemoteDocumentInput {
+    apiClient: DocumentSyncApi;
+    author: DocumentCreateAuthor;
+    /**
+     * Supplies a full-history Loro snapshot of the local document so a
+     * write-bearing pass can heal a stale content-key bundle by rotating to a
+     * fresh content key anchored by a rotation baseline.
+     */
+    buildRotationSnapshot?: (() => Promise<Uint8Array | null>) | undefined;
+    /** Overrides automatic ancestor repair for each submission's current projection. */
+    buildContainerRekeys?: DocumentSyncContainerRekeyBuilder;
+    documentId: string;
+    execSql: ExecSql;
+    /** Explicit read-only recovery that bypasses rotation-baseline redirect. */
+    historyMode?: "raw" | undefined;
+    isRemoteSyncBlocked?: ((organizationId: string) => boolean) | undefined;
+    localVersionVector: string | null;
+    minLsn?: string | undefined;
+    pullContinuation?: DocumentSyncPullContinuation | undefined;
+    /** Atomically commits the verified purge proof with matching local teardown. */
+    onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;
+    onSyncAbandoned?: ((reason: string) => void) | undefined;
+    /** Clipboard-safe trace sink (see syncTrace.ts); never receives content. */
+    onSyncTrace?: DocumentSyncTraceEmitter | undefined;
+    /**
+     * Fires when a pass WITHOUT queued writes cannot resolve its writer
+     * projection (e.g. a coded 409 from the projection route). Read-only
+     * revalidation otherwise fails silently — one burned request and a trace
+     * line — leaving the document permanently stale with nothing durable to
+     * explain why (edge-case row 13).
+     */
+    onReadOnlyProjectionFailure?: TerminalSubmitFailureHandler | undefined;
+    /** Records a verified response update that could not be decrypted/imported. */
+    onIncomingUpdateIsolationFailure?: ((failure: DocumentSyncUpdateIsolationError) => void | Promise<void>) | undefined;
+    /** Fires immediately before a materialized outgoing batch is submitted. */
+    onOutgoingUpdatesMaterialized?: ((updateIds: readonly string[]) => void) | undefined;
+    /** Invalidates continuation state after the server rejects its snapshot. */
+    onPullContinuationInvalidated?: ((continuation: DocumentSyncPullContinuation) => void | Promise<void>) | undefined;
+    onTerminalSubmitFailure?: TerminalSubmitFailureHandler | undefined;
+    pendingUpdates?: readonly PendingUpdateRecord[] | undefined;
+    persistedState?: PersistedDocumentSyncState | null | undefined;
+    rekeyPendingUpdate?: RekeyPendingUpdate | undefined;
+    resolveProjectionUserKey: ProjectionUserKeyResolver;
+    resolveWriterPublicKey: DocumentWriterPublicKeyResolver;
+    signedAt?: string | undefined;
+    stillCurrent?: (() => boolean) | undefined;
+    targetSecretKey: Uint8Array;
+    /** Validates decrypted updates against scratch state before callers persist. */
+    validateIncomingUpdates: IncomingDocumentSyncUpdateValidator;
+    warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;
+    writerProjection?: DocumentWriterProjectionResponse | undefined;
+}
+export declare function tryPersistedReadOnlyDocumentSync(input: SyncRemoteDocumentInput, resolveProjectionUserKey: ProjectionUserKeyResolver): Promise<PersistedReadOnlyDocumentSyncResult | null>;
+export {};