@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/workflows/documents/syncFailures.js

@@ -0,0 +1,252 @@
+import { DOCUMENT_SYNC_ERROR_CODES, } from "../../internal/validators/response/index.js";
+import { isUpstreamDeletedDocumentSyncFailure, submitDocumentSync, } from "../../data/documents/shared/responses.js";
+import { InvalidDocumentSyncPullContinuationError, } from "../../data/documents/shared/syncPagination.js";
+import { canRecoverDocumentUpdateIdConflict, canRetryDocumentSyncConflict, handleUpstreamDeletedDocumentSyncFailure, isCheckpointCoverageConflict, shouldRetrySyncWithFreshWriterProjection, } from "./syncFailureClassification.js";
+import { cacheDocumentSyncPolicyRepair } from "./syncPolicyRepair.js";
+import { traceProjectionFailed, traceSubmitFailed, } from "./syncTrace.js";
+const REMOTE_DOCUMENT_DELETED = Symbol("remoteDocumentDeleted");
+export function assertRawContinuationCanRetry(historyMode, pullContinuation) {
+    if (historyMode === "raw" && pullContinuation !== undefined) {
+        throw new InvalidDocumentSyncPullContinuationError("Document raw-history continuation became stale");
+    }
+}
+async function resolveFailedDocumentSyncAction(input) {
+    const action = await classifyFailedDocumentSyncAction(input);
+    traceSubmitFailed(input.onSyncTrace, {
+        action: action === "retry" || action === "stop"
+            ? action
+            : action.kind === "recover_update_id_conflict"
+                ? "recover-update-ids"
+                : "regenerate-checkpoints",
+        code: input.failure.code,
+        documentId: input.documentId,
+        status: input.failure.status,
+    });
+    return action;
+}
+async function classifyFailedDocumentSyncAction(input) {
+    if (await handleUpstreamDeletedDocumentSyncFailure({
+        documentId: input.documentId,
+        failure: input.failure,
+        onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,
+    })) {
+        return "stop";
+    }
+    if (canRetryDocumentSyncConflict({
+        attempt: input.attempt,
+        failure: input.failure,
+        maxAttempts: input.maxAttempts,
+    })) {
+        return "retry";
+    }
+    // The write rolled back whole. Its inline repairs would have stranded a
+    // level above a directly granted container, and a flat rekey list cannot say
+    // what each must carry: the retry commits them standalone instead.
+    if (input.attempt < input.maxAttempts &&
+        input.onInlineRepairRefused &&
+        input.failure.code === DOCUMENT_SYNC_ERROR_CODES.descendantRekeysRequired) {
+        input.onInlineRepairRefused();
+        return "retry";
+    }
+    if (canRecoverDocumentUpdateIdConflict({
+        attempt: input.attempt,
+        failure: input.failure,
+        maxAttempts: input.maxAttempts,
+        pendingUpdateCount: input.pendingUpdates.length,
+    })) {
+        return {
+            kind: "recover_update_id_conflict",
+            recoveryPendingUpdatesById: new Map(input.pendingUpdates.map((update) => [update.id, update])),
+        };
+    }
+    if (input.attempt < input.maxAttempts &&
+        input.canRegenerateQueuedCheckpoints === true &&
+        isCheckpointCoverageConflict(input.failure)) {
+        return { kind: "regenerate_queued_checkpoints" };
+    }
+    input.failure.report();
+    await input.onTerminalSubmitFailure?.(input.failure);
+    return "stop";
+}
+async function submitDocumentSyncAttempt(input) {
+    if (input.stillCurrent?.() === false)
+        return "cancelled";
+    const submitted = await submitDocumentSync({
+        apiClient: input.apiClient,
+        expectedCommitLsnMode: input.expectedCommitLsnMode,
+        plan: input.plan,
+    });
+    if (input.stillCurrent?.() === false)
+        return "cancelled";
+    if (!submitted) {
+        return "stop";
+    }
+    if (submitted.ok) {
+        return {
+            kind: "completed",
+            pullComplete: submitted.pullComplete,
+            response: submitted.response,
+        };
+    }
+    await cacheDocumentSyncPolicyRepair({
+        failure: submitted,
+        plan: input.plan,
+        stillCurrent: input.stillCurrent,
+        warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,
+    });
+    if (input.stillCurrent?.() === false)
+        return "cancelled";
+    return resolveFailedDocumentSyncAction({
+        attempt: input.attempt,
+        canRegenerateQueuedCheckpoints: input.canRegenerateQueuedCheckpoints,
+        documentId: input.documentId,
+        failure: submitted,
+        maxAttempts: input.maxAttempts,
+        onInlineRepairRefused: input.onInlineRepairRefused,
+        onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,
+        onSyncTrace: input.onSyncTrace,
+        onTerminalSubmitFailure: input.onTerminalSubmitFailure,
+        pendingUpdates: input.pendingUpdates,
+    });
+}
+export async function submitDocumentSyncAttemptIfAllowed(input) {
+    const { failureBlocksQueuedWrites, isRemoteSyncBlocked, onOutgoingUpdatesMaterialized, ...submissionInput } = input;
+    const hasRemoteWrites = input.plan.request.outgoingUpdates.length > 0 ||
+        (input.plan.request.containerRekeys?.length ?? 0) > 0;
+    if (hasRemoteWrites && isRemoteSyncBlocked?.(input.plan.organizationId)) {
+        return "blocked";
+    }
+    if (input.stillCurrent?.() === false)
+        return "cancelled";
+    onOutgoingUpdatesMaterialized?.(input.plan.request.outgoingUpdates.map(({ id }) => id));
+    return submitDocumentSyncAttempt({
+        ...submissionInput,
+        // A read-only pass carries no writes, so a terminal failure describes a
+        // pull, not queued local data — recording it would flag the next local
+        // edit as failed before it was ever attempted. A cursor continuation and
+        // update-id recovery both submit an empty request while durable rows still
+        // exist; a terminal 403 there IS what blocks the queued edits.
+        onTerminalSubmitFailure: hasRemoteWrites || failureBlocksQueuedWrites
+            ? submissionInput.onTerminalSubmitFailure
+            : undefined,
+    });
+}
+async function resolveDocumentSyncWriterProjection(input) {
+    if (input.stillCurrent?.() === false)
+        return null;
+    if (input.reusableWriterProjection) {
+        return input.reusableWriterProjection;
+    }
+    const result = await input.apiClient.getDocumentWriterProjectionResult(input.documentId, { reportErrors: false });
+    if (input.stillCurrent?.() === false)
+        return null;
+    if (result.ok) {
+        return result.data;
+    }
+    if (isUpstreamDeletedDocumentSyncFailure(result)) {
+        return REMOTE_DOCUMENT_DELETED;
+    }
+    traceProjectionFailed(input.onSyncTrace, {
+        code: result.code,
+        documentId: input.documentId,
+        status: result.status,
+    });
+    result.report();
+    await input.onTerminalFailure?.(result);
+    return null;
+}
+export async function retrySyncPlan(input) {
+    try {
+        return [
+            await input.buildWithProjection(input.writerProjection),
+            input.writerProjection,
+        ];
+    }
+    catch (error) {
+        if (!input.apiClient.evictDocumentWriterProjection ||
+            !shouldRetrySyncWithFreshWriterProjection(error)) {
+            throw error;
+        }
+    }
+    if (input.stillCurrent?.() === false)
+        return null;
+    // Only this document's projection was stale; evict just it so unrelated
+    // documents keep their warm cache instead of a global wipe.
+    input.apiClient.evictDocumentWriterProjection?.(input.documentId);
+    const writerProjection = await resolveDocumentSyncWriterProjection({
+        apiClient: input.apiClient,
+        documentId: input.documentId,
+        onSyncTrace: input.onSyncTrace,
+        onTerminalFailure: input.onTerminalFailure,
+        reusableWriterProjection: null,
+        stillCurrent: input.stillCurrent,
+    });
+    if (input.stillCurrent?.() === false)
+        return null;
+    if (writerProjection === REMOTE_DOCUMENT_DELETED) {
+        await input.onRemoteDocumentDeleted?.({ documentId: input.documentId });
+        return null;
+    }
+    if (!writerProjection) {
+        return null;
+    }
+    return [await input.buildWithProjection(writerProjection), writerProjection];
+}
+/**
+ * Resolves the writer projection for one sync attempt, converting the two
+ * unrecoverable outcomes into an abandoned (null) result with a named reason
+ * so callers that turn a null sync into their own error can surface the real
+ * cause.
+ */
+export async function resolveSyncAttemptWriterProjection(input) {
+    const writerProjection = await resolveDocumentSyncWriterProjection(input);
+    if (input.stillCurrent?.() === false)
+        return null;
+    if (writerProjection === REMOTE_DOCUMENT_DELETED) {
+        await input.onRemoteDocumentDeleted?.({ documentId: input.documentId });
+        if (input.stillCurrent?.() !== false) {
+            input.onSyncAbandoned?.("the remote document was deleted");
+        }
+        return null;
+    }
+    if (!writerProjection) {
+        input.onSyncAbandoned?.("the document writer projection could not be fetched");
+        return null;
+    }
+    return writerProjection;
+}
+export async function refreshSyncAttemptWriterProjection(input) {
+    const { onRemoteDocumentDeleted, unavailableError, ...resolutionInput } = input;
+    if (input.stillCurrent?.() === false)
+        return null;
+    if (input.apiClient.evictDocumentWriterProjection) {
+        input.apiClient.evictDocumentWriterProjection(input.documentId);
+    }
+    else {
+        input.apiClient.clearWriterProjectionCaches?.();
+    }
+    let remoteDocumentDeleted = false;
+    const writerProjection = await resolveSyncAttemptWriterProjection({
+        ...resolutionInput,
+        onRemoteDocumentDeleted: async (deleted) => {
+            remoteDocumentDeleted = true;
+            await onRemoteDocumentDeleted?.(deleted);
+        },
+        reusableWriterProjection: null,
+    });
+    if (!writerProjection &&
+        unavailableError !== undefined &&
+        !remoteDocumentDeleted &&
+        input.stillCurrent?.() !== false) {
+        throw unavailableError;
+    }
+    return writerProjection;
+}
+export async function retrySyncPlanOrAbandon(input) {
+    const planned = await retrySyncPlan(input);
+    if (!planned && input.stillCurrent?.() !== false) {
+        input.onSyncAbandoned?.("a sync plan could not be built against the current projection");
+    }
+    return planned;
+}
+//# sourceMappingURL=syncFailures.js.map

package/workflows/documents/syncFailures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncFailures.js","sourceRoot":"","sources":["syncFailures.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DOCUMENT_SYNC_ERROR_CODES,\n  type DocumentSyncResponse,\n  type DocumentWriterProjectionResponse,\n} from \"@tearleads/validators/response\";\nimport {\n  isUpstreamDeletedDocumentSyncFailure,\n  submitDocumentSync,\n} from \"../../data/documents/shared/responses\";\nimport {\n  type DocumentSyncCommitLsnMode,\n  type DocumentSyncPullContinuation,\n  InvalidDocumentSyncPullContinuationError,\n} from \"../../data/documents/shared/syncPagination\";\nimport type {\n  DocumentSyncApi,\n  DocumentSyncPlan,\n  DocumentSyncSubmitFailure,\n  MaterializedDocumentSyncPlan,\n} from \"../../data/documents/shared/types\";\nimport type { ReferencedPrincipalPolicyWarmer } from \"../../data/keyingProjectionVerification\";\nimport type { PendingUpdateRecord } from \"../../data/sqlite/documentPersistence\";\nimport {\n  canRecoverDocumentUpdateIdConflict,\n  canRetryDocumentSyncConflict,\n  handleUpstreamDeletedDocumentSyncFailure,\n  isCheckpointCoverageConflict,\n  type RemoteDocumentDeletionHandler,\n  shouldRetrySyncWithFreshWriterProjection,\n  type TerminalSubmitFailureHandler,\n} from \"./syncFailureClassification\";\nimport { cacheDocumentSyncPolicyRepair } from \"./syncPolicyRepair\";\nimport {\n  type DocumentSyncTraceEmitter,\n  traceProjectionFailed,\n  traceSubmitFailed,\n} from \"./syncTrace\";\n\nconst REMOTE_DOCUMENT_DELETED = Symbol(\"remoteDocumentDeleted\");\n\nexport function assertRawContinuationCanRetry(\n  historyMode: \"raw\" | undefined,\n  pullContinuation: DocumentSyncPullContinuation | undefined,\n): void {\n  if (historyMode === \"raw\" && pullContinuation !== undefined) {\n    throw new InvalidDocumentSyncPullContinuationError(\n      \"Document raw-history continuation became stale\",\n    );\n  }\n}\n\ntype DocumentWriterProjectionResolution =\n  | DocumentWriterProjectionResponse\n  | typeof REMOTE_DOCUMENT_DELETED\n  | null;\n\ntype FailedDocumentSyncAction =\n  | \"retry\"\n  | \"stop\"\n  | {\n      readonly kind: \"recover_update_id_conflict\";\n      readonly recoveryPendingUpdatesById: Map<string, PendingUpdateRecord>;\n    }\n  | { readonly kind: \"regenerate_queued_checkpoints\" };\n\ntype DocumentSyncAttemptSubmission =\n  | {\n      readonly kind: \"completed\";\n      readonly pullComplete: boolean;\n      readonly response: DocumentSyncResponse;\n    }\n  | FailedDocumentSyncAction\n  | \"cancelled\"\n  | \"blocked\";\n\nasync function resolveFailedDocumentSyncAction(input: {\n  attempt: number;\n  canRegenerateQueuedCheckpoints?: boolean | undefined;\n  documentId: string;\n  failure: DocumentSyncSubmitFailure;\n  maxAttempts: number;\n  onInlineRepairRefused?: (() => void) | undefined;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  onTerminalSubmitFailure?: TerminalSubmitFailureHandler | undefined;\n  pendingUpdates: readonly PendingUpdateRecord[];\n}): Promise<FailedDocumentSyncAction> {\n  const action = await classifyFailedDocumentSyncAction(input);\n  traceSubmitFailed(input.onSyncTrace, {\n    action:\n      action === \"retry\" || action === \"stop\"\n        ? action\n        : action.kind === \"recover_update_id_conflict\"\n          ? \"recover-update-ids\"\n          : \"regenerate-checkpoints\",\n    code: input.failure.code,\n    documentId: input.documentId,\n    status: input.failure.status,\n  });\n  return action;\n}\n\nasync function classifyFailedDocumentSyncAction(input: {\n  attempt: number;\n  canRegenerateQueuedCheckpoints?: boolean | undefined;\n  documentId: string;\n  failure: DocumentSyncSubmitFailure;\n  maxAttempts: number;\n  onInlineRepairRefused?: (() => void) | undefined;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onTerminalSubmitFailure?: TerminalSubmitFailureHandler | undefined;\n  pendingUpdates: readonly PendingUpdateRecord[];\n}): Promise<FailedDocumentSyncAction> {\n  if (\n    await handleUpstreamDeletedDocumentSyncFailure({\n      documentId: input.documentId,\n      failure: input.failure,\n      onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,\n    })\n  ) {\n    return \"stop\";\n  }\n\n  if (\n    canRetryDocumentSyncConflict({\n      attempt: input.attempt,\n      failure: input.failure,\n      maxAttempts: input.maxAttempts,\n    })\n  ) {\n    return \"retry\";\n  }\n\n  // The write rolled back whole. Its inline repairs would have stranded a\n  // level above a directly granted container, and a flat rekey list cannot say\n  // what each must carry: the retry commits them standalone instead.\n  if (\n    input.attempt < input.maxAttempts &&\n    input.onInlineRepairRefused &&\n    input.failure.code === DOCUMENT_SYNC_ERROR_CODES.descendantRekeysRequired\n  ) {\n    input.onInlineRepairRefused();\n    return \"retry\";\n  }\n\n  if (\n    canRecoverDocumentUpdateIdConflict({\n      attempt: input.attempt,\n      failure: input.failure,\n      maxAttempts: input.maxAttempts,\n      pendingUpdateCount: input.pendingUpdates.length,\n    })\n  ) {\n    return {\n      kind: \"recover_update_id_conflict\",\n      recoveryPendingUpdatesById: new Map(\n        input.pendingUpdates.map((update) => [update.id, update]),\n      ),\n    };\n  }\n\n  if (\n    input.attempt < input.maxAttempts &&\n    input.canRegenerateQueuedCheckpoints === true &&\n    isCheckpointCoverageConflict(input.failure)\n  ) {\n    return { kind: \"regenerate_queued_checkpoints\" };\n  }\n\n  input.failure.report();\n  await input.onTerminalSubmitFailure?.(input.failure);\n  return \"stop\";\n}\n\nasync function submitDocumentSyncAttempt(input: {\n  apiClient: DocumentSyncApi;\n  attempt: number;\n  canRegenerateQueuedCheckpoints?: boolean | undefined;\n  documentId: string;\n  expectedCommitLsnMode?: DocumentSyncCommitLsnMode | undefined;\n  maxAttempts: number;\n  onInlineRepairRefused?: (() => void) | undefined;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  onTerminalSubmitFailure?: TerminalSubmitFailureHandler | undefined;\n  pendingUpdates: readonly PendingUpdateRecord[];\n  plan: DocumentSyncPlan;\n  stillCurrent?: (() => boolean) | undefined;\n  warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;\n}): Promise<DocumentSyncAttemptSubmission> {\n  if (input.stillCurrent?.() === false) return \"cancelled\";\n  const submitted = await submitDocumentSync({\n    apiClient: input.apiClient,\n    expectedCommitLsnMode: input.expectedCommitLsnMode,\n    plan: input.plan,\n  });\n  if (input.stillCurrent?.() === false) return \"cancelled\";\n  if (!submitted) {\n    return \"stop\";\n  }\n  if (submitted.ok) {\n    return {\n      kind: \"completed\",\n      pullComplete: submitted.pullComplete,\n      response: submitted.response,\n    };\n  }\n\n  await cacheDocumentSyncPolicyRepair({\n    failure: submitted,\n    plan: input.plan,\n    stillCurrent: input.stillCurrent,\n    warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,\n  });\n  if (input.stillCurrent?.() === false) return \"cancelled\";\n\n  return resolveFailedDocumentSyncAction({\n    attempt: input.attempt,\n    canRegenerateQueuedCheckpoints: input.canRegenerateQueuedCheckpoints,\n    documentId: input.documentId,\n    failure: submitted,\n    maxAttempts: input.maxAttempts,\n    onInlineRepairRefused: input.onInlineRepairRefused,\n    onRemoteDocumentDeleted: input.onRemoteDocumentDeleted,\n    onSyncTrace: input.onSyncTrace,\n    onTerminalSubmitFailure: input.onTerminalSubmitFailure,\n    pendingUpdates: input.pendingUpdates,\n  });\n}\n\nexport async function submitDocumentSyncAttemptIfAllowed(\n  input: Parameters<typeof submitDocumentSyncAttempt>[0] & {\n    isRemoteSyncBlocked?: ((organizationId: string) => boolean) | undefined;\n    onOutgoingUpdatesMaterialized?:\n      | ((updateIds: readonly string[]) => void)\n      | undefined;\n    failureBlocksQueuedWrites?: boolean | undefined;\n  },\n): Promise<DocumentSyncAttemptSubmission> {\n  const {\n    failureBlocksQueuedWrites,\n    isRemoteSyncBlocked,\n    onOutgoingUpdatesMaterialized,\n    ...submissionInput\n  } = input;\n  const hasRemoteWrites =\n    input.plan.request.outgoingUpdates.length > 0 ||\n    (input.plan.request.containerRekeys?.length ?? 0) > 0;\n  if (hasRemoteWrites && isRemoteSyncBlocked?.(input.plan.organizationId)) {\n    return \"blocked\";\n  }\n  if (input.stillCurrent?.() === false) return \"cancelled\";\n\n  onOutgoingUpdatesMaterialized?.(\n    input.plan.request.outgoingUpdates.map(({ id }) => id),\n  );\n\n  return submitDocumentSyncAttempt({\n    ...submissionInput,\n    // A read-only pass carries no writes, so a terminal failure describes a\n    // pull, not queued local data — recording it would flag the next local\n    // edit as failed before it was ever attempted. A cursor continuation and\n    // update-id recovery both submit an empty request while durable rows still\n    // exist; a terminal 403 there IS what blocks the queued edits.\n    onTerminalSubmitFailure:\n      hasRemoteWrites || failureBlocksQueuedWrites\n        ? submissionInput.onTerminalSubmitFailure\n        : undefined,\n  });\n}\n\nasync function resolveDocumentSyncWriterProjection(input: {\n  apiClient: DocumentSyncApi;\n  documentId: string;\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  /**\n   * Invoked when the projection fetch fails terminally. Write-bearing sync\n   * passes persist this: without a writer projection their queued writes can\n   * never submit, so the failure (e.g. a 403 after access revocation) is what\n   * the write queue should surface.\n   */\n  onTerminalFailure?: TerminalSubmitFailureHandler | undefined;\n  reusableWriterProjection: DocumentWriterProjectionResponse | null;\n  stillCurrent?: (() => boolean) | undefined;\n}): Promise<DocumentWriterProjectionResolution> {\n  if (input.stillCurrent?.() === false) return null;\n  if (input.reusableWriterProjection) {\n    return input.reusableWriterProjection;\n  }\n\n  const result = await input.apiClient.getDocumentWriterProjectionResult(\n    input.documentId,\n    { reportErrors: false },\n  );\n  if (input.stillCurrent?.() === false) return null;\n  if (result.ok) {\n    return result.data;\n  }\n  if (isUpstreamDeletedDocumentSyncFailure(result)) {\n    return REMOTE_DOCUMENT_DELETED;\n  }\n  traceProjectionFailed(input.onSyncTrace, {\n    code: result.code,\n    documentId: input.documentId,\n    status: result.status,\n  });\n  result.report();\n  await input.onTerminalFailure?.(result);\n  return null;\n}\n\nexport async function retrySyncPlan(input: {\n  apiClient: DocumentSyncApi;\n  buildWithProjection: (\n    projection: DocumentWriterProjectionResponse,\n  ) => Promise<MaterializedDocumentSyncPlan>;\n  documentId: string;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  onTerminalFailure?: TerminalSubmitFailureHandler | undefined;\n  stillCurrent?: (() => boolean) | undefined;\n  writerProjection: DocumentWriterProjectionResponse;\n}): Promise<\n  | readonly [MaterializedDocumentSyncPlan, DocumentWriterProjectionResponse]\n  | null\n> {\n  try {\n    return [\n      await input.buildWithProjection(input.writerProjection),\n      input.writerProjection,\n    ];\n  } catch (error) {\n    if (\n      !input.apiClient.evictDocumentWriterProjection ||\n      !shouldRetrySyncWithFreshWriterProjection(error)\n    ) {\n      throw error;\n    }\n  }\n  if (input.stillCurrent?.() === false) return null;\n\n  // Only this document's projection was stale; evict just it so unrelated\n  // documents keep their warm cache instead of a global wipe.\n  input.apiClient.evictDocumentWriterProjection?.(input.documentId);\n  const writerProjection = await resolveDocumentSyncWriterProjection({\n    apiClient: input.apiClient,\n    documentId: input.documentId,\n    onSyncTrace: input.onSyncTrace,\n    onTerminalFailure: input.onTerminalFailure,\n    reusableWriterProjection: null,\n    stillCurrent: input.stillCurrent,\n  });\n  if (input.stillCurrent?.() === false) return null;\n  if (writerProjection === REMOTE_DOCUMENT_DELETED) {\n    await input.onRemoteDocumentDeleted?.({ documentId: input.documentId });\n    return null;\n  }\n  if (!writerProjection) {\n    return null;\n  }\n\n  return [await input.buildWithProjection(writerProjection), writerProjection];\n}\n\n/**\n * Resolves the writer projection for one sync attempt, converting the two\n * unrecoverable outcomes into an abandoned (null) result with a named reason\n * so callers that turn a null sync into their own error can surface the real\n * cause.\n */\nexport async function resolveSyncAttemptWriterProjection(input: {\n  apiClient: DocumentSyncApi;\n  documentId: string;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onSyncAbandoned?: ((reason: string) => void) | undefined;\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  onTerminalFailure?: TerminalSubmitFailureHandler | undefined;\n  reusableWriterProjection: DocumentWriterProjectionResponse | null;\n  stillCurrent?: (() => boolean) | undefined;\n}): Promise<DocumentWriterProjectionResponse | null> {\n  const writerProjection = await resolveDocumentSyncWriterProjection(input);\n  if (input.stillCurrent?.() === false) return null;\n  if (writerProjection === REMOTE_DOCUMENT_DELETED) {\n    await input.onRemoteDocumentDeleted?.({ documentId: input.documentId });\n    if (input.stillCurrent?.() !== false) {\n      input.onSyncAbandoned?.(\"the remote document was deleted\");\n    }\n    return null;\n  }\n  if (!writerProjection) {\n    input.onSyncAbandoned?.(\n      \"the document writer projection could not be fetched\",\n    );\n    return null;\n  }\n  return writerProjection;\n}\n\nexport async function refreshSyncAttemptWriterProjection(\n  input: Omit<\n    Parameters<typeof resolveSyncAttemptWriterProjection>[0],\n    \"reusableWriterProjection\"\n  > & { unavailableError?: unknown },\n): Promise<DocumentWriterProjectionResponse | null> {\n  const { onRemoteDocumentDeleted, unavailableError, ...resolutionInput } =\n    input;\n  if (input.stillCurrent?.() === false) return null;\n  if (input.apiClient.evictDocumentWriterProjection) {\n    input.apiClient.evictDocumentWriterProjection(input.documentId);\n  } else {\n    input.apiClient.clearWriterProjectionCaches?.();\n  }\n  let remoteDocumentDeleted = false;\n  const writerProjection = await resolveSyncAttemptWriterProjection({\n    ...resolutionInput,\n    onRemoteDocumentDeleted: async (deleted) => {\n      remoteDocumentDeleted = true;\n      await onRemoteDocumentDeleted?.(deleted);\n    },\n    reusableWriterProjection: null,\n  });\n  if (\n    !writerProjection &&\n    unavailableError !== undefined &&\n    !remoteDocumentDeleted &&\n    input.stillCurrent?.() !== false\n  ) {\n    throw unavailableError;\n  }\n  return writerProjection;\n}\n\nexport async function retrySyncPlanOrAbandon(input: {\n  apiClient: DocumentSyncApi;\n  buildWithProjection: (\n    projection: DocumentWriterProjectionResponse,\n  ) => Promise<MaterializedDocumentSyncPlan>;\n  documentId: string;\n  onRemoteDocumentDeleted?: RemoteDocumentDeletionHandler | undefined;\n  onSyncAbandoned?: ((reason: string) => void) | undefined;\n  onSyncTrace?: DocumentSyncTraceEmitter | undefined;\n  onTerminalFailure?: TerminalSubmitFailureHandler | undefined;\n  stillCurrent?: (() => boolean) | undefined;\n  writerProjection: DocumentWriterProjectionResponse;\n}): Promise<\n  | readonly [MaterializedDocumentSyncPlan, DocumentWriterProjectionResponse]\n  | null\n> {\n  const planned = await retrySyncPlan(input);\n  if (!planned && input.stillCurrent?.() !== false) {\n    input.onSyncAbandoned?.(\n      \"a sync plan could not be built against the current projection\",\n    );\n  }\n  return planned;\n}\n"]}

package/workflows/documents/syncLane.d.ts

@@ -0,0 +1,19 @@
+import type { DomainScope } from "../../data/domainScope.js";
+import { type SyncLane } from "../../data/sync/syncCoordinator.js";
+export { sequenceUnchanged } from "../../data/sync/sequence.js";
+export type DocumentSyncLane = SyncLane;
+export declare function registerDocumentSyncLane(input: {
+    readonly domainScope: DomainScope;
+    readonly localId: string;
+    /** Host diagnostics sink; bare runtimes do not structure errors. */
+    readonly logError?: ((message: string, error: unknown) => void) | undefined;
+    readonly run: () => Promise<void>;
+}): DocumentSyncLane;
+export declare function requestDocumentSyncLaneAndWait(input: {
+    readonly didCompleteRequest: () => boolean;
+    readonly domainScope: DomainScope;
+    readonly localId: string;
+    readonly onInvalidated?: (() => void) | undefined;
+    readonly request: () => void;
+    readonly signal?: AbortSignal | undefined;
+}): Promise<boolean>;

package/workflows/documents/syncLane.js

@@ -0,0 +1,93 @@
+import { getOrCreateDomainSyncCoordinator, isDatabaseUnavailableError, } from "../../data/sync/syncCoordinator.js";
+// Facade re-export: document stores must reach this shared sync helper
+// through this workflow boundary, not by importing data/sync directly.
+export { sequenceUnchanged } from "../../data/sync/sequence.js";
+function getDocumentSyncLaneKey(localId) {
+    return `documents:${localId}`;
+}
+export function registerDocumentSyncLane(input) {
+    return getOrCreateDomainSyncCoordinator(input.domainScope).registerLane(getDocumentSyncLaneKey(input.localId), {
+        label: `Document ${input.localId}`,
+        onUnexpectedError: (error) => {
+            console.error(`Failed to sync document ${input.localId}:`, error);
+        },
+        phase: "document",
+        // Fixed literal: the local id stays in the console line above, never in
+        // a report. The mapped stack identifies which lane body threw. Returning
+        // the host's result hands a rejection to the lane reporter's wrapper;
+        // discarding it would surface as an unhandled rejection instead.
+        reportUnexpectedError: (error) => input.logError?.("Documents: sync lane failed", error),
+        run: input.run,
+        shouldIgnoreError: isDatabaseUnavailableError,
+    });
+}
+export function requestDocumentSyncLaneAndWait(input) {
+    if (input.signal?.aborted) {
+        input.onInvalidated?.();
+        return Promise.resolve(false);
+    }
+    const coordinator = getOrCreateDomainSyncCoordinator(input.domainScope);
+    const laneKey = getDocumentSyncLaneKey(input.localId);
+    const initialLane = coordinator
+        .getSnapshot()
+        .lanes.find((lane) => lane.key === laneKey);
+    if (!initialLane) {
+        return Promise.resolve(false);
+    }
+    if (initialLane.runAbandoned) {
+        return Promise.resolve(false);
+    }
+    const baselineRunCount = initialLane.runCount;
+    return new Promise((resolve) => {
+        let settled = false;
+        let unsubscribe = () => undefined;
+        const finish = (completed) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            unsubscribe();
+            input.signal?.removeEventListener("abort", handleAbort);
+            resolve(completed);
+        };
+        const handleAbort = () => {
+            if (settled) {
+                return;
+            }
+            input.onInvalidated?.();
+            finish(false);
+        };
+        const inspect = () => {
+            if (coordinator.isDisposed()) {
+                handleAbort();
+                return;
+            }
+            const lane = coordinator
+                .getSnapshot()
+                .lanes.find((candidate) => candidate.key === laneKey);
+            if (!lane) {
+                handleAbort();
+                return;
+            }
+            if (lane.runAbandoned) {
+                handleAbort();
+                return;
+            }
+            if (lane.runCount <= baselineRunCount || lane.running || lane.requested) {
+                return;
+            }
+            if (lane.lastAction === "completed" || lane.lastAction === "failed") {
+                finish(lane.lastAction === "completed" && input.didCompleteRequest());
+            }
+        };
+        unsubscribe = coordinator.subscribe(inspect);
+        input.signal?.addEventListener("abort", handleAbort, { once: true });
+        if (input.signal?.aborted) {
+            handleAbort();
+            return;
+        }
+        input.request();
+        inspect();
+    });
+}
+//# sourceMappingURL=syncLane.js.map

package/workflows/documents/syncLane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncLane.js","sourceRoot":"","sources":["syncLane.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gCAAgC,EAChC,0BAA0B,GAE3B,MAAM,iCAAiC,CAAC;AAEzC,uEAAuE;AACvE,uEAAuE;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAI7D,SAAS,sBAAsB,CAAC,OAAe;IAC7C,OAAO,aAAa,OAAO,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,KAMxC;IACC,OAAO,gCAAgC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,YAAY,CACrE,sBAAsB,CAAC,KAAK,CAAC,OAAO,CAAC,EACrC;QACE,KAAK,EAAE,YAAY,KAAK,CAAC,OAAO,EAAE;QAClC,iBAAiB,EAAE,CAAC,KAAK,EAAE,EAAE;YAC3B,OAAO,CAAC,KAAK,CAAC,2BAA2B,KAAK,CAAC,OAAO,GAAG,EAAE,KAAK,CAAC,CAAC;QACpE,CAAC;QACD,KAAK,EAAE,UAAU;QACjB,wEAAwE;QACxE,yEAAyE;QACzE,sEAAsE;QACtE,iEAAiE;QACjE,qBAAqB,EAAE,CAAC,KAAK,EAAE,EAAE,CAC/B,KAAK,CAAC,QAAQ,EAAE,CAAC,6BAA6B,EAAE,KAAK,CAAC;QACxD,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,iBAAiB,EAAE,0BAA0B;KAC9C,CACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,8BAA8B,CAAC,KAO9C;IACC,IAAI,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;QAC1B,KAAK,CAAC,aAAa,EAAE,EAAE,CAAC;QACxB,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IACD,MAAM,WAAW,GAAG,gCAAgC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IACxE,MAAM,OAAO,GAAG,sBAAsB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACtD,MAAM,WAAW,GAAG,WAAW;SAC5B,WAAW,EAAE;SACb,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;IAC9C,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IACD,IAAI,WAAW,CAAC,YAAY,EAAE,CAAC;QAC7B,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IACD,MAAM,gBAAgB,GAAG,WAAW,CAAC,QAAQ,CAAC;IAC9C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IAAI,WAAW,GAAe,GAAG,EAAE,CAAC,SAAS,CAAC;QAC9C,MAAM,MAAM,GAAG,CAAC,SAAkB,EAAE,EAAE;YACpC,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO;YACT,CAAC;YACD,OAAO,GAAG,IAAI,CAAC;YACf,WAAW,EAAE,CAAC;YACd,KAAK,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YACxD,OAAO,CAAC,SAAS,CAAC,CAAC;QACrB,CAAC,CAAC;QACF,MAAM,WAAW,GAAG,GAAG,EAAE;YACvB,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO;YACT,CAAC;YACD,KAAK,CAAC,aAAa,EAAE,EAAE,CAAC;YACxB,MAAM,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC,CAAC;QACF,MAAM,OAAO,GAAG,GAAG,EAAE;YACnB,IAAI,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC;gBAC7B,WAAW,EAAE,CAAC;gBACd,OAAO;YACT,CAAC;YACD,MAAM,IAAI,GAAG,WAAW;iBACrB,WAAW,EAAE;iBACb,KAAK,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;YACxD,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,WAAW,EAAE,CAAC;gBACd,OAAO;YACT,CAAC;YACD,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,WAAW,EAAE,CAAC;gBACd,OAAO;YACT,CAAC;YACD,IAAI,IAAI,CAAC,QAAQ,IAAI,gBAAgB,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;gBACxE,OAAO;YACT,CAAC;YACD,IAAI,IAAI,CAAC,UAAU,KAAK,WAAW,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;gBACpE,MAAM,CAAC,IAAI,CAAC,UAAU,KAAK,WAAW,IAAI,KAAK,CAAC,kBAAkB,EAAE,CAAC,CAAC;YACxE,CAAC;QACH,CAAC,CAAC;QACF,WAAW,GAAG,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC7C,KAAK,CAAC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACrE,IAAI,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;YAC1B,WAAW,EAAE,CAAC;YACd,OAAO;QACT,CAAC;QACD,KAAK,CAAC,OAAO,EAAE,CAAC;QAChB,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { DomainScope } from \"../../data/domainScope\";\nimport {\n  getOrCreateDomainSyncCoordinator,\n  isDatabaseUnavailableError,\n  type SyncLane,\n} from \"../../data/sync/syncCoordinator\";\n\n// Facade re-export: document stores must reach this shared sync helper\n// through this workflow boundary, not by importing data/sync directly.\nexport { sequenceUnchanged } from \"../../data/sync/sequence\";\n\nexport type DocumentSyncLane = SyncLane;\n\nfunction getDocumentSyncLaneKey(localId: string): string {\n  return `documents:${localId}`;\n}\n\nexport function registerDocumentSyncLane(input: {\n  readonly domainScope: DomainScope;\n  readonly localId: string;\n  /** Host diagnostics sink; bare runtimes do not structure errors. */\n  readonly logError?: ((message: string, error: unknown) => void) | undefined;\n  readonly run: () => Promise<void>;\n}): DocumentSyncLane {\n  return getOrCreateDomainSyncCoordinator(input.domainScope).registerLane(\n    getDocumentSyncLaneKey(input.localId),\n    {\n      label: `Document ${input.localId}`,\n      onUnexpectedError: (error) => {\n        console.error(`Failed to sync document ${input.localId}:`, error);\n      },\n      phase: \"document\",\n      // Fixed literal: the local id stays in the console line above, never in\n      // a report. The mapped stack identifies which lane body threw. Returning\n      // the host's result hands a rejection to the lane reporter's wrapper;\n      // discarding it would surface as an unhandled rejection instead.\n      reportUnexpectedError: (error) =>\n        input.logError?.(\"Documents: sync lane failed\", error),\n      run: input.run,\n      shouldIgnoreError: isDatabaseUnavailableError,\n    },\n  );\n}\n\nexport function requestDocumentSyncLaneAndWait(input: {\n  readonly didCompleteRequest: () => boolean;\n  readonly domainScope: DomainScope;\n  readonly localId: string;\n  readonly onInvalidated?: (() => void) | undefined;\n  readonly request: () => void;\n  readonly signal?: AbortSignal | undefined;\n}): Promise<boolean> {\n  if (input.signal?.aborted) {\n    input.onInvalidated?.();\n    return Promise.resolve(false);\n  }\n  const coordinator = getOrCreateDomainSyncCoordinator(input.domainScope);\n  const laneKey = getDocumentSyncLaneKey(input.localId);\n  const initialLane = coordinator\n    .getSnapshot()\n    .lanes.find((lane) => lane.key === laneKey);\n  if (!initialLane) {\n    return Promise.resolve(false);\n  }\n  if (initialLane.runAbandoned) {\n    return Promise.resolve(false);\n  }\n  const baselineRunCount = initialLane.runCount;\n  return new Promise((resolve) => {\n    let settled = false;\n    let unsubscribe: () => void = () => undefined;\n    const finish = (completed: boolean) => {\n      if (settled) {\n        return;\n      }\n      settled = true;\n      unsubscribe();\n      input.signal?.removeEventListener(\"abort\", handleAbort);\n      resolve(completed);\n    };\n    const handleAbort = () => {\n      if (settled) {\n        return;\n      }\n      input.onInvalidated?.();\n      finish(false);\n    };\n    const inspect = () => {\n      if (coordinator.isDisposed()) {\n        handleAbort();\n        return;\n      }\n      const lane = coordinator\n        .getSnapshot()\n        .lanes.find((candidate) => candidate.key === laneKey);\n      if (!lane) {\n        handleAbort();\n        return;\n      }\n      if (lane.runAbandoned) {\n        handleAbort();\n        return;\n      }\n      if (lane.runCount <= baselineRunCount || lane.running || lane.requested) {\n        return;\n      }\n      if (lane.lastAction === \"completed\" || lane.lastAction === \"failed\") {\n        finish(lane.lastAction === \"completed\" && input.didCompleteRequest());\n      }\n    };\n    unsubscribe = coordinator.subscribe(inspect);\n    input.signal?.addEventListener(\"abort\", handleAbort, { once: true });\n    if (input.signal?.aborted) {\n      handleAbort();\n      return;\n    }\n    input.request();\n    inspect();\n  });\n}\n"]}

package/workflows/documents/syncPlanIdentity.js

@@ -0,0 +1,203 @@
+import { CONTENT_RECORD_ENCRYPTION_SUITE, computeContentRecordNonceDomainHash, computeDocumentContentKeyTargetHash, signWriteHeader, } from "../../internal/crypto/index.js";
+import { assertDocumentManifestBundleConsistent, normalizeDocumentKekTargetResponse, serializeCanonical, sortDocumentTargets, targetEnvelopeReference, } from "../../data/documents/shared/readers.js";
+import { readCanonicalRecord } from "../../data/keyingCanonicalJson.js";
+function contentKeyBundleForSyncRequest(input) {
+    const { documentId: _omit, ...bundle } = input;
+    return bundle;
+}
+async function resolveDocumentSyncIdentity(input) {
+    const manifestIdentity = await assertDocumentManifestBundleConsistent({
+        bundle: input.documentManifest,
+        label: "Document sync manifest",
+    });
+    const documentId = input.documentId ?? input.contentKeyBundle.documentId;
+    if (documentId.length === 0) {
+        throw new Error("Document sync document id is empty");
+    }
+    if (input.contentKeyBundle.documentId !== documentId ||
+        input.documentKekTargets.documentId !== documentId ||
+        manifestIdentity.documentId !== documentId) {
+        throw new Error("Document sync state document id mismatch");
+    }
+    if (manifestIdentity.organizationId !== input.author.organizationId) {
+        throw new Error("Document sync author organization mismatch");
+    }
+    if (input.documentManifest.manifestHash !==
+        input.contentKeyBundle.linkSetManifestHash ||
+        input.documentKekTargets.linkSetManifestHash !==
+            input.contentKeyBundle.linkSetManifestHash) {
+        throw new Error("Document sync link manifest mismatch");
+    }
+    if (input.documentKekTargets.documentKeyTargetHash !==
+        input.contentKeyBundle.targetHash) {
+        throw new Error("Document sync target hash mismatch");
+    }
+    const kekTargets = normalizeDocumentKekTargetResponse(input.documentKekTargets);
+    const contentKeyTargets = sortDocumentTargets(input.contentKeyBundle.targets.map(targetEnvelopeReference));
+    if (serializeCanonical(kekTargets, "KEK targets") !==
+        serializeCanonical(contentKeyTargets, "content-key targets")) {
+        throw new Error("Document sync content-key targets mismatch");
+    }
+    const targetHash = await computeDocumentContentKeyTargetHash(kekTargets);
+    if (targetHash !== input.contentKeyBundle.targetHash) {
+        throw new Error("Document sync target hash is not canonical");
+    }
+    return {
+        documentId,
+        expectedLinkSetManifestHash: input.contentKeyBundle.linkSetManifestHash,
+        expectedTargetHash: input.contentKeyBundle.targetHash,
+        organizationId: manifestIdentity.organizationId,
+    };
+}
+function normalizeAuthorizingContainerPathRefs(refs) {
+    if (!refs || refs.length === 0) {
+        throw new Error("Document sync write authorization path refs are missing");
+    }
+    return refs.map((path, pathIndex) => {
+        if (path.length === 0) {
+            throw new Error(`Document sync write authorization path[${pathIndex}] is empty`);
+        }
+        return [...path];
+    });
+}
+export async function signDocumentOutgoingUpdate(input) {
+    const contentRecordId = input.update.contentRecordId ?? input.update.id;
+    const nonceDomain = {
+        version: 1,
+        organizationId: input.organizationId,
+        objectKind: "document",
+        objectId: input.documentId,
+        contentKeyEpoch: input.contentKeyEpoch,
+        encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,
+        contentRecordId,
+    };
+    const unsignedHeader = {
+        ...nonceDomain,
+        dependencyManifestHashes: [
+            ...new Set(input.authorizingContainerPathRefs.flatMap((path) => path.map((ref) => ref.manifestHash))),
+        ].sort(),
+        accessManifestHash: input.expectedLinkSetManifestHash,
+        targetHash: input.expectedTargetHash,
+        nonceDomainHash: await computeContentRecordNonceDomainHash(nonceDomain),
+        metadataHash: input.update.metadataHash,
+        ciphertextHash: input.update.ciphertextHash,
+        writerUserId: input.author.signerUserId,
+        writerDeviceId: input.author.signerDeviceId,
+        writerKeyFingerprint: input.author.signerKeyFingerprint,
+        signedAt: input.update.signedAt ?? input.signedAt,
+    };
+    const writeHeader = await signWriteHeader(unsignedHeader, input.author.signerPrivateKey);
+    return {
+        ...(input.update.checkpointKind === undefined
+            ? {}
+            : { checkpointKind: input.update.checkpointKind }),
+        ...(input.update.checkpointPayloadKind === undefined
+            ? {}
+            : { checkpointPayloadKind: input.update.checkpointPayloadKind }),
+        id: input.update.id,
+        encryptedData: input.update.encryptedData,
+        partialStartVersionVector: input.update.partialStartVersionVector,
+        partialEndVersionVector: input.update.partialEndVersionVector,
+        plaintextHash: input.update.plaintextHash,
+        ...(input.update.sourceVersionVector === undefined
+            ? {}
+            : { sourceVersionVector: input.update.sourceVersionVector }),
+        writeHeader: readCanonicalRecord(writeHeader, "Document outgoing write header"),
+    };
+}
+function assertUniqueDocumentOutgoingUpdates(updates) {
+    const updateIds = new Set();
+    const contentRecordIds = new Set();
+    for (const update of updates) {
+        if (updateIds.has(update.id)) {
+            throw new Error("Document sync update id is duplicated");
+        }
+        updateIds.add(update.id);
+        const contentRecordId = (update.contentRecordId ?? update.id).toLowerCase();
+        if (contentRecordIds.has(contentRecordId)) {
+            throw new Error("Document sync content record id is duplicated");
+        }
+        contentRecordIds.add(contentRecordId);
+    }
+}
+function assertDocumentSyncRequestMode(input, hasContainerRekeys, hasOutgoingUpdates) {
+    if (input.historyMode === "raw" && input.localVersionVector !== null) {
+        throw new Error("Document raw-history sync must start from a null version vector");
+    }
+    const hasWrites = hasOutgoingUpdates || hasContainerRekeys;
+    if (input.historyMode === "raw" && hasWrites) {
+        throw new Error("Document raw-history sync must be read-only");
+    }
+    if (input.pullCursor !== undefined && hasWrites) {
+        throw new Error("Document sync continuation must be read-only");
+    }
+    if (hasContainerRekeys && !hasOutgoingUpdates) {
+        throw new Error("Document sync container rekeys require an outgoing update");
+    }
+    if (hasContainerRekeys !== (input.inlineRekeyCommitId !== undefined)) {
+        throw new Error("Document sync inline rekey commit id must accompany container rekeys");
+    }
+}
+export async function buildDocumentSyncPlan(input) {
+    const { documentId, expectedLinkSetManifestHash, expectedTargetHash, organizationId, } = await resolveDocumentSyncIdentity(input);
+    const containerRekeys = [...(input.containerRekeys ?? [])];
+    const outgoingUpdateInputs = [...(input.outgoingUpdates ?? [])];
+    assertDocumentSyncRequestMode(input, containerRekeys.length > 0, outgoingUpdateInputs.length > 0);
+    const signedAt = input.signedAt ?? new Date().toISOString();
+    assertUniqueDocumentOutgoingUpdates(outgoingUpdateInputs);
+    const outgoingUpdates = await Promise.all(outgoingUpdateInputs.map((update) => signDocumentOutgoingUpdate({
+        authorizingContainerPathRefs: normalizeAuthorizingContainerPathRefs(input.authorizingContainerPathRefs),
+        author: input.author,
+        contentKeyEpoch: input.contentKeyBundle.contentKeyEpoch,
+        documentId,
+        expectedLinkSetManifestHash,
+        expectedTargetHash,
+        organizationId,
+        signedAt,
+        update,
+    })));
+    // Writes always carry the verified current content-key bundle so the server
+    // can validate and materialize the current wrapping material in the same
+    // request. Read-only syncs omit it because they do not update server state.
+    const shouldIncludeContentKeyBundle = outgoingUpdates.length > 0;
+    const request = {
+        ...(shouldIncludeContentKeyBundle
+            ? {
+                contentKeyBundle: contentKeyBundleForSyncRequest(input.contentKeyBundle),
+            }
+            : {}),
+        ...(containerRekeys.length === 0 ? {} : { containerRekeys }),
+        contentKeyEpoch: input.contentKeyBundle.contentKeyEpoch,
+        ...(outgoingUpdates.length === 0
+            ? {}
+            : {
+                authorizingContainerPathRefs: normalizeAuthorizingContainerPathRefs(input.authorizingContainerPathRefs),
+            }),
+        expectedLinkSetManifestHash,
+        expectedTargetHash,
+        ...(input.historyMode === undefined
+            ? {}
+            : { historyMode: input.historyMode }),
+        ...(input.inlineRekeyCommitId === undefined
+            ? {}
+            : { inlineRekeyCommitId: input.inlineRekeyCommitId }),
+        localVersionVector: input.localVersionVector,
+        ...(input.minLsn === undefined ? {} : { minLsn: input.minLsn }),
+        outgoingUpdates,
+        ...(input.pullCursor === undefined ? {} : { pullCursor: input.pullCursor }),
+        supportsPullPagination: true,
+    };
+    return {
+        contentKeyEpoch: input.contentKeyBundle.contentKeyEpoch,
+        documentId,
+        documentKekTargets: input.documentKekTargets,
+        documentManifest: input.documentManifest,
+        expectedLinkSetManifestHash,
+        expectedTargetHash,
+        minLsn: input.minLsn,
+        organizationId,
+        request,
+        sourceContentKeyBundle: input.contentKeyBundle,
+    };
+}
+//# sourceMappingURL=syncPlanIdentity.js.map