@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/workflows/documents/sync.js

@@ -0,0 +1,285 @@
+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.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,
+            }),
+        });
+    }
+    catch (error) {
+        if (isProjectionVerificationCancelledError(error))
+            return null;
+        if (input.stillCurrent?.() !== false &&
+            isDocumentSyncUpdateIsolationError(error)) {
+            await input.onIncomingUpdateIsolationFailure?.(error);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=sync.js.map

package/workflows/documents/sync.js.map

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

package/workflows/documents/syncAbandon.js

@@ -0,0 +1,51 @@
+import { DocumentAncestorRepairAbandonedError } from "./syncRepairAbandon.js";
+import { traceAncestorRepairAbandoned } from "./syncTrace.js";
+export function abandonBlockedSync(input) {
+    input.onSyncTrace?.(`document sync blocked document=${input.documentId}`);
+    input.onSyncAbandoned?.("blocked");
+    return null;
+}
+export function abandonAncestorRepair(input, error) {
+    // Trace as well as abandon: the store's onSyncAbandoned only parks the
+    // document, and this path may already have issued server-side rekeys, so
+    // abandoning untraced would leave a retrying loop with no way to see it.
+    traceAncestorRepairAbandoned(input.onSyncTrace, {
+        documentId: input.documentId,
+        reason: error.reason,
+    });
+    input.onSyncAbandoned?.(error.reason);
+    return null;
+}
+/**
+ * The stale ancestor is one this writer can neither re-key nor be given the
+ * key for, and one refetch has already confirmed nobody repaired it yet. The
+ * writes stay queued; the durable row tells the write queue why, and the
+ * dependent-path hint that follows the repair re-arms the pass.
+ */
+export async function abandonInaccessibleAncestorRepair(input, error) {
+    await input.onTerminalSubmitFailure?.({
+        code: "document_ancestor_repair_inaccessible",
+        message: error.message,
+        ok: false,
+        report: () => undefined,
+        status: null,
+    });
+    return abandonAncestorRepair(input, new DocumentAncestorRepairAbandonedError("inaccessible"));
+}
+export function abandonAfterRetryableConflicts(input) {
+    input.onSyncAbandoned?.("every sync attempt hit a retryable conflict");
+    return null;
+}
+export async function abandonOversizedSyncPlan(input, error) {
+    const failure = {
+        code: "document_sync_request_too_large",
+        message: error.message,
+        ok: false,
+        report: () => undefined,
+        status: null,
+    };
+    await input.onTerminalSubmitFailure?.(failure);
+    input.onSyncAbandoned?.("a queued update cannot fit within the document sync request limit");
+    return null;
+}
+//# sourceMappingURL=syncAbandon.js.map

package/workflows/documents/syncAbandon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncAbandon.js","sourceRoot":"","sources":["syncAbandon.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oCAAoC,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAQ3D,MAAM,UAAU,kBAAkB,CAAC,KAAyB;IAC1D,KAAK,CAAC,WAAW,EAAE,CAAC,kCAAkC,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC;IAC1E,KAAK,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,CAAC;IACnC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,KAAyB,EACzB,KAA2C;IAE3C,uEAAuE;IACvE,yEAAyE;IACzE,yEAAyE;IACzE,4BAA4B,CAAC,KAAK,CAAC,WAAW,EAAE;QAC9C,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,MAAM,EAAE,KAAK,CAAC,MAAM;KACrB,CAAC,CAAC;IACH,KAAK,CAAC,eAAe,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACtC,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,iCAAiC,CACrD,KAAyB,EACzB,KAA0C;IAE1C,MAAM,KAAK,CAAC,uBAAuB,EAAE,CAAC;QACpC,IAAI,EAAE,uCAAuC;QAC7C,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,EAAE,EAAE,KAAK;QACT,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS;QACvB,MAAM,EAAE,IAAI;KACb,CAAC,CAAC;IACH,OAAO,qBAAqB,CAC1B,KAAK,EACL,IAAI,oCAAoC,CAAC,cAAc,CAAC,CACzD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,8BAA8B,CAC5C,KAAyB;IAEzB,KAAK,CAAC,eAAe,EAAE,CAAC,6CAA6C,CAAC,CAAC;IACvE,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,KAAyB,EACzB,KAAY;IAEZ,MAAM,OAAO,GAA8B;QACzC,IAAI,EAAE,iCAAiC;QACvC,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,EAAE,EAAE,KAAK;QACT,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS;QACvB,MAAM,EAAE,IAAI;KACb,CAAC;IACF,MAAM,KAAK,CAAC,uBAAuB,EAAE,CAAC,OAAO,CAAC,CAAC;IAC/C,KAAK,CAAC,eAAe,EAAE,CACrB,mEAAmE,CACpE,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["import type { ContainerKekRepairInaccessibleError } from \"../../data/documents/shared/containerKekCurrency\";\nimport type { DocumentSyncSubmitFailure } from \"../../data/documents/shared/types\";\nimport type { SyncRemoteDocumentInput } from \"./readOnlySync\";\nimport { DocumentAncestorRepairAbandonedError } from \"./syncRepairAbandon\";\nimport { traceAncestorRepairAbandoned } from \"./syncTrace\";\n\n/** The ways a sync pass gives up without failing: writes stay queued. */\ntype AbandonedSyncInput = Pick<\n  SyncRemoteDocumentInput,\n  \"documentId\" | \"onSyncAbandoned\" | \"onSyncTrace\" | \"onTerminalSubmitFailure\"\n>;\n\nexport function abandonBlockedSync(input: AbandonedSyncInput): null {\n  input.onSyncTrace?.(`document sync blocked document=${input.documentId}`);\n  input.onSyncAbandoned?.(\"blocked\");\n  return null;\n}\n\nexport function abandonAncestorRepair(\n  input: AbandonedSyncInput,\n  error: DocumentAncestorRepairAbandonedError,\n): null {\n  // Trace as well as abandon: the store's onSyncAbandoned only parks the\n  // document, and this path may already have issued server-side rekeys, so\n  // abandoning untraced would leave a retrying loop with no way to see it.\n  traceAncestorRepairAbandoned(input.onSyncTrace, {\n    documentId: input.documentId,\n    reason: error.reason,\n  });\n  input.onSyncAbandoned?.(error.reason);\n  return null;\n}\n\n/**\n * The stale ancestor is one this writer can neither re-key nor be given the\n * key for, and one refetch has already confirmed nobody repaired it yet. The\n * writes stay queued; the durable row tells the write queue why, and the\n * dependent-path hint that follows the repair re-arms the pass.\n */\nexport async function abandonInaccessibleAncestorRepair(\n  input: AbandonedSyncInput,\n  error: ContainerKekRepairInaccessibleError,\n): Promise<null> {\n  await input.onTerminalSubmitFailure?.({\n    code: \"document_ancestor_repair_inaccessible\",\n    message: error.message,\n    ok: false,\n    report: () => undefined,\n    status: null,\n  });\n  return abandonAncestorRepair(\n    input,\n    new DocumentAncestorRepairAbandonedError(\"inaccessible\"),\n  );\n}\n\nexport function abandonAfterRetryableConflicts(\n  input: AbandonedSyncInput,\n): null {\n  input.onSyncAbandoned?.(\"every sync attempt hit a retryable conflict\");\n  return null;\n}\n\nexport async function abandonOversizedSyncPlan(\n  input: AbandonedSyncInput,\n  error: Error,\n): Promise<null> {\n  const failure: DocumentSyncSubmitFailure = {\n    code: \"document_sync_request_too_large\",\n    message: error.message,\n    ok: false,\n    report: () => undefined,\n    status: null,\n  };\n  await input.onTerminalSubmitFailure?.(failure);\n  input.onSyncAbandoned?.(\n    \"a queued update cannot fit within the document sync request limit\",\n  );\n  return null;\n}\n"]}

package/workflows/documents/syncAttemptPlanning.js

@@ -0,0 +1,79 @@
+import { ContainerKekRepairInaccessibleError } from "../../data/documents/shared/containerKekCurrency.js";
+import { assertDocumentManifestBundleConsistent } from "../../data/documents/shared/readers.js";
+import { resolvePullContinuationMinLsn, } from "../../data/documents/shared/syncPagination.js";
+import { isDocumentSyncRequestLimitError } from "../../data/sync/documentSyncOutgoingBatch.js";
+import { abandonAncestorRepair, abandonBlockedSync, abandonInaccessibleAncestorRepair, abandonOversizedSyncPlan, } from "./syncAbandon.js";
+import { prepareSyncAttemptContainerRekeys } from "./syncContainerRekeyPreparation.js";
+import { buildRemoteDocumentSyncPlan } from "./syncContainerRekeys.js";
+import { retrySyncPlanOrAbandon } from "./syncFailures.js";
+import { DocumentAncestorRepairAbandonedError, DocumentSyncPreparationRequiredError, } from "./syncRepairAbandon.js";
+/**
+ * A write-bearing pass records through the submit handler (its queued writes
+ * are what the failure blocks). A read-only pass records through the
+ * revalidation handler so the refusal still leaves a durable trail instead
+ * of silently never revalidating (edge-case row 13). A cursor continuation is
+ * wire-level read-only, but its failure still blocks the queued writes it
+ * deliberately deferred. Update-id recovery likewise empties the in-flight
+ * batch while durable rows remain. Both keep the submit classification and
+ * its 403 handling.
+ */
+export function projectionFailureHandler(input, failureBlocksQueuedWrites) {
+    return failureBlocksQueuedWrites
+        ? input.onTerminalSubmitFailure
+        : input.onReadOnlyProjectionFailure;
+}
+export async function planDocumentSyncAttempt(input) {
+    try {
+        const pendingUpdates = input.pullContinuation === undefined ? input.pendingUpdates : [];
+        if (pendingUpdates.length &&
+            input.sync.isRemoteSyncBlocked?.((await assertDocumentManifestBundleConsistent({
+                bundle: input.writerProjection.documentManifest,
+                label: "Document sync manifest",
+            })).organizationId)) {
+            return abandonBlockedSync(input.sync);
+        }
+        // Durable repair happens once at this explicit attempt boundary. The
+        // retryable builder below may only sign inline plans against its projection.
+        const prepared = pendingUpdates.length &&
+            !input.sync.buildContainerRekeys &&
+            input.sync.buildRotationSnapshot
+            ? await prepareSyncAttemptContainerRekeys(input.sync, input.writerProjection)
+            : { projection: input.writerProjection, plans: undefined };
+        if (!prepared)
+            return null;
+        return await retrySyncPlanOrAbandon({
+            apiClient: input.sync.apiClient,
+            buildWithProjection: (projection) => buildRemoteDocumentSyncPlan({
+                pendingUpdates,
+                preparedRekeys: projection === prepared.projection ? prepared.plans : undefined,
+                minLsn: resolvePullContinuationMinLsn(input.pullContinuation, input.sync.minLsn),
+                pullCursor: input.pullContinuation?.cursor,
+                projection,
+                regenerateQueuedCheckpoints: input.regenerateQueuedCheckpoints,
+                sync: input.sync,
+            }),
+            documentId: input.sync.documentId,
+            onRemoteDocumentDeleted: input.sync.onRemoteDocumentDeleted,
+            onSyncAbandoned: input.sync.onSyncAbandoned,
+            onSyncTrace: input.sync.onSyncTrace,
+            onTerminalFailure: projectionFailureHandler(input.sync, input.failureBlocksQueuedWrites),
+            stillCurrent: input.sync.stillCurrent,
+            writerProjection: prepared.projection,
+        });
+    }
+    catch (error) {
+        if (error instanceof DocumentSyncPreparationRequiredError)
+            return "retry";
+        if (error instanceof DocumentAncestorRepairAbandonedError) {
+            return abandonAncestorRepair(input.sync, error);
+        }
+        if (error instanceof ContainerKekRepairInaccessibleError) {
+            return abandonInaccessibleAncestorRepair(input.sync, error);
+        }
+        if (!isDocumentSyncRequestLimitError(error)) {
+            throw error;
+        }
+        return abandonOversizedSyncPlan(input.sync, error);
+    }
+}
+//# sourceMappingURL=syncAttemptPlanning.js.map

package/workflows/documents/syncAttemptPlanning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncAttemptPlanning.js","sourceRoot":"","sources":["syncAttemptPlanning.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { ContainerKekRepairInaccessibleError } from \"../../data/documents/shared/containerKekCurrency\";\nimport { assertDocumentManifestBundleConsistent } from \"../../data/documents/shared/readers\";\nimport {\n  type DocumentSyncPullContinuation,\n  resolvePullContinuationMinLsn,\n} from \"../../data/documents/shared/syncPagination\";\nimport type { PendingUpdateRecord } from \"../../data/sqlite/documentPersistence\";\nimport { isDocumentSyncRequestLimitError } from \"../../data/sync/documentSyncOutgoingBatch\";\nimport type { SyncRemoteDocumentInput } from \"./readOnlySync\";\nimport {\n  abandonAncestorRepair,\n  abandonBlockedSync,\n  abandonInaccessibleAncestorRepair,\n  abandonOversizedSyncPlan,\n} from \"./syncAbandon\";\nimport { prepareSyncAttemptContainerRekeys } from \"./syncContainerRekeyPreparation\";\nimport { buildRemoteDocumentSyncPlan } from \"./syncContainerRekeys\";\nimport type { TerminalSubmitFailureHandler } from \"./syncFailureClassification\";\nimport { retrySyncPlanOrAbandon } from \"./syncFailures\";\nimport {\n  DocumentAncestorRepairAbandonedError,\n  DocumentSyncPreparationRequiredError,\n} from \"./syncRepairAbandon\";\n\n/**\n * A write-bearing pass records through the submit handler (its queued writes\n * are what the failure blocks). A read-only pass records through the\n * revalidation handler so the refusal still leaves a durable trail instead\n * of silently never revalidating (edge-case row 13). A cursor continuation is\n * wire-level read-only, but its failure still blocks the queued writes it\n * deliberately deferred. Update-id recovery likewise empties the in-flight\n * batch while durable rows remain. Both keep the submit classification and\n * its 403 handling.\n */\nexport function projectionFailureHandler(\n  input: SyncRemoteDocumentInput,\n  failureBlocksQueuedWrites: boolean,\n): TerminalSubmitFailureHandler | undefined {\n  return failureBlocksQueuedWrites\n    ? input.onTerminalSubmitFailure\n    : input.onReadOnlyProjectionFailure;\n}\nexport async function planDocumentSyncAttempt(input: {\n  pendingUpdates: readonly PendingUpdateRecord[];\n  pullContinuation?: DocumentSyncPullContinuation | undefined;\n  regenerateQueuedCheckpoints: boolean;\n  sync: SyncRemoteDocumentInput;\n  failureBlocksQueuedWrites: boolean;\n  writerProjection: DocumentWriterProjectionResponse;\n}) {\n  try {\n    const pendingUpdates =\n      input.pullContinuation === undefined ? input.pendingUpdates : [];\n    if (\n      pendingUpdates.length &&\n      input.sync.isRemoteSyncBlocked?.(\n        (\n          await assertDocumentManifestBundleConsistent({\n            bundle: input.writerProjection.documentManifest,\n            label: \"Document sync manifest\",\n          })\n        ).organizationId,\n      )\n    ) {\n      return abandonBlockedSync(input.sync);\n    }\n    // Durable repair happens once at this explicit attempt boundary. The\n    // retryable builder below may only sign inline plans against its projection.\n    const prepared =\n      pendingUpdates.length &&\n      !input.sync.buildContainerRekeys &&\n      input.sync.buildRotationSnapshot\n        ? await prepareSyncAttemptContainerRekeys(\n            input.sync,\n            input.writerProjection,\n          )\n        : { projection: input.writerProjection, plans: undefined };\n    if (!prepared) return null;\n    return await retrySyncPlanOrAbandon({\n      apiClient: input.sync.apiClient,\n      buildWithProjection: (projection) =>\n        buildRemoteDocumentSyncPlan({\n          pendingUpdates,\n          preparedRekeys:\n            projection === prepared.projection ? prepared.plans : undefined,\n          minLsn: resolvePullContinuationMinLsn(\n            input.pullContinuation,\n            input.sync.minLsn,\n          ),\n          pullCursor: input.pullContinuation?.cursor,\n          projection,\n          regenerateQueuedCheckpoints: input.regenerateQueuedCheckpoints,\n          sync: input.sync,\n        }),\n      documentId: input.sync.documentId,\n      onRemoteDocumentDeleted: input.sync.onRemoteDocumentDeleted,\n      onSyncAbandoned: input.sync.onSyncAbandoned,\n      onSyncTrace: input.sync.onSyncTrace,\n      onTerminalFailure: projectionFailureHandler(\n        input.sync,\n        input.failureBlocksQueuedWrites,\n      ),\n      stillCurrent: input.sync.stillCurrent,\n      writerProjection: prepared.projection,\n    });\n  } catch (error) {\n    if (error instanceof DocumentSyncPreparationRequiredError)\n      return \"retry\" as const;\n    if (error instanceof DocumentAncestorRepairAbandonedError) {\n      return abandonAncestorRepair(input.sync, error);\n    }\n    if (error instanceof ContainerKekRepairInaccessibleError) {\n      return abandonInaccessibleAncestorRepair(input.sync, error);\n    }\n    if (!isDocumentSyncRequestLimitError(error)) {\n      throw error;\n    }\n    return abandonOversizedSyncPlan(input.sync, error);\n  }\n}\n"]}

package/workflows/documents/syncAttemptState.d.ts

@@ -0,0 +1,27 @@
+import type { DocumentWriterProjectionResponse } from "../../internal/validators/response/index.js";
+import type { MaterializedContainerRekeyPlan } from "../../data/containers/shared/types.js";
+import type { DocumentSyncPullContinuation } from "../../data/documents/shared/syncPagination.js";
+import type { SyncRemoteDocumentResult } from "../../data/documents/shared/types.js";
+import type { PendingUpdateRecord } from "../../data/sqlite/documentPersistence.js";
+export type DocumentSyncContainerRekeyBuilder = (writerProjection: DocumentWriterProjectionResponse, verification: {
+    readonly persistVerificationCheckpoints: false;
+}) => Promise<readonly MaterializedContainerRekeyPlan[]>;
+export interface RemoteDocumentSyncAttemptState {
+    pendingUpdates: readonly PendingUpdateRecord[];
+    pullContinuation: DocumentSyncPullContinuation | undefined;
+    recoveryPendingUpdatesById: Map<string, PendingUpdateRecord>;
+    regenerateQueuedCheckpoints: boolean;
+    reusableWriterProjection: DocumentWriterProjectionResponse | null;
+}
+export type RemoteDocumentSyncAttemptOutcome = {
+    kind: "complete";
+    result: SyncRemoteDocumentResult | null;
+} | {
+    kind: "recover";
+    updates: Map<string, PendingUpdateRecord>;
+} | {
+    kind: "regenerate";
+} | {
+    kind: "retry";
+    pullContinuation: DocumentSyncPullContinuation | undefined;
+};

package/workflows/documents/syncAttemptState.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=syncAttemptState.js.map

package/workflows/documents/syncAttemptState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncAttemptState.js","sourceRoot":"","sources":["syncAttemptState.ts"],"names":[],"mappings":"","sourcesContent":["import type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport type { MaterializedContainerRekeyPlan } from \"../../data/containers/shared/types\";\nimport type { DocumentSyncPullContinuation } from \"../../data/documents/shared/syncPagination\";\nimport type { SyncRemoteDocumentResult } from \"../../data/documents/shared/types\";\nimport type { PendingUpdateRecord } from \"../../data/sqlite/documentPersistence\";\n\nexport type DocumentSyncContainerRekeyBuilder = (\n  writerProjection: DocumentWriterProjectionResponse,\n  verification: { readonly persistVerificationCheckpoints: false },\n) => Promise<readonly MaterializedContainerRekeyPlan[]>;\n\nexport interface RemoteDocumentSyncAttemptState {\n  pendingUpdates: readonly PendingUpdateRecord[];\n  pullContinuation: DocumentSyncPullContinuation | undefined;\n  recoveryPendingUpdatesById: Map<string, PendingUpdateRecord>;\n  regenerateQueuedCheckpoints: boolean;\n  reusableWriterProjection: DocumentWriterProjectionResponse | null;\n}\n\nexport type RemoteDocumentSyncAttemptOutcome =\n  | { kind: \"complete\"; result: SyncRemoteDocumentResult | null }\n  | { kind: \"recover\"; updates: Map<string, PendingUpdateRecord> }\n  | { kind: \"regenerate\" }\n  | {\n      kind: \"retry\";\n      pullContinuation: DocumentSyncPullContinuation | undefined;\n    };\n"]}