@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/documents/sync.js.map

@@ -1 +0,0 @@
-{"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        stillCurrent: input.stillCurrent,\n        warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,\n      }),\n    });\n  } catch (error) {\n    if (isProjectionVerificationCancelledError(error)) return null;\n    if (\n      input.stillCurrent?.() !== false &&\n      isDocumentSyncUpdateIsolationError(error)\n    ) {\n      await input.onIncomingUpdateIsolationFailure?.(error);\n    }\n    throw error;\n  }\n}\n"]}

package/workflows/documents/syncAbandon.js

@@ -1,51 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,79 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,27 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"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/syncAutomaticContainerRekeys.js

@@ -1,119 +0,0 @@
-import { KeyingVerificationError } from "../../internal/crypto/index.js";
-import { MAX_INLINE_CONTAINER_REKEYS } from "../../internal/validators/util/index.js";
-import { ContainerAuthorAccessError } from "../../data/containers/shared/authorAccess.js";
-import { ContainerKekRepairInaccessibleError } from "../../data/documents/shared/containerKekCurrency.js";
-import { ContainerKekTargetUnreachableError } from "../../data/documents/shared/containerKekPath.js";
-import { documentContainerProjections } from "../../data/keyingProjectionVerification/documentContainerProjections.js";
-import { assertProjectionVerificationCurrent } from "../../data/keyingProjectionVerification/types.js";
-import { buildMaterializedContainerRekeyPlan } from "../containers/child/rekey.js";
-import { applyContainerRekeyPlan } from "./syncContainerRekeyProjection.js";
-import { DocumentAncestorRepairAbandonedError } from "./syncRepairAbandon.js";
-import { hasOtherLinkedWriteAccess } from "./syncRepairAccess.js";
-function firstStaleContainer(projection) {
-    for (const path of documentContainerProjections(projection)) {
-        for (let index = 1; index < path.containerKeks.length; index += 1) {
-            const parent = path.containerKeks[index - 1];
-            const child = path.containerKeks[index];
-            if (!parent || !child)
-                throw new Error("Container KEK path is incomplete");
-            if (child.parentContainerKeyEpochId === parent.containerKeyEpochId) {
-                continue;
-            }
-            return {
-                isPathTarget: index === path.containerKeks.length - 1,
-                projection: {
-                    ...path,
-                    containerId: child.containerId,
-                    containerKeks: path.containerKeks.slice(0, index + 1),
-                    path: path.path.slice(0, index + 1),
-                },
-            };
-        }
-    }
-    return null;
-}
-/**
- * The stale container is not this writer's to re-key: no wrap on the verified
- * path opens it, or the signed path grants the signer no write access there.
- * Both are judged against the path sliced at the stale container, so a grant
- * held only further down never counts — exactly the API's `container.rekey`
- * rule. Anything else (keyring damage, a forged path) stays an error.
- *
- * A target's write refusal is handled separately: another linked target may
- * still authorize the document write. Key unwrap failures on a target stay
- * errors, because this path's readable grant should open its own key.
- */
-function isRepairInaccessible(error, stale) {
-    if (stale.isPathTarget)
-        return false;
-    return (error instanceof ContainerAuthorAccessError ||
-        (error instanceof ContainerKekTargetUnreachableError &&
-            error.containerId === stale.projection.containerId));
-}
-/** Prepare parent-first repairs; the sync transaction commits them with the write. */
-export async function buildAutomaticContainerRekeys(sync, initialProjection) {
-    const plans = [];
-    const plannedIds = new Set();
-    let projection = initialProjection;
-    for (;;) {
-        const stale = firstStaleContainer(projection);
-        if (!stale)
-            return { plans, hasMore: false };
-        const previousProjection = stale.projection;
-        if (plans.length >= MAX_INLINE_CONTAINER_REKEYS) {
-            return { plans, hasMore: true };
-        }
-        // Use the shared cancellation sentinel: syncRemoteDocument converts only
-        // that to a graceful null, so a plain Error would report a routine
-        // generation flip mid-repair as a real sync failure.
-        assertProjectionVerificationCurrent(sync.stillCurrent);
-        if (plannedIds.has(previousProjection.containerId)) {
-            // Abandon like every other routine repair failure: two linked paths
-            // disagreeing about a container is a concurrent-rotation race, not a
-            // defect, and a raw Error would crash the sync lane instead.
-            throw new DocumentAncestorRepairAbandonedError("peer-rotation");
-        }
-        // Assert rather than adopt: resolveRotationContext compares the verified
-        // manifest's organization against the author's, so substituting the path's
-        // own organization here would make that the only cross-org check and leave
-        // it comparing a server-supplied value with itself.
-        if (previousProjection.organizationId !== sync.author.organizationId) {
-            throw new KeyingVerificationError("object_mismatch", "Document ancestor repair crosses the author's organization");
-        }
-        const planned = await buildMaterializedContainerRekeyPlan({
-            author: sync.author,
-            persistVerificationCheckpoints: false,
-            previousProjection,
-            signedAt: sync.signedAt,
-            targetSecretKey: sync.targetSecretKey,
-            resolveProjectionUserKey: sync.resolveProjectionUserKey,
-            stillCurrent: sync.stillCurrent,
-            warmReferencedPrincipalPolicies: sync.warmReferencedPrincipalPolicies,
-            execSql: sync.execSql,
-        }).catch(async (error) => {
-            if (error instanceof ContainerAuthorAccessError && stale.isPathTarget) {
-                if (await hasOtherLinkedWriteAccess(sync, initialProjection, previousProjection.containerId)) {
-                    throw new ContainerKekRepairInaccessibleError(previousProjection.containerId);
-                }
-                await sync.onTerminalSubmitFailure?.({
-                    code: error.code,
-                    message: error.message,
-                    ok: false,
-                    report: () => undefined,
-                    status: error.status,
-                });
-                throw new DocumentAncestorRepairAbandonedError("refused");
-            }
-            // Repairs run parent-first and access inherits downward, so only the
-            // first stale container can be out of reach. Retry-classified like any
-            // stale path: one refetch sees a repair a capable member already made.
-            throw isRepairInaccessible(error, stale)
-                ? new ContainerKekRepairInaccessibleError(previousProjection.containerId)
-                : error;
-        });
-        plannedIds.add(previousProjection.containerId);
-        plans.push(planned);
-        projection = await applyContainerRekeyPlan(projection, planned);
-    }
-}
-//# sourceMappingURL=syncAutomaticContainerRekeys.js.map

package/workflows/documents/syncAutomaticContainerRekeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syncAutomaticContainerRekeys.js","sourceRoot":"","sources":["syncAutomaticContainerRekeys.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyingVerificationError } from \"@tearleads/crypto\";\nimport type {\n  ContainerWriterProjectionResponse,\n  DocumentWriterProjectionResponse,\n} from \"@tearleads/validators/response\";\nimport { MAX_INLINE_CONTAINER_REKEYS } from \"@tearleads/validators/util\";\nimport { ContainerAuthorAccessError } from \"../../data/containers/shared/authorAccess\";\nimport type { MaterializedContainerRekeyPlan } from \"../../data/containers/shared/types\";\nimport { ContainerKekRepairInaccessibleError } from \"../../data/documents/shared/containerKekCurrency\";\nimport { ContainerKekTargetUnreachableError } from \"../../data/documents/shared/containerKekPath\";\nimport { documentContainerProjections } from \"../../data/keyingProjectionVerification/documentContainerProjections\";\nimport { assertProjectionVerificationCurrent } from \"../../data/keyingProjectionVerification/types\";\nimport { buildMaterializedContainerRekeyPlan } from \"../containers/child/rekey\";\nimport type { SyncRemoteDocumentInput } from \"./readOnlySync\";\nimport { applyContainerRekeyPlan } from \"./syncContainerRekeyProjection\";\nimport { DocumentAncestorRepairAbandonedError } from \"./syncRepairAbandon\";\nimport { hasOtherLinkedWriteAccess } from \"./syncRepairAccess\";\n\ninterface StaleContainer {\n  /** The stale container is the one the document itself is linked into. */\n  readonly isPathTarget: boolean;\n  readonly projection: ContainerWriterProjectionResponse;\n}\n\nfunction firstStaleContainer(\n  projection: DocumentWriterProjectionResponse,\n): StaleContainer | null {\n  for (const path of documentContainerProjections(projection)) {\n    for (let index = 1; index < path.containerKeks.length; index += 1) {\n      const parent = path.containerKeks[index - 1];\n      const child = path.containerKeks[index];\n      if (!parent || !child)\n        throw new Error(\"Container KEK path is incomplete\");\n      if (child.parentContainerKeyEpochId === parent.containerKeyEpochId) {\n        continue;\n      }\n      return {\n        isPathTarget: index === path.containerKeks.length - 1,\n        projection: {\n          ...path,\n          containerId: child.containerId,\n          containerKeks: path.containerKeks.slice(0, index + 1),\n          path: path.path.slice(0, index + 1),\n        },\n      };\n    }\n  }\n  return null;\n}\n\n/**\n * The stale container is not this writer's to re-key: no wrap on the verified\n * path opens it, or the signed path grants the signer no write access there.\n * Both are judged against the path sliced at the stale container, so a grant\n * held only further down never counts — exactly the API's `container.rekey`\n * rule. Anything else (keyring damage, a forged path) stays an error.\n *\n * A target's write refusal is handled separately: another linked target may\n * still authorize the document write. Key unwrap failures on a target stay\n * errors, because this path's readable grant should open its own key.\n */\nfunction isRepairInaccessible(error: unknown, stale: StaleContainer): boolean {\n  if (stale.isPathTarget) return false;\n  return (\n    error instanceof ContainerAuthorAccessError ||\n    (error instanceof ContainerKekTargetUnreachableError &&\n      error.containerId === stale.projection.containerId)\n  );\n}\n\n/** Prepare parent-first repairs; the sync transaction commits them with the write. */\nexport async function buildAutomaticContainerRekeys(\n  sync: SyncRemoteDocumentInput,\n  initialProjection: DocumentWriterProjectionResponse,\n): Promise<{ plans: MaterializedContainerRekeyPlan[]; hasMore: boolean }> {\n  const plans: MaterializedContainerRekeyPlan[] = [];\n  const plannedIds = new Set<string>();\n  let projection = initialProjection;\n  for (;;) {\n    const stale = firstStaleContainer(projection);\n    if (!stale) return { plans, hasMore: false };\n    const previousProjection = stale.projection;\n    if (plans.length >= MAX_INLINE_CONTAINER_REKEYS) {\n      return { plans, hasMore: true };\n    }\n    // Use the shared cancellation sentinel: syncRemoteDocument converts only\n    // that to a graceful null, so a plain Error would report a routine\n    // generation flip mid-repair as a real sync failure.\n    assertProjectionVerificationCurrent(sync.stillCurrent);\n    if (plannedIds.has(previousProjection.containerId)) {\n      // Abandon like every other routine repair failure: two linked paths\n      // disagreeing about a container is a concurrent-rotation race, not a\n      // defect, and a raw Error would crash the sync lane instead.\n      throw new DocumentAncestorRepairAbandonedError(\"peer-rotation\");\n    }\n    // Assert rather than adopt: resolveRotationContext compares the verified\n    // manifest's organization against the author's, so substituting the path's\n    // own organization here would make that the only cross-org check and leave\n    // it comparing a server-supplied value with itself.\n    if (previousProjection.organizationId !== sync.author.organizationId) {\n      throw new KeyingVerificationError(\n        \"object_mismatch\",\n        \"Document ancestor repair crosses the author's organization\",\n      );\n    }\n    const planned = await buildMaterializedContainerRekeyPlan({\n      author: sync.author,\n      persistVerificationCheckpoints: false,\n      previousProjection,\n      signedAt: sync.signedAt,\n      targetSecretKey: sync.targetSecretKey,\n      resolveProjectionUserKey: sync.resolveProjectionUserKey,\n      stillCurrent: sync.stillCurrent,\n      warmReferencedPrincipalPolicies: sync.warmReferencedPrincipalPolicies,\n      execSql: sync.execSql,\n    }).catch(async (error: unknown) => {\n      if (error instanceof ContainerAuthorAccessError && stale.isPathTarget) {\n        if (\n          await hasOtherLinkedWriteAccess(\n            sync,\n            initialProjection,\n            previousProjection.containerId,\n          )\n        ) {\n          throw new ContainerKekRepairInaccessibleError(\n            previousProjection.containerId,\n          );\n        }\n        await sync.onTerminalSubmitFailure?.({\n          code: error.code,\n          message: error.message,\n          ok: false,\n          report: () => undefined,\n          status: error.status,\n        });\n        throw new DocumentAncestorRepairAbandonedError(\"refused\");\n      }\n      // Repairs run parent-first and access inherits downward, so only the\n      // first stale container can be out of reach. Retry-classified like any\n      // stale path: one refetch sees a repair a capable member already made.\n      throw isRepairInaccessible(error, stale)\n        ? new ContainerKekRepairInaccessibleError(\n            previousProjection.containerId,\n          )\n        : error;\n    });\n    plannedIds.add(previousProjection.containerId);\n    plans.push(planned);\n    projection = await applyContainerRekeyPlan(projection, planned);\n  }\n}\n"]}

package/workflows/documents/syncContainerRekeyPreparation.js

@@ -1,227 +0,0 @@
-import { KeyingVerificationError } from "../../internal/crypto/index.js";
-import { MAX_CONTAINER_PATH_LENGTH } from "../../internal/validators/util/index.js";
-import { acknowledgeContainerMutationBatch } from "../../data/containers/shared/mutationAcknowledgement.js";
-import { assertDocumentWriterProjectionConsistent } from "../../data/documents/shared/projection.js";
-import { projectionVerificationOptions } from "../../data/documents/shared/types.js";
-import { requireProjectionUserKeyResolver } from "../../data/keyingProjectionVerification/index.js";
-import { assertProjectionVerificationCurrent } from "../../data/keyingProjectionVerification/types.js";
-import { submitContainerRotation, submitRotationCarryingDescendants, } from "../containers/child/mutationSubmit.js";
-import { buildAutomaticContainerRekeys } from "./syncAutomaticContainerRekeys.js";
-import { shouldRetrySyncWithFreshWriterProjection } from "./syncFailureClassification.js";
-import { refreshSyncAttemptWriterProjection } from "./syncFailures.js";
-import { DocumentAncestorRepairAbandonedError } from "./syncRepairAbandon.js";
-/**
- * Repairs committed during one sync pass, keyed by the pass's own input object
- * (stable across all three attempts). The sync loop explicitly prepares each
- * attempt, so a counter local to one call would not bound the whole pass.
- */
-const passRepairTotals = new WeakMap();
-/**
- * Passes whose inline repairs the server refused for stranding a level above a
- * directly granted container. The write's flat rekey list cannot say which
- * descendants each repair must carry; a standalone rekey can, so the rest of
- * the pass commits every repair standalone before writing.
- */
-const standaloneRepairPasses = new WeakSet();
-export function requiresStandaloneAncestorRepairs(sync) {
-    return standaloneRepairPasses.has(sync);
-}
-export function requireStandaloneAncestorRepairs(sync) {
-    standaloneRepairPasses.add(sync);
-}
-/** A refusal the writer cannot clear by retrying, as opposed to 5xx/offline. */
-function isTerminalRepairStatus(status) {
-    return status === 401 || status === 402 || status === 403;
-}
-/**
- * One standalone repair. Prefers the status-bearing rekey: a permanent refusal
- * (403 once ancestor write access is revoked, 402) must leave a durable record,
- * while a 5xx or an offline blip must not, and plain `rekeyContainer` collapses
- * both to null. It is also the only way to learn which descendant rekeys this
- * repair must carry. An adapter without it still repairs; its refusals are just
- * reported as an ordinary abandon.
- */
-function submitStandaloneRepair(sync, plan, writerProjection) {
-    const options = {
-        expectedPaymentRequiredOrganizationId: plan.state.organizationId,
-    };
-    const { getContainerWriterProjection, rekeyContainerResult } = sync.apiClient;
-    return submitRotationCarryingDescendants({
-        carriedRekeys: getContainerWriterProjection && {
-            planning: {
-                apiClient: {
-                    getContainerWriterProjection: getContainerWriterProjection.bind(sync.apiClient),
-                },
-                author: sync.author,
-                execSql: sync.execSql,
-                resolveProjectionUserKey: requireProjectionUserKeyResolver(sync.resolveProjectionUserKey, "Document ancestor repair"),
-                stillCurrent: sync.stillCurrent,
-                targetSecretKey: sync.targetSecretKey,
-                warmReferencedPrincipalPolicies: sync.warmReferencedPrincipalPolicies,
-            },
-            rotated: async () => writerProjection,
-        },
-        stillCurrent: sync.stillCurrent,
-        submit: (carried) => {
-            const request = carried.length
-                ? { ...plan.request, containerRekeys: [...carried] }
-                : plan.request;
-            return submitContainerRotation({
-                plain: () => sync.apiClient.rekeyContainer(plan.containerId, request, options),
-                result: rekeyContainerResult
-                    ? () => rekeyContainerResult.call(sync.apiClient, plan.containerId, request, { ...options, reportErrors: false })
-                    : undefined,
-            });
-        },
-    });
-}
-async function commitRepairPrefix(input) {
-    let committed = 0;
-    for (const { plan, writerProjection } of input.plans) {
-        assertProjectionVerificationCurrent(input.sync.stillCurrent);
-        if (input.sync.isRemoteSyncBlocked?.(plan.state.organizationId)) {
-            throw new DocumentAncestorRepairAbandonedError("blocked");
-        }
-        if (input.repairedIds.has(plan.containerId)) {
-            throw new DocumentAncestorRepairAbandonedError("peer-rotation");
-        }
-        const { carriedPlans, result } = await submitStandaloneRepair(input.sync, plan, writerProjection);
-        const response = result.ok ? result.data : null;
-        // Deliberately not ContainerKekRepairRequiredError: that is classified as
-        // retryable, so a handled refusal would re-sign the whole prefix before
-        // failing again, and the retry never reaches onTerminalSubmitFailure
-        // regardless, because this throws before submission.
-        if (!response) {
-            if (!result.ok && isTerminalRepairStatus(result.status)) {
-                await input.sync.onTerminalSubmitFailure?.({
-                    code: "document_ancestor_repair_refused",
-                    message: `Ancestor repair refused for ${plan.containerId}`,
-                    ok: false,
-                    report: () => undefined,
-                    status: result.status,
-                });
-            }
-            throw new DocumentAncestorRepairAbandonedError("refused");
-        }
-        // What a repair carried committed with it, so the pins advance together.
-        const acknowledged = await acknowledgeContainerMutationBatch({
-            execSql: input.sync.execSql,
-            plans: [plan, ...carriedPlans.map((carried) => carried.plan)],
-            responses: [response, ...(response.containerRekeys ?? [])],
-            stillCurrent: input.sync.stillCurrent,
-        });
-        if (!acknowledged) {
-            // A refused guarded transaction is usually a generation flip; surface it
-            // as the shared cancellation so syncRemoteDocument returns null instead
-            // of reporting a routine flip as a sync failure.
-            assertProjectionVerificationCurrent(input.sync.stillCurrent);
-            throw new Error("Document ancestor repair was superseded");
-        }
-        input.repairedIds.add(plan.containerId);
-        for (const carried of carriedPlans) {
-            input.repairedIds.add(carried.plan.containerId);
-        }
-        committed += 1 + carriedPlans.length;
-        // The rest of this prefix was signed before the carry. A plan for a carried
-        // container extends a superseded head, and one below it pins an epoch that
-        // was never minted. Stop here; the caller refetches and re-plans.
-        if (carriedPlans.length > 0)
-            return committed;
-    }
-    return committed;
-}
-/**
- * Large repairs commit a bounded prefix; the last batch stays atomic with content.
- * A tighter local resource budget may be used, but never above the protocol cap.
- */
-export async function prepareAutomaticContainerRekeys(sync, initialProjection, maxRepairs = MAX_CONTAINER_PATH_LENGTH) {
-    if (initialProjection.documentId !== sync.documentId) {
-        throw new KeyingVerificationError("object_mismatch", "Document ancestor repair projection targets another document");
-    }
-    let projection = initialProjection;
-    const repairedIds = new Set();
-    // `repairedIds` only breaks a loop within one preparation. An explicit sync
-    // retry starts another preparation with a fresh set. Bound the
-    // work by the deepest authorizing path the protocol allows, counted across
-    // the whole pass rather than per call: no honest chain needs more repairs
-    // than that, so re-entry cannot multiply the budget.
-    for (;;) {
-        const batch = await buildAutomaticContainerRekeys(sync, projection);
-        const commitsStandalone = batch.hasMore ||
-            (batch.plans.length > 0 && standaloneRepairPasses.has(sync));
-        if (!commitsStandalone)
-            return { plans: batch.plans, projection };
-        // Standalone mutations require authentic document scope before any request.
-        // Persist the verified heads here, unlike the inline path: a committed
-        // repair is acknowledged against the latest durable pin, and a repaired
-        // ancestor is always past epoch 1, so a device that has never pinned it
-        // would reject its own acknowledgement after the server already committed
-        // the rekey. The inline path needs no pin because the sync response
-        // re-verifies and pins before anything is acknowledged.
-        await assertDocumentWriterProjectionConsistent(projection, {
-            ...projectionVerificationOptions(sync),
-            persistVerificationCheckpoints: true,
-            allowStaleContentKeyBundle: true,
-        });
-        // Charge what this prefix can still commit, then settle to what it did: it
-        // stops early after a repair that carried something, and charging the plans
-        // it never submitted would spend the budget on work that did not happen.
-        const committedBefore = passRepairTotals.get(sync) ?? 0;
-        if (committedBefore + batch.plans.length >
-            Math.min(maxRepairs, MAX_CONTAINER_PATH_LENGTH)) {
-            throw new DocumentAncestorRepairAbandonedError("depth-budget");
-        }
-        passRepairTotals.set(sync, committedBefore +
-            (await commitRepairPrefix({ plans: batch.plans, repairedIds, sync })));
-        const fresh = await refreshSyncAttemptWriterProjection({
-            apiClient: sync.apiClient,
-            documentId: sync.documentId,
-            onRemoteDocumentDeleted: sync.onRemoteDocumentDeleted,
-            onSyncAbandoned: sync.onSyncAbandoned,
-            onSyncTrace: sync.onSyncTrace,
-            // Always a write-bearing pass, so a terminal projection failure (a 403
-            // after revocation mid-repair) must leave the durable record that the
-            // queued writes are blocked. onReadOnlyProjectionFailure is documented
-            // for passes without queued writes and would not apply here.
-            onTerminalFailure: sync.onTerminalSubmitFailure,
-            stillCurrent: sync.stillCurrent,
-        });
-        if (!fresh) {
-            // refreshSyncAttemptWriterProjection returns null on a generation flip.
-            assertProjectionVerificationCurrent(sync.stillCurrent);
-            // It has already called onSyncAbandoned by this point, and on a coded 404
-            // ran the verified local teardown, so a bare Error would double-signal as
-            // an abandon plus a sync-lane crash.
-            throw new DocumentAncestorRepairAbandonedError("unrefreshable");
-        }
-        // The scope check above guards the first round only; a refetched projection
-        // is server-supplied too, and nothing in the refresh path proves it names
-        // the document this repair is for.
-        if (fresh.documentId !== sync.documentId) {
-            throw new KeyingVerificationError("object_mismatch", "Document ancestor repair projection targets another document");
-        }
-        projection = fresh;
-    }
-}
-/** An explicit preparation retry may commit repairs; plan retries never do. */
-export async function prepareSyncAttemptContainerRekeys(sync, projection) {
-    try {
-        return await prepareAutomaticContainerRekeys(sync, projection);
-    }
-    catch (error) {
-        if (!sync.apiClient.evictDocumentWriterProjection ||
-            !shouldRetrySyncWithFreshWriterProjection(error))
-            throw error;
-    }
-    const fresh = await refreshSyncAttemptWriterProjection({
-        apiClient: sync.apiClient,
-        documentId: sync.documentId,
-        onRemoteDocumentDeleted: sync.onRemoteDocumentDeleted,
-        onSyncAbandoned: sync.onSyncAbandoned,
-        onSyncTrace: sync.onSyncTrace,
-        onTerminalFailure: sync.onTerminalSubmitFailure,
-        stillCurrent: sync.stillCurrent,
-    });
-    return fresh ? prepareAutomaticContainerRekeys(sync, fresh) : null;
-}
-//# sourceMappingURL=syncContainerRekeyPreparation.js.map