@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/documents/readOnlySync.js

@@ -1,269 +0,0 @@
-import { isAccessManifestBundleWireResponse, isDocumentContentKeyBundleResponse, isDocumentKekTargetsResponse, } from "../../internal/validators/response/index.js";
-import { isRetryableDocumentSyncConflict, persistedDocumentSyncStateFromResponse, submitDocumentSync, } from "../../data/documents/shared/responses.js";
-import { resolvePullContinuationMinLsn, } from "../../data/documents/shared/syncPagination.js";
-import { projectionVerificationOptions } from "../../data/documents/shared/types.js";
-import { readCanonicalRecord } from "../../data/keying/canonicalJson.js";
-import { limitDocumentSyncRequestBytes } from "../../data/sync/documentSyncOutgoingBatch.js";
-import { handleReadOnlyProjectionCompletionError, REFRESH_CACHED_PROJECTION, } from "./readOnlyProjectionFailure.js";
-import { DocumentRawHistoryUnavailableError } from "./syncContentKeys.js";
-import { handleUpstreamDeletedDocumentSyncFailure, projectionIntegrityErrorCode, } from "./syncFailureClassification.js";
-import { assertRawContinuationCanRetry, refreshSyncAttemptWriterProjection, resolveSyncAttemptWriterProjection, } from "./syncFailures.js";
-import { buildDocumentSyncPlan } from "./syncPlanIdentity.js";
-import { buildMaterializedDocumentSyncPlan } from "./syncPlanMaterial.js";
-import { syncRemoteDocumentResultFromResponse } from "./syncResponseResult.js";
-import { traceSubmitFailed } from "./syncTrace.js";
-async function completeReadOnlyRemoteDocumentSyncWithProjection(input) {
-    const materializedPlan = await buildMaterializedDocumentSyncPlan({
-        author: input.author,
-        execSql: input.execSql,
-        historyMode: input.historyMode,
-        localVersionVector: input.localVersionVector,
-        minLsn: resolvePullContinuationMinLsn(input.pullContinuation, input.minLsn),
-        pullCursor: input.pullContinuation?.cursor,
-        onSyncTrace: input.onSyncTrace,
-        pendingUpdates: [],
-        signedAt: input.signedAt,
-        targetSecretKey: input.targetSecretKey,
-        writerProjection: input.writerProjection,
-        ...projectionVerificationOptions(input),
-    });
-    const result = await syncRemoteDocumentResultFromResponse({
-        ...projectionVerificationOptions(input),
-        execSql: input.execSql,
-        materializedPlan,
-        recoveryPendingUpdatesById: new Map(),
-        resolveWriterPublicKey: input.resolveWriterPublicKey,
-        response: input.response,
-        targetSecretKey: input.targetSecretKey,
-        validateIncomingUpdates: input.validateIncomingUpdates,
-        writerProjection: input.writerProjection,
-        resolveProjectionUserKey: input.resolveProjectionUserKey,
-    });
-    return {
-        ...result,
-        hasIncompletePull: !input.pullComplete,
-    };
-}
-function parsePersistedDocumentSyncRecord(value, label, isRecord) {
-    if (!value) {
-        return null;
-    }
-    try {
-        const record = readCanonicalRecord(JSON.parse(value), label);
-        return isRecord(record) ? record : null;
-    }
-    catch {
-        return null;
-    }
-}
-function parsePersistedDocumentSyncState(persistedState, documentId) {
-    if (persistedState?.documentId !== documentId) {
-        return null;
-    }
-    const contentKeyBundle = parsePersistedDocumentSyncRecord(persistedState.contentKeyBundle, "Persisted document sync content-key bundle", isDocumentContentKeyBundleResponse);
-    const documentKekTargets = parsePersistedDocumentSyncRecord(persistedState.documentKekTargets, "Persisted document sync KEK targets", isDocumentKekTargetsResponse);
-    const documentManifest = parsePersistedDocumentSyncRecord(persistedState.documentManifestBundle, "Persisted document sync manifest", isAccessManifestBundleWireResponse);
-    if (!contentKeyBundle || !documentKekTargets || !documentManifest) {
-        return null;
-    }
-    return {
-        contentKeyBundle,
-        documentKekTargets,
-        documentManifest,
-    };
-}
-async function buildReadOnlyDocumentSyncPlanFromPersistedState(input) {
-    const persisted = parsePersistedDocumentSyncState(input.persistedState, input.documentId);
-    if (!persisted) {
-        return null;
-    }
-    const plan = await buildDocumentSyncPlan({
-        author: input.author,
-        contentKeyBundle: persisted.contentKeyBundle,
-        documentId: input.documentId,
-        documentKekTargets: persisted.documentKekTargets,
-        documentManifest: persisted.documentManifest,
-        historyMode: input.historyMode,
-        localVersionVector: input.localVersionVector,
-        minLsn: resolvePullContinuationMinLsn(input.pullContinuation, input.minLsn),
-        outgoingUpdates: [],
-        pullCursor: input.pullContinuation?.cursor,
-        signedAt: input.signedAt,
-    });
-    const request = limitDocumentSyncRequestBytes(plan.request);
-    return request === plan.request ? plan : { ...plan, request };
-}
-async function tryCompleteReadOnlyRemoteDocumentSyncWithProjection(input) {
-    try {
-        return await completeReadOnlyRemoteDocumentSyncWithProjection({
-            ...input.completion,
-            writerProjection: input.writerProjection,
-        });
-    }
-    catch (error) {
-        return handleReadOnlyProjectionCompletionError(error, {
-            allowCachedProjectionRefresh: input.allowCachedProjectionRefresh,
-            historyMode: input.completion.historyMode,
-        });
-    }
-}
-async function completeReadOnlyRemoteDocumentSyncWithUpdates(input) {
-    const reusableWriterProjection = input.writerProjection?.documentId === input.documentId
-        ? input.writerProjection
-        : null;
-    const writerProjection = reusableWriterProjection ??
-        (await resolveSyncAttemptWriterProjection({
-            apiClient: input.apiClient,
-            documentId: input.documentId,
-            onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,
-            onSyncTrace: input.onSyncTrace,
-            onTerminalFailure: input.onReadOnlyProjectionFailure,
-            reusableWriterProjection: null,
-            stillCurrent: input.stillCurrent,
-        }));
-    if (!writerProjection) {
-        return { kind: "completed", result: null };
-    }
-    const canRefreshProjection = input.historyMode === "raw" || Boolean(reusableWriterProjection);
-    let result = null;
-    let retryAfterRollback = false;
-    try {
-        result = await tryCompleteReadOnlyRemoteDocumentSyncWithProjection({
-            allowCachedProjectionRefresh: canRefreshProjection,
-            completion: input,
-            writerProjection,
-        });
-    }
-    catch (error) {
-        if (projectionIntegrityErrorCode(error) !== "rollback") {
-            throw error;
-        }
-        retryAfterRollback = true;
-    }
-    if (!retryAfterRollback &&
-        result !== REFRESH_CACHED_PROJECTION &&
-        !(result instanceof DocumentRawHistoryUnavailableError) &&
-        (result || !reusableWriterProjection)) {
-        return { kind: "completed", result };
-    }
-    const freshWriterProjection = await refreshSyncAttemptWriterProjection({
-        apiClient: input.apiClient,
-        documentId: input.documentId,
-        onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,
-        onSyncTrace: input.onSyncTrace,
-        onTerminalFailure: input.onReadOnlyProjectionFailure,
-        stillCurrent: input.stillCurrent,
-        unavailableError: result instanceof DocumentRawHistoryUnavailableError ? result : undefined,
-    });
-    if (!freshWriterProjection) {
-        return { kind: "completed", result: null };
-    }
-    const freshResult = await tryCompleteReadOnlyRemoteDocumentSyncWithProjection({
-        allowCachedProjectionRefresh: false,
-        completion: input,
-        writerProjection: freshWriterProjection,
-    });
-    if (freshResult === REFRESH_CACHED_PROJECTION ||
-        freshResult instanceof DocumentRawHistoryUnavailableError) {
-        throw new Error("Fresh document projection unexpectedly requested refresh");
-    }
-    return freshResult
-        ? { kind: "completed", result: freshResult }
-        : { kind: "not_completed" };
-}
-async function syncReadOnlyRemoteDocumentFromPersistedState(input) {
-    let plan;
-    try {
-        plan = await buildReadOnlyDocumentSyncPlanFromPersistedState(input);
-    }
-    catch {
-        plan = null;
-    }
-    if (!plan) {
-        return { kind: "not_completed" };
-    }
-    if (input.stillCurrent?.() === false) {
-        return { kind: "completed", result: null };
-    }
-    const submitted = await submitDocumentSync({
-        apiClient: input.apiClient,
-        expectedCommitLsnMode: input.pullContinuation?.commitLsnMode,
-        plan,
-    });
-    if (input.stillCurrent?.() === false) {
-        return { kind: "completed", result: null };
-    }
-    if (!submitted) {
-        return { kind: "completed", result: null };
-    }
-    if (!submitted.ok) {
-        if (await handleUpstreamDeletedDocumentSyncFailure({
-            documentId: input.documentId,
-            failure: submitted,
-            onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,
-        })) {
-            return { kind: "completed", result: null };
-        }
-        if (isRetryableDocumentSyncConflict(submitted)) {
-            traceSubmitFailed(input.onSyncTrace, {
-                action: "retry",
-                code: submitted.code,
-                documentId: input.documentId,
-                status: submitted.status,
-            });
-            assertRawContinuationCanRetry(input.historyMode, input.pullContinuation);
-            return { kind: "not_completed" };
-        }
-        traceSubmitFailed(input.onSyncTrace, {
-            action: "stop",
-            code: submitted.code,
-            documentId: input.documentId,
-            status: submitted.status,
-        });
-        submitted.report();
-        return { kind: "completed", result: null };
-    }
-    if (submitted.response.updates.length > 0) {
-        return completeReadOnlyRemoteDocumentSyncWithUpdates({
-            ...input,
-            pullComplete: submitted.pullComplete,
-            response: submitted.response,
-        });
-    }
-    try {
-        const persistedState = await persistedDocumentSyncStateFromResponse(plan, submitted.response, { resolveWriterPublicKey: input.resolveWriterPublicKey });
-        return {
-            kind: "completed",
-            result: {
-                contentKey: new Uint8Array(),
-                decryptedUpdates: [],
-                exhaustedPendingUpdateCount: 0,
-                hasDeferredPendingUpdates: false,
-                hasIncompletePull: !submitted.pullComplete,
-                persistedState,
-                plan,
-                rekeyedPendingUpdateIds: [],
-                response: submitted.response,
-                settledPendingUpdateIds: [],
-                acceptedRecoveryBaseline: false,
-            },
-        };
-    }
-    catch (error) {
-        if (input.historyMode === "raw") {
-            throw error;
-        }
-        return { kind: "not_completed" };
-    }
-}
-export async function tryPersistedReadOnlyDocumentSync(input, resolveProjectionUserKey) {
-    if (input.stillCurrent?.() === false)
-        return null;
-    if ((input.pendingUpdates ?? []).length > 0)
-        return null;
-    return syncReadOnlyRemoteDocumentFromPersistedState({
-        ...input,
-        resolveProjectionUserKey,
-    });
-}
-//# sourceMappingURL=readOnlySync.js.map

package/workflows/documents/readOnlySync.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"readOnlySync.js","sourceRoot":"","sources":["readOnlySync.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  DocumentCreateResponse,\n  DocumentSyncResponse,\n  DocumentWriterProjectionResponse,\n} from \"@tearleads/validators/response\";\nimport {\n  isAccessManifestBundleWireResponse,\n  isDocumentContentKeyBundleResponse,\n  isDocumentKekTargetsResponse,\n} from \"@tearleads/validators/response\";\nimport type {\n  DocumentSyncUpdateIsolationError,\n  IncomingDocumentSyncUpdateValidator,\n} from \"../../data/documents/shared/documentSyncUpdateIsolation\";\nimport {\n  isRetryableDocumentSyncConflict,\n  persistedDocumentSyncStateFromResponse,\n  submitDocumentSync,\n} from \"../../data/documents/shared/responses\";\nimport {\n  type DocumentSyncPullContinuation,\n  resolvePullContinuationMinLsn,\n} from \"../../data/documents/shared/syncPagination\";\nimport type {\n  DocumentCreateAuthor,\n  DocumentSyncApi,\n  DocumentSyncPlan,\n  DocumentWriterPublicKeyResolver,\n  PersistedDocumentSyncState,\n  SyncRemoteDocumentResult,\n} from \"../../data/documents/shared/types\";\nimport { projectionVerificationOptions } from \"../../data/documents/shared/types\";\nimport { readCanonicalRecord } from \"../../data/keying/canonicalJson\";\nimport type {\n  ProjectionUserKeyResolver,\n  ReferencedPrincipalPolicyWarmer,\n} from \"../../data/keyingProjectionVerification\";\nimport type { PendingUpdateRecord } from \"../../data/sqlite/documentPersistence\";\nimport type { ExecSql } from \"../../data/sqlite/sqlSchema\";\nimport { limitDocumentSyncRequestBytes } from \"../../data/sync/documentSyncOutgoingBatch\";\nimport {\n  handleReadOnlyProjectionCompletionError,\n  REFRESH_CACHED_PROJECTION,\n} from \"./readOnlyProjectionFailure\";\nimport type { DocumentSyncContainerRekeyBuilder } from \"./syncAttemptState\";\nimport { DocumentRawHistoryUnavailableError } from \"./syncContentKeys\";\nimport {\n  handleUpstreamDeletedDocumentSyncFailure,\n  projectionIntegrityErrorCode,\n  type RemoteDocumentDeletionHandler,\n  type TerminalSubmitFailureHandler,\n} from \"./syncFailureClassification\";\nimport {\n  assertRawContinuationCanRetry,\n  refreshSyncAttemptWriterProjection,\n  resolveSyncAttemptWriterProjection,\n} from \"./syncFailures\";\nimport { buildDocumentSyncPlan } from \"./syncPlanIdentity\";\nimport { buildMaterializedDocumentSyncPlan } from \"./syncPlanMaterial\";\nimport type { RekeyPendingUpdate } from \"./syncRecoveryRekey\";\nimport { syncRemoteDocumentResultFromResponse } from \"./syncResponseResult\";\nimport { type DocumentSyncTraceEmitter, traceSubmitFailed } from \"./syncTrace\";\n\nasync function completeReadOnlyRemoteDocumentSyncWithProjection(\n  input: Omit<ReadOnlyDocumentSyncCompletionInput, \"writerProjection\"> & {\n    writerProjection: DocumentWriterProjectionResponse;\n  },\n): Promise<SyncRemoteDocumentResult> {\n  const materializedPlan = await buildMaterializedDocumentSyncPlan({\n    author: input.author,\n    execSql: input.execSql,\n    historyMode: input.historyMode,\n    localVersionVector: input.localVersionVector,\n    minLsn: resolvePullContinuationMinLsn(input.pullContinuation, input.minLsn),\n    pullCursor: input.pullContinuation?.cursor,\n    onSyncTrace: input.onSyncTrace,\n    pendingUpdates: [],\n    signedAt: input.signedAt,\n    targetSecretKey: input.targetSecretKey,\n    writerProjection: input.writerProjection,\n    ...projectionVerificationOptions(input),\n  });\n\n  const result = await syncRemoteDocumentResultFromResponse({\n    ...projectionVerificationOptions(input),\n    execSql: input.execSql,\n    materializedPlan,\n    recoveryPendingUpdatesById: new Map(),\n    resolveWriterPublicKey: input.resolveWriterPublicKey,\n    response: input.response,\n    targetSecretKey: input.targetSecretKey,\n    validateIncomingUpdates: input.validateIncomingUpdates,\n    writerProjection: input.writerProjection,\n    resolveProjectionUserKey: input.resolveProjectionUserKey,\n  });\n  return {\n    ...result,\n    hasIncompletePull: !input.pullComplete,\n  };\n}\n\nfunction parsePersistedDocumentSyncRecord<T>(\n  value: string | null | undefined,\n  label: string,\n  isRecord: (value: unknown) => value is T,\n): T | null {\n  if (!value) {\n    return null;\n  }\n\n  try {\n    const record = readCanonicalRecord(JSON.parse(value), label);\n    return isRecord(record) ? record : null;\n  } catch {\n    return null;\n  }\n}\n\nfunction parsePersistedDocumentSyncState(\n  persistedState: PersistedDocumentSyncState | null | undefined,\n  documentId: string,\n): {\n  contentKeyBundle: DocumentCreateResponse[\"contentKeyBundle\"];\n  documentKekTargets: DocumentSyncResponse[\"documentKekTargets\"];\n  documentManifest: DocumentCreateResponse[\"accessManifest\"];\n} | null {\n  if (persistedState?.documentId !== documentId) {\n    return null;\n  }\n\n  const contentKeyBundle = parsePersistedDocumentSyncRecord(\n    persistedState.contentKeyBundle,\n    \"Persisted document sync content-key bundle\",\n    isDocumentContentKeyBundleResponse,\n  );\n  const documentKekTargets = parsePersistedDocumentSyncRecord(\n    persistedState.documentKekTargets,\n    \"Persisted document sync KEK targets\",\n    isDocumentKekTargetsResponse,\n  );\n  const documentManifest = parsePersistedDocumentSyncRecord(\n    persistedState.documentManifestBundle,\n    \"Persisted document sync manifest\",\n    isAccessManifestBundleWireResponse,\n  );\n\n  if (!contentKeyBundle || !documentKekTargets || !documentManifest) {\n    return null;\n  }\n\n  return {\n    contentKeyBundle,\n    documentKekTargets,\n    documentManifest,\n  };\n}\n\nasync function buildReadOnlyDocumentSyncPlanFromPersistedState(input: {\n  author: DocumentCreateAuthor;\n  documentId: string;\n  historyMode?: \"raw\" | undefined;\n  localVersionVector: string | null;\n  minLsn?: string | undefined;\n  pullContinuation?: DocumentSyncPullContinuation | undefined;\n  persistedState?: PersistedDocumentSyncState | null | undefined;\n  signedAt?: string | undefined;\n}): Promise<DocumentSyncPlan | null> {\n  const persisted = parsePersistedDocumentSyncState(\n    input.persistedState,\n    input.documentId,\n  );\n  if (!persisted) {\n    return null;\n  }\n\n  const plan = await buildDocumentSyncPlan({\n    author: input.author,\n    contentKeyBundle: persisted.contentKeyBundle,\n    documentId: input.documentId,\n    documentKekTargets: persisted.documentKekTargets,\n    documentManifest: persisted.documentManifest,\n    historyMode: input.historyMode,\n    localVersionVector: input.localVersionVector,\n    minLsn: resolvePullContinuationMinLsn(input.pullContinuation, input.minLsn),\n    outgoingUpdates: [],\n    pullCursor: input.pullContinuation?.cursor,\n    signedAt: input.signedAt,\n  });\n  const request = limitDocumentSyncRequestBytes(plan.request);\n  return request === plan.request ? plan : { ...plan, request };\n}\n\ntype PersistedReadOnlyDocumentSyncResult =\n  | {\n      kind: \"completed\";\n      result: SyncRemoteDocumentResult | null;\n    }\n  | {\n      kind: \"not_completed\";\n    };\n\ninterface ReadOnlyDocumentSyncCompletionInput {\n  apiClient: DocumentSyncApi;\n  author: DocumentCreateAuthor;\n  documentId: string;\n  execSql: ExecSql;\n  historyMode?: \"raw\" | undefined;\n  localVersionVector: string | null;\n  minLsn?: string | undefined;\n  pullContinuation?: DocumentSyncPullContinuation | undefined;\n  onReadOnlyProjectionFailure?: TerminalSubmitFailureHandler | undefined;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  pullComplete: boolean;\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  resolveWriterPublicKey: DocumentWriterPublicKeyResolver;\n  response: DocumentSyncResponse;\n  signedAt?: string | undefined;\n  stillCurrent?: (() => boolean) | undefined;\n  targetSecretKey: Uint8Array;\n  validateIncomingUpdates: IncomingDocumentSyncUpdateValidator;\n  warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;\n  writerProjection?: DocumentWriterProjectionResponse | undefined;\n}\n\nasync function tryCompleteReadOnlyRemoteDocumentSyncWithProjection(input: {\n  allowCachedProjectionRefresh: boolean;\n  completion: ReadOnlyDocumentSyncCompletionInput;\n  writerProjection: DocumentWriterProjectionResponse;\n}): Promise<\n  | DocumentRawHistoryUnavailableError\n  | SyncRemoteDocumentResult\n  | null\n  | typeof REFRESH_CACHED_PROJECTION\n> {\n  try {\n    return await completeReadOnlyRemoteDocumentSyncWithProjection({\n      ...input.completion,\n      writerProjection: input.writerProjection,\n    });\n  } catch (error) {\n    return handleReadOnlyProjectionCompletionError(error, {\n      allowCachedProjectionRefresh: input.allowCachedProjectionRefresh,\n      historyMode: input.completion.historyMode,\n    });\n  }\n}\nasync function completeReadOnlyRemoteDocumentSyncWithUpdates(\n  input: ReadOnlyDocumentSyncCompletionInput,\n): Promise<PersistedReadOnlyDocumentSyncResult> {\n  const reusableWriterProjection =\n    input.writerProjection?.documentId === input.documentId\n      ? input.writerProjection\n      : null;\n  const writerProjection =\n    reusableWriterProjection ??\n    (await resolveSyncAttemptWriterProjection({\n      apiClient: input.apiClient,\n      documentId: input.documentId,\n      onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,\n      onSyncTrace: input.onSyncTrace,\n      onTerminalFailure: input.onReadOnlyProjectionFailure,\n      reusableWriterProjection: null,\n      stillCurrent: input.stillCurrent,\n    }));\n  if (!writerProjection) {\n    return { kind: \"completed\", result: null };\n  }\n  const canRefreshProjection =\n    input.historyMode === \"raw\" || Boolean(reusableWriterProjection);\n  let result:\n    | DocumentRawHistoryUnavailableError\n    | SyncRemoteDocumentResult\n    | null\n    | typeof REFRESH_CACHED_PROJECTION = null;\n  let retryAfterRollback = false;\n  try {\n    result = await tryCompleteReadOnlyRemoteDocumentSyncWithProjection({\n      allowCachedProjectionRefresh: canRefreshProjection,\n      completion: input,\n      writerProjection,\n    });\n  } catch (error) {\n    if (projectionIntegrityErrorCode(error) !== \"rollback\") {\n      throw error;\n    }\n    retryAfterRollback = true;\n  }\n  if (\n    !retryAfterRollback &&\n    result !== REFRESH_CACHED_PROJECTION &&\n    !(result instanceof DocumentRawHistoryUnavailableError) &&\n    (result || !reusableWriterProjection)\n  ) {\n    return { kind: \"completed\", result };\n  }\n  const freshWriterProjection = await refreshSyncAttemptWriterProjection({\n    apiClient: input.apiClient,\n    documentId: input.documentId,\n    onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,\n    onSyncTrace: input.onSyncTrace,\n    onTerminalFailure: input.onReadOnlyProjectionFailure,\n    stillCurrent: input.stillCurrent,\n    unavailableError:\n      result instanceof DocumentRawHistoryUnavailableError ? result : undefined,\n  });\n  if (!freshWriterProjection) {\n    return { kind: \"completed\", result: null };\n  }\n  const freshResult = await tryCompleteReadOnlyRemoteDocumentSyncWithProjection(\n    {\n      allowCachedProjectionRefresh: false,\n      completion: input,\n      writerProjection: freshWriterProjection,\n    },\n  );\n  if (\n    freshResult === REFRESH_CACHED_PROJECTION ||\n    freshResult instanceof DocumentRawHistoryUnavailableError\n  ) {\n    throw new Error(\"Fresh document projection unexpectedly requested refresh\");\n  }\n  return freshResult\n    ? { kind: \"completed\", result: freshResult }\n    : { kind: \"not_completed\" };\n}\nasync function syncReadOnlyRemoteDocumentFromPersistedState(\n  input: Omit<\n    ReadOnlyDocumentSyncCompletionInput,\n    \"pullComplete\" | \"response\"\n  > & {\n    persistedState?: PersistedDocumentSyncState | null | undefined;\n  },\n): Promise<PersistedReadOnlyDocumentSyncResult> {\n  let plan: DocumentSyncPlan | null;\n  try {\n    plan = await buildReadOnlyDocumentSyncPlanFromPersistedState(input);\n  } catch {\n    plan = null;\n  }\n  if (!plan) {\n    return { kind: \"not_completed\" };\n  }\n  if (input.stillCurrent?.() === false) {\n    return { kind: \"completed\", result: null };\n  }\n  const submitted = await submitDocumentSync({\n    apiClient: input.apiClient,\n    expectedCommitLsnMode: input.pullContinuation?.commitLsnMode,\n    plan,\n  });\n  if (input.stillCurrent?.() === false) {\n    return { kind: \"completed\", result: null };\n  }\n  if (!submitted) {\n    return { kind: \"completed\", result: null };\n  }\n  if (!submitted.ok) {\n    if (\n      await handleUpstreamDeletedDocumentSyncFailure({\n        documentId: input.documentId,\n        failure: submitted,\n        onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,\n      })\n    ) {\n      return { kind: \"completed\", result: null };\n    }\n\n    if (isRetryableDocumentSyncConflict(submitted)) {\n      traceSubmitFailed(input.onSyncTrace, {\n        action: \"retry\",\n        code: submitted.code,\n        documentId: input.documentId,\n        status: submitted.status,\n      });\n      assertRawContinuationCanRetry(input.historyMode, input.pullContinuation);\n      return { kind: \"not_completed\" };\n    }\n\n    traceSubmitFailed(input.onSyncTrace, {\n      action: \"stop\",\n      code: submitted.code,\n      documentId: input.documentId,\n      status: submitted.status,\n    });\n    submitted.report();\n    return { kind: \"completed\", result: null };\n  }\n\n  if (submitted.response.updates.length > 0) {\n    return completeReadOnlyRemoteDocumentSyncWithUpdates({\n      ...input,\n      pullComplete: submitted.pullComplete,\n      response: submitted.response,\n    });\n  }\n\n  try {\n    const persistedState = await persistedDocumentSyncStateFromResponse(\n      plan,\n      submitted.response,\n      { resolveWriterPublicKey: input.resolveWriterPublicKey },\n    );\n\n    return {\n      kind: \"completed\",\n      result: {\n        contentKey: new Uint8Array(),\n        decryptedUpdates: [],\n        exhaustedPendingUpdateCount: 0,\n        hasDeferredPendingUpdates: false,\n        hasIncompletePull: !submitted.pullComplete,\n        persistedState,\n        plan,\n        rekeyedPendingUpdateIds: [],\n        response: submitted.response,\n        settledPendingUpdateIds: [],\n        acceptedRecoveryBaseline: false,\n      },\n    };\n  } catch (error) {\n    if (input.historyMode === \"raw\") {\n      throw error;\n    }\n    return { kind: \"not_completed\" };\n  }\n}\n\nexport interface SyncRemoteDocumentInput {\n  apiClient: DocumentSyncApi;\n  author: DocumentCreateAuthor;\n  /**\n   * Supplies a full-history Loro snapshot of the local document so a\n   * write-bearing pass can heal a stale content-key bundle by rotating to a\n   * fresh content key anchored by a rotation baseline.\n   */\n  buildRotationSnapshot?: (() => Promise<Uint8Array | null>) | undefined;\n  /** Overrides automatic ancestor repair for each submission's current projection. */\n  buildContainerRekeys?: DocumentSyncContainerRekeyBuilder;\n  documentId: string;\n  execSql: ExecSql;\n  /** Explicit read-only recovery that bypasses rotation-baseline redirect. */\n  historyMode?: \"raw\" | undefined;\n  isRemoteSyncBlocked?: ((organizationId: string) => boolean) | undefined;\n  localVersionVector: string | null;\n  minLsn?: string | undefined;\n  pullContinuation?: DocumentSyncPullContinuation | undefined;\n  /** Atomically commits the verified purge proof with matching local teardown. */\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onSyncAbandoned?: ((reason: string) => void) | undefined;\n  /** Clipboard-safe trace sink (see syncTrace.ts); never receives content. */\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  /**\n   * Fires when a pass WITHOUT queued writes cannot resolve its writer\n   * projection (e.g. a coded 409 from the projection route). Read-only\n   * revalidation otherwise fails silently — one burned request and a trace\n   * line — leaving the document permanently stale with nothing durable to\n   * explain why (edge-case row 13).\n   */\n  onReadOnlyProjectionFailure?: TerminalSubmitFailureHandler | undefined;\n  /** Records a verified response update that could not be decrypted/imported. */\n  onIncomingUpdateIsolationFailure?:\n    | ((failure: DocumentSyncUpdateIsolationError) => void | Promise<void>)\n    | undefined;\n  /** Fires immediately before a materialized outgoing batch is submitted. */\n  onOutgoingUpdatesMaterialized?:\n    | ((updateIds: readonly string[]) => void)\n    | undefined;\n  /** Invalidates continuation state after the server rejects its snapshot. */\n  onPullContinuationInvalidated?:\n    | ((continuation: DocumentSyncPullContinuation) => void | Promise<void>)\n    | undefined;\n  onTerminalSubmitFailure?: TerminalSubmitFailureHandler | undefined;\n  pendingUpdates?: readonly PendingUpdateRecord[] | undefined;\n  persistedState?: PersistedDocumentSyncState | null | undefined;\n  rekeyPendingUpdate?: RekeyPendingUpdate | undefined;\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  resolveWriterPublicKey: DocumentWriterPublicKeyResolver;\n  signedAt?: string | undefined;\n  stillCurrent?: (() => boolean) | undefined;\n  targetSecretKey: Uint8Array;\n  /** Validates decrypted updates against scratch state before callers persist. */\n  validateIncomingUpdates: IncomingDocumentSyncUpdateValidator;\n  warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;\n  writerProjection?: DocumentWriterProjectionResponse | undefined;\n}\n\nexport async function tryPersistedReadOnlyDocumentSync(\n  input: SyncRemoteDocumentInput,\n  resolveProjectionUserKey: ProjectionUserKeyResolver,\n): Promise<PersistedReadOnlyDocumentSyncResult | null> {\n  if (input.stillCurrent?.() === false) return null;\n  if ((input.pendingUpdates ?? []).length > 0) return null;\n\n  return syncReadOnlyRemoteDocumentFromPersistedState({\n    ...input,\n    resolveProjectionUserKey,\n  });\n}\n"]}

package/workflows/documents/reportDocumentSyncQuarantine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reportDocumentSyncQuarantine.js","sourceRoot":"","sources":["reportDocumentSyncQuarantine.ts"],"names":[],"mappings":"AAGA,MAAM,qBAAqB,GAAG,IAAI,OAAO,EAAkB,CAAC;AAE5D,4EAA4E;AAC5E,MAAM,UAAU,4BAA4B,CAC1C,KAAa,EACb,QAA0D,EAC1D,OAAyC;IAEzC,IAAI,CAAC,QAAQ;QAAE,OAAO;IACtB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IAC5E,IAAI,qBAAqB,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,SAAS;QAAE,OAAO;IAC3D,4EAA4E;IAC5E,yEAAyE;IACzE,qBAAqB,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC5C,IAAI,CAAC;QACH,KAAK,OAAO,CAAC,OAAO,CAClB,QAAQ,CAAC,qCAAqC,EAAE,OAAO,CAAC,CACzD,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IAC3B,CAAC;IAAC,MAAM,CAAC;QACP,8DAA8D;IAChE,CAAC;AACH,CAAC","sourcesContent":["import type { DocumentSyncUpdateIsolationError } from \"../../data/documents/shared/documentSyncUpdateIsolation\";\nimport type { WorkflowRuntimeUtilInput } from \"../shared/runtimeInput\";\n\nconst lastQuarantineByScope = new WeakMap<object, string>();\n\n/** Keep host diagnostics failures from replacing the durable quarantine. */\nexport function reportDocumentSyncQuarantine(\n  scope: object,\n  logError: WorkflowRuntimeUtilInput[\"logError\"] | undefined,\n  failure: DocumentSyncUpdateIsolationError,\n): void {\n  if (!logError) return;\n  const signature = JSON.stringify([failure.message, failure.batchUpdateIds]);\n  if (lastQuarantineByScope.get(scope) === signature) return;\n  // Suppress repeats before the host appends local logs and breadcrumbs. Keep\n  // only the last failure, and let discarded document scopes be collected.\n  lastQuarantineByScope.set(scope, signature);\n  try {\n    void Promise.resolve(\n      logError(\"Documents: sync updates quarantined\", failure),\n    ).catch(() => undefined);\n  } catch {\n    // Hosts may throw synchronously or return a rejected promise.\n  }\n}\n"]}

package/workflows/documents/subtreePurgeScope.d.ts

@@ -1,8 +0,0 @@
-import type { AccessManifestBundleWireResponse } from "../../internal/validators/response/index.js";
-/** The selected purge root and the parent the user selected it under. */
-export interface SubtreePurgeRoot {
-    readonly id: string;
-    readonly parentId: string | null;
-}
-/** Check the exact verified path that the destructive request will cite. */
-export declare function assertSubtreePurgePath(path: readonly AccessManifestBundleWireResponse[], root: SubtreePurgeRoot | undefined): void;

package/workflows/documents/subtreePurgeScope.js

@@ -1,18 +0,0 @@
-import { isPlainObject } from "../../internal/validators/isPlainObject.js";
-import { readManifestContainerId } from "../../data/documents/shared/readers.js";
-function readSignedParentContainerId(bundle) {
-    return isPlainObject(bundle.state)
-        ? Reflect.get(bundle.state, "parentContainerId")
-        : undefined;
-}
-/** Check the exact verified path that the destructive request will cite. */
-export function assertSubtreePurgePath(path, root) {
-    if (root === undefined)
-        return;
-    const rootBundle = path.find((bundle) => readManifestContainerId(bundle) === root.id);
-    // A valid move out of the selected subtree, or a settled restore of the
-    // selected root itself, is ordinary concurrent work.
-    if (!rootBundle || readSignedParentContainerId(rootBundle) !== root.parentId)
-        throw new Error("Document placement is outside the requested purge subtree");
-}
-//# sourceMappingURL=subtreePurgeScope.js.map

package/workflows/documents/subtreePurgeScope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"subtreePurgeScope.js","sourceRoot":"","sources":["subtreePurgeScope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAQ9E,SAAS,2BAA2B,CAClC,MAAwC;IAExC,OAAO,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC;QAChC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,mBAAmB,CAAC;QAChD,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,sBAAsB,CACpC,IAAiD,EACjD,IAAkC;IAElC,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO;IAC/B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAC1B,CAAC,MAAM,EAAE,EAAE,CAAC,uBAAuB,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,EAAE,CACxD,CAAC;IACF,wEAAwE;IACxE,qDAAqD;IACrD,IAAI,CAAC,UAAU,IAAI,2BAA2B,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,QAAQ;QAC1E,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;AACN,CAAC","sourcesContent":["import { isPlainObject } from \"@tearleads/validators/isPlainObject\";\nimport type { AccessManifestBundleWireResponse } from \"@tearleads/validators/response\";\nimport { readManifestContainerId } from \"../../data/documents/shared/readers\";\n\n/** The selected purge root and the parent the user selected it under. */\nexport interface SubtreePurgeRoot {\n  readonly id: string;\n  readonly parentId: string | null;\n}\n\nfunction readSignedParentContainerId(\n  bundle: AccessManifestBundleWireResponse,\n): unknown {\n  return isPlainObject(bundle.state)\n    ? Reflect.get(bundle.state, \"parentContainerId\")\n    : undefined;\n}\n\n/** Check the exact verified path that the destructive request will cite. */\nexport function assertSubtreePurgePath(\n  path: readonly AccessManifestBundleWireResponse[],\n  root: SubtreePurgeRoot | undefined,\n): void {\n  if (root === undefined) return;\n  const rootBundle = path.find(\n    (bundle) => readManifestContainerId(bundle) === root.id,\n  );\n  // A valid move out of the selected subtree, or a settled restore of the\n  // selected root itself, is ordinary concurrent work.\n  if (!rootBundle || readSignedParentContainerId(rootBundle) !== root.parentId)\n    throw new Error(\n      \"Document placement is outside the requested purge subtree\",\n    );\n}\n"]}

package/workflows/documents/sync.d.ts

@@ -1,4 +0,0 @@
-import type { SyncRemoteDocumentResult } from "../../data/documents/shared/types.js";
-import { type SyncRemoteDocumentInput } from "./readOnlySync.js";
-export declare function hasDocumentUpdateEvent(events: ReadonlyArray<unknown>, documentId: string | null | undefined): boolean;
-export declare function syncRemoteDocument(input: SyncRemoteDocumentInput): Promise<SyncRemoteDocumentResult | null>;

package/workflows/documents/sync.js

@@ -1,287 +0,0 @@
-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.js";
-import { tryPersistedReadOnlyDocumentSync, } from "./readOnlySync.js";
-import { abandonAfterRetryableConflicts, abandonBlockedSync, } from "./syncAbandon.js";
-import { planDocumentSyncAttempt, projectionFailureHandler, } from "./syncAttemptPlanning.js";
-import { requireStandaloneAncestorRepairs } from "./syncContainerRekeyPreparation.js";
-import { assertRawContinuationCanRetry, resolveSyncAttemptWriterProjection, submitDocumentSyncAttemptIfAllowed, } from "./syncFailures.js";
-import { recoverablePendingUpdates } from "./syncPlanRequestBounds.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=sync.js.map