@tearleads/client-sdk 0.1.61 → 0.1.63

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

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

package/workflows/documents/sync/readOnlySync.js

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

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

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

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

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

package/workflows/documents/sync/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 { retrySyncPlanOrAbandon } from "../syncFailures/index.js";
+import { abandonAncestorRepair, abandonBlockedSync, abandonInaccessibleAncestorRepair, abandonOversizedSyncPlan, } from "../syncFailures/syncAbandon.js";
+import { DocumentAncestorRepairAbandonedError, DocumentSyncPreparationRequiredError, } from "../syncFailures/syncRepairAbandon.js";
+import { prepareSyncAttemptContainerRekeys } from "../syncRekeys/syncContainerRekeyPreparation.js";
+import { buildRemoteDocumentSyncPlan } from "../syncRekeys/syncContainerRekeys.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/sync/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 { retrySyncPlanOrAbandon } from \"../syncFailures\";\nimport {\n  abandonAncestorRepair,\n  abandonBlockedSync,\n  abandonInaccessibleAncestorRepair,\n  abandonOversizedSyncPlan,\n} from \"../syncFailures/syncAbandon\";\nimport type { TerminalSubmitFailureHandler } from \"../syncFailures/syncFailureClassification\";\nimport {\n  DocumentAncestorRepairAbandonedError,\n  DocumentSyncPreparationRequiredError,\n} from \"../syncFailures/syncRepairAbandon\";\nimport { prepareSyncAttemptContainerRekeys } from \"../syncRekeys/syncContainerRekeyPreparation\";\nimport { buildRemoteDocumentSyncPlan } from \"../syncRekeys/syncContainerRekeys\";\nimport type { SyncRemoteDocumentInput } from \"./readOnlySync\";\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/sync/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/sync/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"]}

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

@@ -0,0 +1,20 @@
+import type { DomainScope } from "../../../data/shared/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>;
+    readonly priority?: (() => number) | undefined;
+}): 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>;