@tearleads/client-sdk 0.1.64 → 0.1.66

package/client/organizations/organizationAccessRestoration.js

@@ -1,6 +1,6 @@
 import { sqlDocumentMoveIntentPersistence } from "../../data/persistence/container-contents/documentMoveIntentPersistence.js";
 import { requestDormantMetadataRestorationSweeps } from "../../data/persistence/container-contents/dormantMetadataSweep.js";
-import { hasRecordedTerminalSyncFailures } from "../../data/sqlite/documentPersistence.js";
+import { hasRecordedTerminalSyncFailures } from "../../data/sqlite/documentPersistence/index.js";
 import { requestAllDomainSyncLanes, requestDomainSyncLane, } from "../../data/sync/syncCoordinator.js";
 import { CONTAINER_CONTENTS_SYNC_LANE_KEY } from "../../workflows/container-contents/syncLane.js";
 /** Recover parked work before optional presentation hydration can fail. */

package/data/containers/shared/mutationAcknowledgement.js

@@ -1,6 +1,6 @@
 import { accessManifestCheckpointFromManifest, compareCanonicalStrings, computeContainerKekKeyringHash, computeContainerKekRecipientTargetHash, computeContainerKeyEpochHash, } from "../../../internal/crypto/index.js";
 import { canonicalKeyingJsonString } from "../../keying/canonicalJson.js";
-import { advanceLocallyAcknowledgedAccessManifestHeadsAtomically, } from "../../persistence/locallyAcknowledgedCheckpointPersistence.js";
+import { advanceLocallyAcknowledgedAccessManifestHeadsAtomically, } from "../../persistence/keyingCheckpoints/locallyAcknowledgedCheckpointPersistence.js";
 function assertCanonicalMatch(input) {
     if (canonicalKeyingJsonString(input.actual, `${input.label} response`) !==
         canonicalKeyingJsonString(input.expected, `${input.label} plan`)) {

package/data/containers/shared/mutationAcknowledgement.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutationAcknowledgement.js","sourceRoot":"","sources":["mutationAcknowledgement.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type AccessEvent,\n  type AccessManifest,\n  accessManifestCheckpointFromManifest,\n  type ContainerAccessManifestState,\n  type ContainerKekRecipientTarget,\n  type ContainerKeyEpoch,\n  type ContainerKeyWrap,\n  compareCanonicalStrings,\n  computeContainerKekKeyringHash,\n  computeContainerKekRecipientTargetHash,\n  computeContainerKeyEpochHash,\n} from \"@tearleads/crypto\";\nimport type { ContainerMutationResponse } from \"@tearleads/validators/response\";\nimport { canonicalKeyingJsonString } from \"../../keying/canonicalJson\";\nimport {\n  advanceLocallyAcknowledgedAccessManifestHeadsAtomically,\n  type LocallyAcknowledgedAccessManifestHead,\n} from \"../../persistence/locallyAcknowledgedCheckpointPersistence\";\nimport type { ExecSql } from \"../../sqlite/sqlSchema\";\n\nexport interface AuthoredContainerMutationHead {\n  readonly body: object;\n  readonly containerId: string;\n  readonly event: AccessEvent;\n  readonly eventHash: string;\n  readonly keyEpoch: ContainerKeyEpoch;\n  readonly manifest: AccessManifest;\n  readonly manifestHash: string;\n  /**\n   * The keyring the epoch already had, for mutations that keep their epoch.\n   * Its artifact is immutable, so the response must echo exactly this.\n   */\n  readonly previousKeyring?: Record<string, unknown> | null | undefined;\n  readonly state: ContainerAccessManifestState;\n  readonly wraps: readonly ContainerKeyWrap[];\n}\n\nfunction assertCanonicalMatch(input: {\n  readonly actual: unknown;\n  readonly expected: unknown;\n  readonly label: string;\n}): void {\n  if (\n    canonicalKeyingJsonString(input.actual, `${input.label} response`) !==\n    canonicalKeyingJsonString(input.expected, `${input.label} plan`)\n  ) {\n    throw new Error(`Container mutation response ${input.label} mismatch`);\n  }\n}\n\nfunction sortedCanonicalValues<T>(values: readonly T[], label: string): T[] {\n  return [...values].sort((left, right) =>\n    compareCanonicalStrings(\n      canonicalKeyingJsonString(left, label),\n      canonicalKeyingJsonString(right, label),\n    ),\n  );\n}\n\nfunction expectedRecipientTargets(\n  wraps: readonly ContainerKeyWrap[],\n): ContainerKekRecipientTarget[] {\n  return sortedCanonicalValues(\n    wraps.map((wrap) => ({\n      recipientId: wrap.recipientId,\n      recipientKeyEpochId: wrap.recipientKeyEpochId,\n      recipientKeyFingerprint: wrap.recipientKeyFingerprint,\n      recipientKind: wrap.recipientKind,\n    })),\n    \"recipient target\",\n  );\n}\n\nfunction assertResponseIdentity(\n  plan: AuthoredContainerMutationHead,\n  response: ContainerMutationResponse,\n): void {\n  if (\n    response.containerId !== plan.containerId ||\n    response.organizationId !== plan.state.organizationId ||\n    response.parentId !== plan.state.parentContainerId\n  ) {\n    throw new Error(\"Container mutation response object identity mismatch\");\n  }\n  // The top-level slot column is what local system-container lookups key on,\n  // so it must echo the slot this client signed into the manifest state; an\n  // omitted slot is the server's spelling of null.\n  if ((response.systemSlot ?? null) !== plan.state.systemSlot) {\n    throw new Error(\"Container mutation response system slot mismatch\");\n  }\n  if (\n    response.manifestHead.epoch !== plan.state.epoch ||\n    response.manifestHead.manifestHash !== plan.manifestHash ||\n    response.accessManifest.manifestHash !== plan.manifestHash\n  ) {\n    throw new Error(\"Container mutation response manifest head mismatch\");\n  }\n  if (\n    response.containerKek.containerId !== plan.containerId ||\n    response.containerKek.accessManifestHash !== plan.manifestHash ||\n    response.containerKek.containerKeyEpochId !== plan.keyEpoch.id ||\n    response.containerKek.containerKeyEpoch !== plan.keyEpoch.keyEpoch\n  ) {\n    throw new Error(\"Container mutation response KEK identity mismatch\");\n  }\n}\n\n/** A rotation body commits a keyring hash; other bodies do not. */\nfunction readOptionalKeyringHash(body: object): string | null {\n  const value = Reflect.get(body, \"keyringHash\");\n  return typeof value === \"string\" ? value : null;\n}\n\n/**\n * The response's keyring must be the one this client's own signed event\n * committed to. Without this a server could echo a substituted snapshot and\n * have it acknowledged into durable local state — the acknowledgement is the\n * moment the response becomes trusted, so the commitment is checked here.\n */\nasync function assertAcknowledgedKeyring(\n  plan: AuthoredContainerMutationHead,\n  response: ContainerMutationResponse,\n): Promise<void> {\n  const committedHash = readOptionalKeyringHash(plan.body);\n  const keyring = response.containerKek.keyring;\n  if (committedHash === null) {\n    // A non-rotating mutation keeps its epoch, so the echoed keyring must be\n    // the immutable artifact that epoch already had. Accepting anything else\n    // would let a server null or substitute the snapshot in the response that\n    // becomes the next writer projection.\n    const expected = plan.previousKeyring ?? null;\n    if (expected === null) {\n      // The epoch had no keyring, so the response must not invent one: an\n      // injected snapshot would become the next writer projection's history.\n      if (keyring) {\n        throw new Error(\n          \"Container mutation response added a keyring to an unchanged epoch\",\n        );\n      }\n      return;\n    }\n    if (!keyring) {\n      throw new Error(\n        \"Container mutation response dropped its unchanged keyring\",\n      );\n    }\n    if (\n      (await computeContainerKekKeyringHash(keyring)) !==\n      (await computeContainerKekKeyringHash(expected))\n    ) {\n      throw new Error(\n        \"Container mutation response replaced its unchanged keyring\",\n      );\n    }\n    return;\n  }\n  if (!keyring) {\n    throw new Error(\"Container mutation response is missing its keyring\");\n  }\n  if ((await computeContainerKekKeyringHash(keyring)) !== committedHash) {\n    throw new Error(\n      \"Container mutation response keyring does not match its signed event\",\n    );\n  }\n}\n\nasync function assertResponseContent(\n  plan: AuthoredContainerMutationHead,\n  response: ContainerMutationResponse,\n): Promise<void> {\n  assertCanonicalMatch({\n    actual: response.accessManifest.event.event,\n    expected: plan.event,\n    label: \"event\",\n  });\n  assertCanonicalMatch({\n    actual: response.accessManifest.event.body,\n    expected: plan.body,\n    label: \"event body\",\n  });\n  if (response.accessManifest.event.eventHash !== plan.eventHash) {\n    throw new Error(\"Container mutation response event hash mismatch\");\n  }\n  assertCanonicalMatch({\n    actual: response.accessManifest.manifest,\n    expected: plan.manifest,\n    label: \"manifest\",\n  });\n  assertCanonicalMatch({\n    actual: response.accessManifest.state,\n    expected: plan.state,\n    label: \"state\",\n  });\n  assertCanonicalMatch({\n    actual: response.containerKek.keyEpoch,\n    expected: plan.keyEpoch,\n    label: \"key epoch\",\n  });\n  await assertAcknowledgedKeyring(plan, response);\n  assertCanonicalMatch({\n    actual: sortedCanonicalValues(response.containerKek.wraps, \"response wrap\"),\n    expected: sortedCanonicalValues(plan.wraps, \"planned wrap\"),\n    label: \"wraps\",\n  });\n  const recipientTargets = expectedRecipientTargets(plan.wraps);\n  const responseTargets = sortedCanonicalValues(\n    response.containerKek.recipientTargets,\n    \"response recipient target\",\n  );\n  assertCanonicalMatch({\n    actual: responseTargets,\n    expected: recipientTargets,\n    label: \"recipient targets\",\n  });\n  if (\n    response.containerKek.keyEpochHash !==\n      (await computeContainerKeyEpochHash(plan.keyEpoch)) ||\n    response.containerKek.keyTargetHash !==\n      (await computeContainerKekRecipientTargetHash(recipientTargets)) ||\n    response.containerKek.parentContainerKeyEpochId !==\n      plan.keyEpoch.parentContainerKeyEpochId\n  ) {\n    throw new Error(\"Container mutation response KEK commitment mismatch\");\n  }\n  assertCanonicalMatch({\n    actual: response.referencedPrincipalHeads,\n    expected: plan.manifest.referencedPrincipalHeads,\n    label: \"referenced principal heads\",\n  });\n}\n\nexport async function locallyAcknowledgedContainerMutationHead(input: {\n  readonly plan: AuthoredContainerMutationHead;\n  readonly response: ContainerMutationResponse;\n}): Promise<LocallyAcknowledgedAccessManifestHead> {\n  assertResponseIdentity(input.plan, input.response);\n  await assertResponseContent(input.plan, input.response);\n  return {\n    checkpoint: accessManifestCheckpointFromManifest({\n      manifest: input.plan.manifest,\n      manifestHash: input.plan.manifestHash,\n    }),\n    previousManifestHash: input.plan.manifest.previousManifestHash,\n  };\n}\n\n/** Correlates an API acknowledgement to the locally signed plan before pinning. */\nexport async function acknowledgeContainerMutation(input: {\n  readonly execSql: ExecSql;\n  readonly plan: AuthoredContainerMutationHead;\n  readonly response: ContainerMutationResponse;\n  readonly stillCurrent?: (() => boolean) | undefined;\n}): Promise<boolean> {\n  return advanceLocallyAcknowledgedAccessManifestHeadsAtomically({\n    execSql: input.execSql,\n    heads: [\n      await locallyAcknowledgedContainerMutationHead({\n        plan: input.plan,\n        response: input.response,\n      }),\n    ],\n    stillCurrent: input.stillCurrent,\n  });\n}\n\n/** Correlates and advances a complete authored mutation batch atomically. */\nexport async function acknowledgeContainerMutationBatch(input: {\n  readonly execSql: ExecSql;\n  readonly plans: readonly AuthoredContainerMutationHead[];\n  readonly responses: readonly ContainerMutationResponse[];\n  readonly stillCurrent?: (() => boolean) | undefined;\n}): Promise<boolean> {\n  if (input.plans.length !== input.responses.length) {\n    throw new Error(\"Container mutation acknowledgement batch is incomplete\");\n  }\n  const heads = await Promise.all(\n    input.plans.map(async (plan, index) => {\n      const response = input.responses[index];\n      if (!response) {\n        throw new Error(\n          \"Container mutation acknowledgement batch is incomplete\",\n        );\n      }\n      return locallyAcknowledgedContainerMutationHead({ plan, response });\n    }),\n  );\n  return advanceLocallyAcknowledgedAccessManifestHeadsAtomically({\n    execSql: input.execSql,\n    heads,\n    stillCurrent: input.stillCurrent,\n  });\n}\n"]}
+{"version":3,"file":"mutationAcknowledgement.js","sourceRoot":"","sources":["mutationAcknowledgement.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type AccessEvent,\n  type AccessManifest,\n  accessManifestCheckpointFromManifest,\n  type ContainerAccessManifestState,\n  type ContainerKekRecipientTarget,\n  type ContainerKeyEpoch,\n  type ContainerKeyWrap,\n  compareCanonicalStrings,\n  computeContainerKekKeyringHash,\n  computeContainerKekRecipientTargetHash,\n  computeContainerKeyEpochHash,\n} from \"@tearleads/crypto\";\nimport type { ContainerMutationResponse } from \"@tearleads/validators/response\";\nimport { canonicalKeyingJsonString } from \"../../keying/canonicalJson\";\nimport {\n  advanceLocallyAcknowledgedAccessManifestHeadsAtomically,\n  type LocallyAcknowledgedAccessManifestHead,\n} from \"../../persistence/keyingCheckpoints/locallyAcknowledgedCheckpointPersistence\";\nimport type { ExecSql } from \"../../sqlite/sqlSchema\";\n\nexport interface AuthoredContainerMutationHead {\n  readonly body: object;\n  readonly containerId: string;\n  readonly event: AccessEvent;\n  readonly eventHash: string;\n  readonly keyEpoch: ContainerKeyEpoch;\n  readonly manifest: AccessManifest;\n  readonly manifestHash: string;\n  /**\n   * The keyring the epoch already had, for mutations that keep their epoch.\n   * Its artifact is immutable, so the response must echo exactly this.\n   */\n  readonly previousKeyring?: Record<string, unknown> | null | undefined;\n  readonly state: ContainerAccessManifestState;\n  readonly wraps: readonly ContainerKeyWrap[];\n}\n\nfunction assertCanonicalMatch(input: {\n  readonly actual: unknown;\n  readonly expected: unknown;\n  readonly label: string;\n}): void {\n  if (\n    canonicalKeyingJsonString(input.actual, `${input.label} response`) !==\n    canonicalKeyingJsonString(input.expected, `${input.label} plan`)\n  ) {\n    throw new Error(`Container mutation response ${input.label} mismatch`);\n  }\n}\n\nfunction sortedCanonicalValues<T>(values: readonly T[], label: string): T[] {\n  return [...values].sort((left, right) =>\n    compareCanonicalStrings(\n      canonicalKeyingJsonString(left, label),\n      canonicalKeyingJsonString(right, label),\n    ),\n  );\n}\n\nfunction expectedRecipientTargets(\n  wraps: readonly ContainerKeyWrap[],\n): ContainerKekRecipientTarget[] {\n  return sortedCanonicalValues(\n    wraps.map((wrap) => ({\n      recipientId: wrap.recipientId,\n      recipientKeyEpochId: wrap.recipientKeyEpochId,\n      recipientKeyFingerprint: wrap.recipientKeyFingerprint,\n      recipientKind: wrap.recipientKind,\n    })),\n    \"recipient target\",\n  );\n}\n\nfunction assertResponseIdentity(\n  plan: AuthoredContainerMutationHead,\n  response: ContainerMutationResponse,\n): void {\n  if (\n    response.containerId !== plan.containerId ||\n    response.organizationId !== plan.state.organizationId ||\n    response.parentId !== plan.state.parentContainerId\n  ) {\n    throw new Error(\"Container mutation response object identity mismatch\");\n  }\n  // The top-level slot column is what local system-container lookups key on,\n  // so it must echo the slot this client signed into the manifest state; an\n  // omitted slot is the server's spelling of null.\n  if ((response.systemSlot ?? null) !== plan.state.systemSlot) {\n    throw new Error(\"Container mutation response system slot mismatch\");\n  }\n  if (\n    response.manifestHead.epoch !== plan.state.epoch ||\n    response.manifestHead.manifestHash !== plan.manifestHash ||\n    response.accessManifest.manifestHash !== plan.manifestHash\n  ) {\n    throw new Error(\"Container mutation response manifest head mismatch\");\n  }\n  if (\n    response.containerKek.containerId !== plan.containerId ||\n    response.containerKek.accessManifestHash !== plan.manifestHash ||\n    response.containerKek.containerKeyEpochId !== plan.keyEpoch.id ||\n    response.containerKek.containerKeyEpoch !== plan.keyEpoch.keyEpoch\n  ) {\n    throw new Error(\"Container mutation response KEK identity mismatch\");\n  }\n}\n\n/** A rotation body commits a keyring hash; other bodies do not. */\nfunction readOptionalKeyringHash(body: object): string | null {\n  const value = Reflect.get(body, \"keyringHash\");\n  return typeof value === \"string\" ? value : null;\n}\n\n/**\n * The response's keyring must be the one this client's own signed event\n * committed to. Without this a server could echo a substituted snapshot and\n * have it acknowledged into durable local state — the acknowledgement is the\n * moment the response becomes trusted, so the commitment is checked here.\n */\nasync function assertAcknowledgedKeyring(\n  plan: AuthoredContainerMutationHead,\n  response: ContainerMutationResponse,\n): Promise<void> {\n  const committedHash = readOptionalKeyringHash(plan.body);\n  const keyring = response.containerKek.keyring;\n  if (committedHash === null) {\n    // A non-rotating mutation keeps its epoch, so the echoed keyring must be\n    // the immutable artifact that epoch already had. Accepting anything else\n    // would let a server null or substitute the snapshot in the response that\n    // becomes the next writer projection.\n    const expected = plan.previousKeyring ?? null;\n    if (expected === null) {\n      // The epoch had no keyring, so the response must not invent one: an\n      // injected snapshot would become the next writer projection's history.\n      if (keyring) {\n        throw new Error(\n          \"Container mutation response added a keyring to an unchanged epoch\",\n        );\n      }\n      return;\n    }\n    if (!keyring) {\n      throw new Error(\n        \"Container mutation response dropped its unchanged keyring\",\n      );\n    }\n    if (\n      (await computeContainerKekKeyringHash(keyring)) !==\n      (await computeContainerKekKeyringHash(expected))\n    ) {\n      throw new Error(\n        \"Container mutation response replaced its unchanged keyring\",\n      );\n    }\n    return;\n  }\n  if (!keyring) {\n    throw new Error(\"Container mutation response is missing its keyring\");\n  }\n  if ((await computeContainerKekKeyringHash(keyring)) !== committedHash) {\n    throw new Error(\n      \"Container mutation response keyring does not match its signed event\",\n    );\n  }\n}\n\nasync function assertResponseContent(\n  plan: AuthoredContainerMutationHead,\n  response: ContainerMutationResponse,\n): Promise<void> {\n  assertCanonicalMatch({\n    actual: response.accessManifest.event.event,\n    expected: plan.event,\n    label: \"event\",\n  });\n  assertCanonicalMatch({\n    actual: response.accessManifest.event.body,\n    expected: plan.body,\n    label: \"event body\",\n  });\n  if (response.accessManifest.event.eventHash !== plan.eventHash) {\n    throw new Error(\"Container mutation response event hash mismatch\");\n  }\n  assertCanonicalMatch({\n    actual: response.accessManifest.manifest,\n    expected: plan.manifest,\n    label: \"manifest\",\n  });\n  assertCanonicalMatch({\n    actual: response.accessManifest.state,\n    expected: plan.state,\n    label: \"state\",\n  });\n  assertCanonicalMatch({\n    actual: response.containerKek.keyEpoch,\n    expected: plan.keyEpoch,\n    label: \"key epoch\",\n  });\n  await assertAcknowledgedKeyring(plan, response);\n  assertCanonicalMatch({\n    actual: sortedCanonicalValues(response.containerKek.wraps, \"response wrap\"),\n    expected: sortedCanonicalValues(plan.wraps, \"planned wrap\"),\n    label: \"wraps\",\n  });\n  const recipientTargets = expectedRecipientTargets(plan.wraps);\n  const responseTargets = sortedCanonicalValues(\n    response.containerKek.recipientTargets,\n    \"response recipient target\",\n  );\n  assertCanonicalMatch({\n    actual: responseTargets,\n    expected: recipientTargets,\n    label: \"recipient targets\",\n  });\n  if (\n    response.containerKek.keyEpochHash !==\n      (await computeContainerKeyEpochHash(plan.keyEpoch)) ||\n    response.containerKek.keyTargetHash !==\n      (await computeContainerKekRecipientTargetHash(recipientTargets)) ||\n    response.containerKek.parentContainerKeyEpochId !==\n      plan.keyEpoch.parentContainerKeyEpochId\n  ) {\n    throw new Error(\"Container mutation response KEK commitment mismatch\");\n  }\n  assertCanonicalMatch({\n    actual: response.referencedPrincipalHeads,\n    expected: plan.manifest.referencedPrincipalHeads,\n    label: \"referenced principal heads\",\n  });\n}\n\nexport async function locallyAcknowledgedContainerMutationHead(input: {\n  readonly plan: AuthoredContainerMutationHead;\n  readonly response: ContainerMutationResponse;\n}): Promise<LocallyAcknowledgedAccessManifestHead> {\n  assertResponseIdentity(input.plan, input.response);\n  await assertResponseContent(input.plan, input.response);\n  return {\n    checkpoint: accessManifestCheckpointFromManifest({\n      manifest: input.plan.manifest,\n      manifestHash: input.plan.manifestHash,\n    }),\n    previousManifestHash: input.plan.manifest.previousManifestHash,\n  };\n}\n\n/** Correlates an API acknowledgement to the locally signed plan before pinning. */\nexport async function acknowledgeContainerMutation(input: {\n  readonly execSql: ExecSql;\n  readonly plan: AuthoredContainerMutationHead;\n  readonly response: ContainerMutationResponse;\n  readonly stillCurrent?: (() => boolean) | undefined;\n}): Promise<boolean> {\n  return advanceLocallyAcknowledgedAccessManifestHeadsAtomically({\n    execSql: input.execSql,\n    heads: [\n      await locallyAcknowledgedContainerMutationHead({\n        plan: input.plan,\n        response: input.response,\n      }),\n    ],\n    stillCurrent: input.stillCurrent,\n  });\n}\n\n/** Correlates and advances a complete authored mutation batch atomically. */\nexport async function acknowledgeContainerMutationBatch(input: {\n  readonly execSql: ExecSql;\n  readonly plans: readonly AuthoredContainerMutationHead[];\n  readonly responses: readonly ContainerMutationResponse[];\n  readonly stillCurrent?: (() => boolean) | undefined;\n}): Promise<boolean> {\n  if (input.plans.length !== input.responses.length) {\n    throw new Error(\"Container mutation acknowledgement batch is incomplete\");\n  }\n  const heads = await Promise.all(\n    input.plans.map(async (plan, index) => {\n      const response = input.responses[index];\n      if (!response) {\n        throw new Error(\n          \"Container mutation acknowledgement batch is incomplete\",\n        );\n      }\n      return locallyAcknowledgedContainerMutationHead({ plan, response });\n    }),\n  );\n  return advanceLocallyAcknowledgedAccessManifestHeadsAtomically({\n    execSql: input.execSql,\n    heads,\n    stillCurrent: input.stillCurrent,\n  });\n}\n"]}

package/data/documents/blob/shared/projection.js

@@ -1,9 +1,9 @@
 import { BLOB_CONTENT_KEY_WRAP_SUITE, wrapContentKey, } from "../../../../internal/crypto/index.js";
 import { bytesToBase64 } from "../../../../internal/encoding/index.js";
 import { documentContainerProjections } from "../../../keyingProjectionVerification/document/documentContainerProjections.js";
-import { assertDocumentKekPathsCurrent } from "../../shared/containerKekCurrency.js";
-import { readLinkedContainerIdsFromDocumentManifest, unwrapContainerKekPath, verifiedDocumentWrapTargets, } from "../../shared/projection.js";
-import { unwrapContentKeyTargetForKind } from "../../shared/projectionContentKeys.js";
+import { assertDocumentKekPathsCurrent } from "../../shared/containerKek/containerKekCurrency.js";
+import { readLinkedContainerIdsFromDocumentManifest, unwrapContainerKekPath, verifiedDocumentWrapTargets, } from "../../shared/projection/index.js";
+import { unwrapContentKeyTargetForKind } from "../../shared/projection/projectionContentKeys.js";
 import { assertEqualBytes, normalizeDocumentKekTargetResponse, } from "../../shared/readers.js";
 import { projectionVerificationOptions, } from "../../shared/types.js";
 import { sortBlobTargets } from "./readers.js";

package/data/documents/blob/shared/projection.js.map

@@ -1 +1 @@
-{"version":3,"file":"projection.js","sourceRoot":"","sources":["projection.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BLOB_CONTENT_KEY_WRAP_SUITE,\n  type DocumentContentKeyTarget,\n  wrapContentKey,\n} from \"@tearleads/crypto\";\nimport { bytesToBase64 } from \"@tearleads/encoding\";\nimport type { BlobContentKeyTargetEnvelopeRequest } from \"@tearleads/validators/request\";\nimport type {\n  BlobContentKeyBundleResponse,\n  DocumentWriterProjectionResponse,\n} from \"@tearleads/validators/response\";\nimport { documentContainerProjections } from \"../../../keyingProjectionVerification/document/documentContainerProjections\";\nimport type { ExecSql } from \"../../../sqlite/sqlSchema\";\nimport { assertDocumentKekPathsCurrent } from \"../../shared/containerKekCurrency\";\nimport {\n  readLinkedContainerIdsFromDocumentManifest,\n  unwrapContainerKekPath,\n  verifiedDocumentWrapTargets,\n} from \"../../shared/projection\";\nimport { unwrapContentKeyTargetForKind } from \"../../shared/projectionContentKeys\";\nimport {\n  assertEqualBytes,\n  normalizeDocumentKekTargetResponse,\n} from \"../../shared/readers\";\nimport {\n  type ProjectionVerificationOptions,\n  projectionVerificationOptions,\n} from \"../../shared/types\";\nimport { sortBlobTargets } from \"./readers\";\nimport type { BlobContentKeyTarget, BlobEncryptedBytesHeader } from \"./types\";\n\nfunction blobTargetsFor(\n  input: { bindingId: string; documentId: string },\n  targets: readonly DocumentContentKeyTarget[],\n): BlobContentKeyTarget[] {\n  return sortBlobTargets(\n    targets.map((target) => ({\n      bindingId: input.bindingId,\n      documentId: input.documentId,\n      ...target,\n    })),\n  );\n}\n\n/**\n * The targets a blob content key may be wrapped to: the verified current\n * heads of the document's linked containers. The server list only names which\n * containers a bundle must cover.\n */\nexport function verifiedBlobWrapTargetsFromDocumentProjection(input: {\n  bindingId: string;\n  documentId: string;\n  writerProjection: DocumentWriterProjectionResponse;\n}): BlobContentKeyTarget[] {\n  return blobTargetsFor(\n    input,\n    verifiedDocumentWrapTargets({\n      linkedContainerIds: readLinkedContainerIdsFromDocumentManifest(\n        input.writerProjection,\n      ),\n      serverTargets: normalizeDocumentKekTargetResponse(\n        input.writerProjection.documentKekTargets,\n      ),\n      writerProjection: input.writerProjection,\n    }),\n  );\n}\n\n// Not collectContainerKeksForDocumentSync: the blob upload retry classifier\n// keys on the bare \"Container writer projection KEK… could not be unwrapped\"\n// message, which the sync collector would wrap with document-sync context.\nasync function collectContainerKeks(\n  input: {\n    execSql?: ExecSql | undefined;\n    secretKey: Uint8Array;\n    writerProjection: DocumentWriterProjectionResponse;\n  } & ProjectionVerificationOptions,\n): Promise<ReadonlyMap<string, Uint8Array>> {\n  const keksByEpochId = new Map<string, Uint8Array>();\n\n  for (const projection of documentContainerProjections(\n    input.writerProjection,\n  )) {\n    const projectionKeks = await unwrapContainerKekPath({\n      execSql: input.execSql,\n      projection,\n      secretKey: input.secretKey,\n      ...projectionVerificationOptions(input),\n    });\n\n    for (const [containerKeyEpochId, keyMaterial] of projectionKeks) {\n      const existing = keksByEpochId.get(containerKeyEpochId);\n      if (existing) {\n        assertEqualBytes(\n          existing,\n          keyMaterial,\n          \"Blob writer projection contains conflicting container KEKs\",\n        );\n        continue;\n      }\n      keksByEpochId.set(containerKeyEpochId, keyMaterial);\n    }\n  }\n\n  return keksByEpochId;\n}\n\nexport async function wrapBlobContentKey(\n  input: {\n    blobId: string;\n    contentKey: Uint8Array;\n    contentKeyEpoch: number;\n    execSql?: ExecSql | undefined;\n    secretKey: Uint8Array;\n    targets: readonly BlobContentKeyTarget[];\n    writerProjection: DocumentWriterProjectionResponse;\n  } & ProjectionVerificationOptions,\n): Promise<BlobContentKeyTargetEnvelopeRequest[]> {\n  assertDocumentKekPathsCurrent(\n    input.writerProjection,\n    new Set(input.targets.map((target) => target.containerId)),\n  );\n  const keksByEpochId = await collectContainerKeks({\n    execSql: input.execSql,\n    secretKey: input.secretKey,\n    writerProjection: input.writerProjection,\n    ...projectionVerificationOptions(input),\n  });\n\n  return Promise.all(\n    input.targets.map(async (target) => {\n      const targetKek = keksByEpochId.get(target.containerKeyEpochId);\n      if (!targetKek) {\n        throw new Error(\n          `Blob target KEK could not be unwrapped for ${target.containerKeyEpochId}`,\n        );\n      }\n\n      const wrapped = await wrapContentKey(input.contentKey, targetKek, {\n        kind: \"Blob\",\n        objectId: input.blobId,\n        contentKeyEpoch: input.contentKeyEpoch,\n        containerId: target.containerId,\n        containerKeyEpochId: target.containerKeyEpochId,\n      });\n      return {\n        ...target,\n        wrappedKey: bytesToBase64(wrapped.ciphertext),\n        wrappingMetadata: {\n          suite: BLOB_CONTENT_KEY_WRAP_SUITE,\n          iv: bytesToBase64(wrapped.iv),\n        },\n      };\n    }),\n  );\n}\n\nasync function unwrapBlobContentKeyTarget(input: {\n  blobId: string;\n  containerKek: Uint8Array;\n  contentKeyEpoch: number;\n  envelope: BlobContentKeyTargetEnvelopeRequest;\n}): Promise<Uint8Array> {\n  return unwrapContentKeyTargetForKind({\n    containerKek: input.containerKek,\n    contentKeyEpoch: input.contentKeyEpoch,\n    envelope: input.envelope,\n    kind: \"Blob\",\n    objectId: input.blobId,\n  });\n}\n\nexport async function unwrapBlobContentKey(\n  input: {\n    /** The blob being read; its wraps must be sealed to it. */\n    blobId: string;\n    contentKeyBundle: BlobContentKeyBundleResponse;\n    documentId: string;\n    encrypted: BlobEncryptedBytesHeader;\n    execSql?: ExecSql | undefined;\n    expectedBindingId: string;\n    secretKey: Uint8Array;\n    writerProjection: DocumentWriterProjectionResponse;\n  } & ProjectionVerificationOptions,\n): Promise<Uint8Array> {\n  const keksByEpochId = await collectContainerKeks({\n    execSql: input.execSql,\n    secretKey: input.secretKey,\n    writerProjection: input.writerProjection,\n    ...projectionVerificationOptions(input),\n  });\n  let contentKey: Uint8Array | null = null;\n  const attachmentTargets = input.contentKeyBundle.targets.filter(\n    (envelope) =>\n      envelope.bindingId === input.expectedBindingId &&\n      envelope.documentId === input.documentId,\n  );\n\n  if (attachmentTargets.length === 0) {\n    throw new Error(\"Blob content-key bundle is missing attachment target\");\n  }\n\n  for (const envelope of attachmentTargets) {\n    const containerKek = keksByEpochId.get(envelope.containerKeyEpochId);\n    if (!containerKek) {\n      continue;\n    }\n    const unwrapped = await unwrapBlobContentKeyTarget({\n      blobId: input.blobId,\n      containerKek,\n      contentKeyEpoch: input.contentKeyBundle.contentKeyEpoch,\n      envelope,\n    });\n    if (contentKey) {\n      assertEqualBytes(\n        contentKey,\n        unwrapped,\n        \"Blob content-key targets unwrap to conflicting keys\",\n      );\n      continue;\n    }\n    contentKey = unwrapped;\n  }\n\n  if (!contentKey) {\n    throw new Error(\"Blob content key could not be unwrapped\");\n  }\n  return contentKey;\n}\n"]}
+{"version":3,"file":"projection.js","sourceRoot":"","sources":["projection.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BLOB_CONTENT_KEY_WRAP_SUITE,\n  type DocumentContentKeyTarget,\n  wrapContentKey,\n} from \"@tearleads/crypto\";\nimport { bytesToBase64 } from \"@tearleads/encoding\";\nimport type { BlobContentKeyTargetEnvelopeRequest } from \"@tearleads/validators/request\";\nimport type {\n  BlobContentKeyBundleResponse,\n  DocumentWriterProjectionResponse,\n} from \"@tearleads/validators/response\";\nimport { documentContainerProjections } from \"../../../keyingProjectionVerification/document/documentContainerProjections\";\nimport type { ExecSql } from \"../../../sqlite/sqlSchema\";\nimport { assertDocumentKekPathsCurrent } from \"../../shared/containerKek/containerKekCurrency\";\nimport {\n  readLinkedContainerIdsFromDocumentManifest,\n  unwrapContainerKekPath,\n  verifiedDocumentWrapTargets,\n} from \"../../shared/projection\";\nimport { unwrapContentKeyTargetForKind } from \"../../shared/projection/projectionContentKeys\";\nimport {\n  assertEqualBytes,\n  normalizeDocumentKekTargetResponse,\n} from \"../../shared/readers\";\nimport {\n  type ProjectionVerificationOptions,\n  projectionVerificationOptions,\n} from \"../../shared/types\";\nimport { sortBlobTargets } from \"./readers\";\nimport type { BlobContentKeyTarget, BlobEncryptedBytesHeader } from \"./types\";\n\nfunction blobTargetsFor(\n  input: { bindingId: string; documentId: string },\n  targets: readonly DocumentContentKeyTarget[],\n): BlobContentKeyTarget[] {\n  return sortBlobTargets(\n    targets.map((target) => ({\n      bindingId: input.bindingId,\n      documentId: input.documentId,\n      ...target,\n    })),\n  );\n}\n\n/**\n * The targets a blob content key may be wrapped to: the verified current\n * heads of the document's linked containers. The server list only names which\n * containers a bundle must cover.\n */\nexport function verifiedBlobWrapTargetsFromDocumentProjection(input: {\n  bindingId: string;\n  documentId: string;\n  writerProjection: DocumentWriterProjectionResponse;\n}): BlobContentKeyTarget[] {\n  return blobTargetsFor(\n    input,\n    verifiedDocumentWrapTargets({\n      linkedContainerIds: readLinkedContainerIdsFromDocumentManifest(\n        input.writerProjection,\n      ),\n      serverTargets: normalizeDocumentKekTargetResponse(\n        input.writerProjection.documentKekTargets,\n      ),\n      writerProjection: input.writerProjection,\n    }),\n  );\n}\n\n// Not collectContainerKeksForDocumentSync: the blob upload retry classifier\n// keys on the bare \"Container writer projection KEK… could not be unwrapped\"\n// message, which the sync collector would wrap with document-sync context.\nasync function collectContainerKeks(\n  input: {\n    execSql?: ExecSql | undefined;\n    secretKey: Uint8Array;\n    writerProjection: DocumentWriterProjectionResponse;\n  } & ProjectionVerificationOptions,\n): Promise<ReadonlyMap<string, Uint8Array>> {\n  const keksByEpochId = new Map<string, Uint8Array>();\n\n  for (const projection of documentContainerProjections(\n    input.writerProjection,\n  )) {\n    const projectionKeks = await unwrapContainerKekPath({\n      execSql: input.execSql,\n      projection,\n      secretKey: input.secretKey,\n      ...projectionVerificationOptions(input),\n    });\n\n    for (const [containerKeyEpochId, keyMaterial] of projectionKeks) {\n      const existing = keksByEpochId.get(containerKeyEpochId);\n      if (existing) {\n        assertEqualBytes(\n          existing,\n          keyMaterial,\n          \"Blob writer projection contains conflicting container KEKs\",\n        );\n        continue;\n      }\n      keksByEpochId.set(containerKeyEpochId, keyMaterial);\n    }\n  }\n\n  return keksByEpochId;\n}\n\nexport async function wrapBlobContentKey(\n  input: {\n    blobId: string;\n    contentKey: Uint8Array;\n    contentKeyEpoch: number;\n    execSql?: ExecSql | undefined;\n    secretKey: Uint8Array;\n    targets: readonly BlobContentKeyTarget[];\n    writerProjection: DocumentWriterProjectionResponse;\n  } & ProjectionVerificationOptions,\n): Promise<BlobContentKeyTargetEnvelopeRequest[]> {\n  assertDocumentKekPathsCurrent(\n    input.writerProjection,\n    new Set(input.targets.map((target) => target.containerId)),\n  );\n  const keksByEpochId = await collectContainerKeks({\n    execSql: input.execSql,\n    secretKey: input.secretKey,\n    writerProjection: input.writerProjection,\n    ...projectionVerificationOptions(input),\n  });\n\n  return Promise.all(\n    input.targets.map(async (target) => {\n      const targetKek = keksByEpochId.get(target.containerKeyEpochId);\n      if (!targetKek) {\n        throw new Error(\n          `Blob target KEK could not be unwrapped for ${target.containerKeyEpochId}`,\n        );\n      }\n\n      const wrapped = await wrapContentKey(input.contentKey, targetKek, {\n        kind: \"Blob\",\n        objectId: input.blobId,\n        contentKeyEpoch: input.contentKeyEpoch,\n        containerId: target.containerId,\n        containerKeyEpochId: target.containerKeyEpochId,\n      });\n      return {\n        ...target,\n        wrappedKey: bytesToBase64(wrapped.ciphertext),\n        wrappingMetadata: {\n          suite: BLOB_CONTENT_KEY_WRAP_SUITE,\n          iv: bytesToBase64(wrapped.iv),\n        },\n      };\n    }),\n  );\n}\n\nasync function unwrapBlobContentKeyTarget(input: {\n  blobId: string;\n  containerKek: Uint8Array;\n  contentKeyEpoch: number;\n  envelope: BlobContentKeyTargetEnvelopeRequest;\n}): Promise<Uint8Array> {\n  return unwrapContentKeyTargetForKind({\n    containerKek: input.containerKek,\n    contentKeyEpoch: input.contentKeyEpoch,\n    envelope: input.envelope,\n    kind: \"Blob\",\n    objectId: input.blobId,\n  });\n}\n\nexport async function unwrapBlobContentKey(\n  input: {\n    /** The blob being read; its wraps must be sealed to it. */\n    blobId: string;\n    contentKeyBundle: BlobContentKeyBundleResponse;\n    documentId: string;\n    encrypted: BlobEncryptedBytesHeader;\n    execSql?: ExecSql | undefined;\n    expectedBindingId: string;\n    secretKey: Uint8Array;\n    writerProjection: DocumentWriterProjectionResponse;\n  } & ProjectionVerificationOptions,\n): Promise<Uint8Array> {\n  const keksByEpochId = await collectContainerKeks({\n    execSql: input.execSql,\n    secretKey: input.secretKey,\n    writerProjection: input.writerProjection,\n    ...projectionVerificationOptions(input),\n  });\n  let contentKey: Uint8Array | null = null;\n  const attachmentTargets = input.contentKeyBundle.targets.filter(\n    (envelope) =>\n      envelope.bindingId === input.expectedBindingId &&\n      envelope.documentId === input.documentId,\n  );\n\n  if (attachmentTargets.length === 0) {\n    throw new Error(\"Blob content-key bundle is missing attachment target\");\n  }\n\n  for (const envelope of attachmentTargets) {\n    const containerKek = keksByEpochId.get(envelope.containerKeyEpochId);\n    if (!containerKek) {\n      continue;\n    }\n    const unwrapped = await unwrapBlobContentKeyTarget({\n      blobId: input.blobId,\n      containerKek,\n      contentKeyEpoch: input.contentKeyBundle.contentKeyEpoch,\n      envelope,\n    });\n    if (contentKey) {\n      assertEqualBytes(\n        contentKey,\n        unwrapped,\n        \"Blob content-key targets unwrap to conflicting keys\",\n      );\n      continue;\n    }\n    contentKey = unwrapped;\n  }\n\n  if (!contentKey) {\n    throw new Error(\"Blob content key could not be unwrapped\");\n  }\n  return contentKey;\n}\n"]}

package/data/documents/shared/{containerKekCurrency.d.ts → containerKek/containerKekCurrency.d.ts}

@@ -1,4 +1,4 @@
-import type { ContainerKekResponse, DocumentWriterProjectionResponse } from "../../../internal/validators/response/index.js";
+import type { ContainerKekResponse, DocumentWriterProjectionResponse } from "../../../../internal/validators/response/index.js";
 /**
  * A write path cites a retired ancestor key epoch. Retryable: this writer's
  * next sync pass, or a peer, re-keys the stale container parent-first.

package/data/documents/shared/{containerKekEntryVerification.js → containerKek/containerKekEntryVerification.js}

@@ -1,4 +1,4 @@
-import { verifyContainerKekKeyringEntry, } from "../../../internal/crypto/index.js";
+import { verifyContainerKekKeyringEntry, } from "../../../../internal/crypto/index.js";
 /** Bound outstanding key derivations and yield between batches on cold histories. */
 export async function verifyContainerKekEntries(containerId, entries) {
     const batchSize = 16;

package/data/documents/shared/{containerKekLogFetch.d.ts → containerKek/containerKekLogFetch.d.ts}

@@ -1,4 +1,4 @@
-import type { ContainerKekLogResponse } from "../../../internal/validators/response/index.js";
+import type { ContainerKekLogResponse } from "../../../../internal/validators/response/index.js";
 import type { AggregatedContainerKekLog } from "./keyringLogWalk.js";
 /**
  * Fetches the container's complete rotation log across pages. The endpoint

package/data/documents/shared/{containerKekLogFetch.js → containerKek/containerKekLogFetch.js}

@@ -1,4 +1,4 @@
-import { CONTAINER_KEK_LOG_PAGE_LIMIT, MAX_CONTAINER_KEY_EPOCH, } from "../../../internal/validators/util/index.js";
+import { CONTAINER_KEK_LOG_PAGE_LIMIT, MAX_CONTAINER_KEY_EPOCH, } from "../../../../internal/validators/util/index.js";
 /**
  * Binds one page to what was actually asked for.
  *

package/data/documents/shared/{containerKekPath.js → containerKek/containerKekPath.js}

@@ -1,9 +1,9 @@
-import { isPlainObject as isPlainRecord } from "../../../internal/validators/isPlainObject.js";
-import { unwrapKeyEnvelopesWithPrincipalPolicies } from "../../principals/principalPolicyCrypto.js";
+import { isPlainObject as isPlainRecord } from "../../../../internal/validators/isPlainObject.js";
+import { unwrapKeyEnvelopesWithPrincipalPolicies } from "../../../principals/principalPolicyCrypto.js";
+import { normalizeContainerKeyWrap, readManifestContainerId, readRecordNullableString, readRecordPositiveInteger, readRecordString, } from "../readers.js";
 import { assertUnwrappedContainerKekMatchesMaterialId, projectedUnreachablePredecessorEpochIds, projectionKekLabel, unwrapKeyringContainerKeksAtIndex, } from "./containerKekPathHistory.js";
 import { verifyContainerKekPathProjection, } from "./containerKekPathVerification.js";
 import { assertSignedWrappingPublicKey, unwrapContainerKekFromParentWrap, } from "./containerKekWrapping.js";
-import { normalizeContainerKeyWrap, readManifestContainerId, readRecordNullableString, readRecordPositiveInteger, readRecordString, } from "./readers.js";
 function assertProjectionKekMatchesPath(projection, index) {
     const manifest = projection.path[index];
     const kek = projection.containerKeks[index];

package/data/documents/shared/containerKek/containerKekPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containerKekPath.js","sourceRoot":"","sources":["containerKekPath.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,IAAI,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAErF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAEpG,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,4CAA4C,EAC5C,uCAAuC,EACvC,kBAAkB,EAClB,iCAAiC,GAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,gCAAgC,GACjC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,6BAA6B,EAC7B,gCAAgC,GACjC,MAAM,wBAAwB,CAAC;AAEhC,SAAS,8BAA8B,CACrC,UAA6C,EAC7C,KAAa;IAEb,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,MAAM,GAAG,GAAG,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5C,IAAI,CAAC,QAAQ,IAAI,CAAC,GAAG,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IAC9E,CAAC;IACD,IAAI,uBAAuB,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,WAAW,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,GAAG,CAAC,kBAAkB,KAAK,QAAQ,CAAC,YAAY,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;IACpE,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACvE,CAAC;IACD,IACE,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC7D,GAAG,CAAC,mBAAmB;QACzB,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,aAAa,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC;YACtE,GAAG,CAAC,WAAW;QACjB,yBAAyB,CACvB,GAAG,CAAC,QAAQ,EACZ,UAAU,EACV,kBAAkB,CAAC,KAAK,CAAC,CAC1B,KAAK,GAAG,CAAC,iBAAiB;QAC3B,wBAAwB,CACtB,GAAG,CAAC,QAAQ,EACZ,2BAA2B,EAC3B,kBAAkB,CAAC,KAAK,CAAC,CAC1B,KAAK,GAAG,CAAC,yBAAyB,EACnC,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC;AAED,KAAK,UAAU,oCAAoC,CAAC,KAInD;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK;SAC1B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,KAAK,WAAW,CAAC;SACpD,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACd,cAAc,EAAE,IAAI,CAAC,uBAAuB;QAC5C,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,UAAU,EAAE,IAAI,CAAC,UAAU;KAC5B,CAAC,CAAC,CAAC;IACN,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,OAAO,MAAM,uCAAuC,CAAC;YACnD,SAAS;YACT,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,SAAS,EAAE,KAAK,CAAC,SAAS;SAC3B,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,KAAK,UAAU,sBAAsB,CAAC,KAGrC;IACC,MAAM,aAAa,GAAG,IAAI,GAAG,EAAiC,CAAC;IAE/D,KAAK,MAAM,CAAC,mBAAmB,EAAE,WAAW,CAAC,IAAI,KAAK,CAAC,kBAAkB;QACvE,IAAI,GAAG,EAAsB,EAAE,CAAC;QAChC,MAAM,SAAS,GAAG,yBAAyB,CACzC,KAAK,CAAC,UAAU,EAChB,mBAAmB,CACpB,CAAC;QACF,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,SAAS;QACX,CAAC;QACD,MAAM,4CAA4C,CAAC;YACjD,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,GAAG,EAAE,SAAS,CAAC,GAAG;YAClB,WAAW;SACZ,CAAC,CAAC;QACH,MAAM,6BAA6B,CACjC,KAAK,CAAC,UAAU,EAChB,SAAS,CAAC,KAAK,EACf,WAAW,CACZ,CAAC;QACF,aAAa,CAAC,GAAG,CAAC,mBAAmB,EAAE;YACrC,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,WAAW;YACtC,YAAY,EAAE,SAAS,CAAC,GAAG,CAAC,YAAY;YACxC,WAAW;SACZ,CAAC,CAAC;IACL,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,SAAS,yBAAyB,CAChC,UAA6C,EAC7C,mBAA2B;IAE3B,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,UAAU,CAAC,aAAa,CAAC,OAAO,EAAE,EAAE,CAAC;QAClE,IAAI,OAAO,CAAC,mBAAmB,KAAK,mBAAmB,EAAE,CAAC;YACxD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;QACnE,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,oBAAoB,CAC3B,aAAyD,EACzD,GAGC,EACD,SAA4B;IAE5B,OAAO,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,CAAC,EAAE,WAAW,IAAI,SAAS,CAAC;AAC9E,CAAC;AAED,KAAK,UAAU,yBAAyB,CAAC,KAQxC;IAKC,8BAA8B,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAC9D,MAAM,GAAG,GAAG,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACxD,MAAM,eAAe,GAAG,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3D,IAAI,CAAC,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,KAAK,GAAuB,EAAE,CAAC;IACrC,KAAK,MAAM,OAAO,IAAI,GAAG,CAAC,KAAK,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,IAAI,CAAC,mBAAmB,KAAK,GAAG,CAAC,mBAAmB,EAAE,CAAC;YACzD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC9E,CAAC;IAED,MAAM,SAAS,GACb,CAAC,MAAM,oCAAoC,CAAC;QAC1C,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,KAAK;KACN,CAAC,CAAC;QACH,CAAC,MAAM,gCAAgC,CAAC;YACtC,KAAK,EAAE,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAAC;YACtC,yBAAyB,EAAE,GAAG,CAAC,yBAAyB;YACxD,mBAAmB,EAAE,KAAK,CAAC,aAAa;YACxC,KAAK;SACN,CAAC,CAAC,CAAC;IAEN,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,4CAA4C,CAAC;YACjD,KAAK,EAAE,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAAC;YACtC,GAAG;YACH,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;QACH,MAAM,6BAA6B,CACjC,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,KAAK,EACX,SAAS,CACV,CAAC;QACF,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,EAAE;YAC/C,WAAW,EAAE,GAAG,CAAC,WAAW;YAC5B,YAAY,EAAE,GAAG,CAAC,YAAY;YAC9B,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC;QACH,wEAAwE;QACxE,oDAAoD;QACpD,MAAM,iCAAiC,CAAC;YACtC,eAAe;YACf,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,GAAG;YACH,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,oBAAoB,EAAE,oBAAoB,CACxC,KAAK,CAAC,aAAa,EACnB,GAAG,EACH,SAAS,CACV;YACD,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,uBAAuB,EAAE,KAAK,CAAC,sBAAsB;SACtD,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,uEAAuE;QACvE,iEAAiE;QACjE,qEAAqE;QACrE,gCAAgC;QAChC,OAAO;YACL,WAAW,EAAE,GAAG,CAAC,WAAW;YAC5B,KAAK,EACH,KAAK,YAAY,KAAK;gBACpB,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC,IAAI,KAAK,CAAC,2CAA2C,EAAE;oBACrD,KAAK,EAAE,KAAK;iBACb,CAAC;YACR,mBAAmB,EAAE,uCAAuC,CAAC;gBAC3D,GAAG;gBACH,aAAa,EAAE,KAAK,CAAC,aAAa;aACnC,CAAC;SACH,CAAC;IACJ,CAAC;AACH,CAAC;AAWD,SAAS,wBAAwB,CAC/B,iBAAqC,EACrC,iCAAqD,EACrD,OAA2E;IAE3E,IAAI,OAAO,CAAC,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7C,IAAI,CAAC,iCAAiC,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;YAChE,iCAAiC,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5E,CAAC;QACD,OAAO;IACT,CAAC;IACD,KAAK,MAAM,mBAAmB,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;QAC9D,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,mBAAmB,CAAC,EAAE,CAAC;YAChD,iBAAiB,CAAC,GAAG,CAAC,mBAAmB,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,OAAO,kCAAmC,SAAQ,KAAK;IAEhD;IADX,YACW,WAAmB,EAC5B,KAAa;QAEb,KAAK,CAAC,GAAG,KAAK,yBAAyB,CAAC,CAAC;QAHhC,gBAAW,GAAX,WAAW,CAAQ;QAI5B,IAAI,CAAC,IAAI,GAAG,oCAAoC,CAAC;IACnD,CAAC;CACF;AAED,SAAS,wBAAwB,CAAC,KAQjC;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,IACE,CAAC,SAAS;QACV,KAAK,CAAC,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,mBAAmB,CAAC,EAC7D,CAAC;QACD,OAAO;IACT,CAAC;IACD,KACE,IAAI,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EACrD,KAAK,IAAI,CAAC,EACV,KAAK,IAAI,CAAC,EACV,CAAC;QACD,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACtD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,SAAS;QACX,CAAC;QACD,MAAM,kBAAkB,GACtB,KAAK,CAAC,4BAA4B,CAAC,GAAG,CAAC,OAAO,CAAC,mBAAmB,CAAC;YACnE,CAAC,OAAO,CAAC,yBAAyB;gBAChC,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC,GAAG,CACpC,OAAO,CAAC,yBAAyB,CAClC;gBACH,CAAC,CAAC,SAAS,CAAC;YACd,KAAK,CAAC,4CAA4C,CAAC,GAAG,CACpD,OAAO,CAAC,WAAW,CACpB,CAAC;QACJ,IAAI,kBAAkB,EAAE,CAAC;YACvB,MAAM,kBAAkB,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,MAAM,IAAI,kCAAkC,CAC1C,SAAS,CAAC,WAAW,EACrB,kBAAkB,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAC9D,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,yCAAyC,CAC7D,QAAqC;IAErC,qEAAqE;IACrE,MAAM,KAAK,GAAG;QACZ,GAAG,QAAQ;QACX,cAAc,EACZ,QAAQ,CAAC,cAAc;YACvB,IAAI,GAAG,EAA2C;KACrD,CAAC;IACF,MAAM,gCAAgC,CAAC,KAAK,CAAC,CAAC;IAE9C,MAAM,aAAa,GAAG,MAAM,sBAAsB,CAAC;QACjD,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;QAC5C,UAAU,EAAE,KAAK,CAAC,UAAU;KAC7B,CAAC,CAAC;IACH,MAAM,4BAA4B,GAAG,IAAI,GAAG,EAAiB,CAAC;IAC9D,MAAM,4CAA4C,GAAG,IAAI,GAAG,EAAiB,CAAC;IAE9E,KACE,IAAI,KAAK,GAAG,CAAC,EACb,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,EAC7C,KAAK,IAAI,CAAC,EACV,CAAC;QACD,MAAM,cAAc,GAAG,MAAM,yBAAyB,CAAC;YACrD,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,KAAK;YACL,aAAa;YACb,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,sBAAsB,EAAE,KAAK,CAAC,sBAAsB,KAAK,IAAI;SAC9D,CAAC,CAAC;QACH,IAAI,cAAc,EAAE,CAAC;YACnB,wBAAwB,CACtB,4BAA4B,EAC5B,4CAA4C,EAC5C,cAAc,CACf,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,oBAAoB,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC3D,KAAK,MAAM,CAAC,mBAAmB,EAAE,GAAG,CAAC,IAAI,aAAa,EAAE,CAAC;QACvD,oBAAoB,CAAC,GAAG,CAAC,mBAAmB,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC;IACjE,CAAC;IACD,wBAAwB,CAAC;QACvB,oBAAoB;QACpB,4BAA4B;QAC5B,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,4CAA4C;KAC7C,CAAC,CAAC;IACH,OAAO;QACL,aAAa,EAAE,oBAAoB;QACnC,4BAA4B;QAC5B,4CAA4C;KAC7C,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,KAAkC;IAElC,OAAO,CAAC,MAAM,yCAAyC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC;AAChF,CAAC","sourcesContent":["import type {\n  ContainerKeyWrap,\n  VerifiedContainerAccessManifest,\n} from \"@tearleads/crypto\";\nimport { isPlainObject as isPlainRecord } from \"@tearleads/validators/isPlainObject\";\nimport type { ContainerWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { unwrapKeyEnvelopesWithPrincipalPolicies } from \"../../../principals/principalPolicyCrypto\";\nimport type { ExecSql } from \"../../../sqlite/sqlSchema\";\nimport {\n  normalizeContainerKeyWrap,\n  readManifestContainerId,\n  readRecordNullableString,\n  readRecordPositiveInteger,\n  readRecordString,\n} from \"../readers\";\nimport type { UnwrappedContainerKek } from \"../types\";\nimport {\n  assertUnwrappedContainerKekMatchesMaterialId,\n  projectedUnreachablePredecessorEpochIds,\n  projectionKekLabel,\n  unwrapKeyringContainerKeksAtIndex,\n} from \"./containerKekPathHistory\";\nimport {\n  type UnwrapContainerKekPathInput,\n  verifyContainerKekPathProjection,\n} from \"./containerKekPathVerification\";\nimport {\n  assertSignedWrappingPublicKey,\n  unwrapContainerKekFromParentWrap,\n} from \"./containerKekWrapping\";\n\nfunction assertProjectionKekMatchesPath(\n  projection: ContainerWriterProjectionResponse,\n  index: number,\n): void {\n  const manifest = projection.path[index];\n  const kek = projection.containerKeks[index];\n  if (!manifest || !kek) {\n    throw new Error(\"Container writer projection path and KEKs are incomplete\");\n  }\n  if (readManifestContainerId(manifest) !== kek.containerId) {\n    throw new Error(`${projectionKekLabel(index)} container is inconsistent`);\n  }\n  if (kek.accessManifestHash !== manifest.manifestHash) {\n    throw new Error(`${projectionKekLabel(index)} manifest is stale`);\n  }\n  if (!isPlainRecord(kek.keyEpoch)) {\n    throw new Error(`${projectionKekLabel(index)} key epoch is invalid`);\n  }\n  if (\n    readRecordString(kek.keyEpoch, \"id\", projectionKekLabel(index)) !==\n      kek.containerKeyEpochId ||\n    readRecordString(kek.keyEpoch, \"containerId\", projectionKekLabel(index)) !==\n      kek.containerId ||\n    readRecordPositiveInteger(\n      kek.keyEpoch,\n      \"keyEpoch\",\n      projectionKekLabel(index),\n    ) !== kek.containerKeyEpoch ||\n    readRecordNullableString(\n      kek.keyEpoch,\n      \"parentContainerKeyEpochId\",\n      projectionKekLabel(index),\n    ) !== kek.parentContainerKeyEpochId\n  ) {\n    throw new Error(`${projectionKekLabel(index)} key epoch is inconsistent`);\n  }\n}\n\nasync function unwrapContainerKekFromPrincipalWraps(input: {\n  execSql?: ExecSql | undefined;\n  secretKey: Uint8Array;\n  wraps: readonly ContainerKeyWrap[];\n}): Promise<Uint8Array | null> {\n  const envelopes = input.wraps\n    .filter((wrap) => wrap.recipientKind !== \"container\")\n    .map((wrap) => ({\n      keyFingerprint: wrap.recipientKeyFingerprint,\n      kemCipherText: wrap.kemCipherText,\n      wrappedKey: wrap.wrappedKey,\n    }));\n  if (envelopes.length === 0) {\n    return null;\n  }\n\n  try {\n    return await unwrapKeyEnvelopesWithPrincipalPolicies({\n      envelopes,\n      execSql: input.execSql,\n      secretKey: input.secretKey,\n    });\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Admits caller-supplied keys that the projection also names.\n *\n * The projection match is deliberate: a seeded key is trusted only once its\n * epoch is one this projection actually carries, which is what makes the\n * material-id check below meaningful. Production seeds this with the epoch it\n * just minted (see `registerIdentity`), never with recovered history — history\n * arrives through the sealed keyring on each path instead, and is shared across\n * authorizing paths through the common `keksByEpochId` map.\n */\nasync function seedKnownContainerKeks(input: {\n  knownContainerKeks?: ReadonlyMap<string, Uint8Array> | undefined;\n  projection: ContainerWriterProjectionResponse;\n}): Promise<Map<string, UnwrappedContainerKek>> {\n  const keksByEpochId = new Map<string, UnwrappedContainerKek>();\n\n  for (const [containerKeyEpochId, keyMaterial] of input.knownContainerKeks ??\n    new Map<string, Uint8Array>()) {\n    const projected = findProjectedContainerKek(\n      input.projection,\n      containerKeyEpochId,\n    );\n    if (!projected) {\n      continue;\n    }\n    await assertUnwrappedContainerKekMatchesMaterialId({\n      label: projected.label,\n      kek: projected.kek,\n      keyMaterial,\n    });\n    await assertSignedWrappingPublicKey(\n      input.projection,\n      projected.index,\n      keyMaterial,\n    );\n    keksByEpochId.set(containerKeyEpochId, {\n      containerId: projected.kek.containerId,\n      keyEpochHash: projected.kek.keyEpochHash,\n      keyMaterial,\n    });\n  }\n\n  return keksByEpochId;\n}\n\nfunction findProjectedContainerKek(\n  projection: ContainerWriterProjectionResponse,\n  containerKeyEpochId: string,\n) {\n  for (const [index, current] of projection.containerKeks.entries()) {\n    if (current.containerKeyEpochId === containerKeyEpochId) {\n      return { index, kek: current, label: projectionKekLabel(index) };\n    }\n  }\n  return null;\n}\n\nfunction successorKeyMaterial(\n  keksByEpochId: ReadonlyMap<string, UnwrappedContainerKek>,\n  kek: Pick<\n    ContainerWriterProjectionResponse[\"containerKeks\"][number],\n    \"containerKeyEpochId\"\n  >,\n  unwrapped: Uint8Array | null,\n): Uint8Array | null {\n  return keksByEpochId.get(kek.containerKeyEpochId)?.keyMaterial ?? unwrapped;\n}\n\nasync function unwrapContainerKekAtIndex(input: {\n  readonly execSql?: ExecSql | undefined;\n  readonly index: number;\n  readonly keksByEpochId: Map<string, UnwrappedContainerKek>;\n  readonly projection: ContainerWriterProjectionResponse;\n  readonly secretKey: Uint8Array;\n  readonly verifiedByHash: ReadonlyMap<string, VerifiedContainerAccessManifest>;\n  readonly verifyBridgeCommitment: boolean;\n}): Promise<{\n  readonly containerId: string;\n  readonly error: Error;\n  readonly unreachableEpochIds: readonly string[];\n} | null> {\n  assertProjectionKekMatchesPath(input.projection, input.index);\n  const kek = input.projection.containerKeks[input.index];\n  const currentManifest = input.projection.path[input.index];\n  if (!kek || !currentManifest) {\n    throw new Error(`${projectionKekLabel(input.index)} is missing`);\n  }\n\n  const wraps: ContainerKeyWrap[] = [];\n  for (const rawWrap of kek.wraps) {\n    const wrap = normalizeContainerKeyWrap(rawWrap);\n    if (wrap.containerKeyEpochId === kek.containerKeyEpochId) {\n      wraps.push(wrap);\n    }\n  }\n  if (wraps.length !== kek.wraps.length) {\n    throw new Error(`${projectionKekLabel(input.index)} contains a stale wrap`);\n  }\n\n  const unwrapped =\n    (await unwrapContainerKekFromPrincipalWraps({\n      execSql: input.execSql,\n      secretKey: input.secretKey,\n      wraps,\n    })) ??\n    (await unwrapContainerKekFromParentWrap({\n      label: projectionKekLabel(input.index),\n      parentContainerKeyEpochId: kek.parentContainerKeyEpochId,\n      parentKeksByEpochId: input.keksByEpochId,\n      wraps,\n    }));\n\n  if (unwrapped) {\n    await assertUnwrappedContainerKekMatchesMaterialId({\n      label: projectionKekLabel(input.index),\n      kek,\n      keyMaterial: unwrapped,\n    });\n    await assertSignedWrappingPublicKey(\n      input.projection,\n      input.index,\n      unwrapped,\n    );\n    input.keksByEpochId.set(kek.containerKeyEpochId, {\n      containerId: kek.containerId,\n      keyEpochHash: kek.keyEpochHash,\n      keyMaterial: unwrapped,\n    });\n  }\n\n  try {\n    // Open the keyring immediately so descendants pinned to an older parent\n    // epoch can still unwrap during the same path walk.\n    await unwrapKeyringContainerKeksAtIndex({\n      currentManifest,\n      index: input.index,\n      kek,\n      keksByEpochId: input.keksByEpochId,\n      successorKeyMaterial: successorKeyMaterial(\n        input.keksByEpochId,\n        kek,\n        unwrapped,\n      ),\n      verifiedByHash: input.verifiedByHash,\n      verifyKeyringCommitment: input.verifyBridgeCommitment,\n    });\n    return null;\n  } catch (error) {\n    // Historical keyring damage must not discard an independently verified\n    // current KEK. If the target still cannot be reached, the caller\n    // surfaces this integrity error; the bridge log remains the recovery\n    // path for the orphaned epochs.\n    return {\n      containerId: kek.containerId,\n      error:\n        error instanceof Error\n          ? error\n          : new Error(\"Container predecessor KEK recovery failed\", {\n              cause: error,\n            }),\n      unreachableEpochIds: projectedUnreachablePredecessorEpochIds({\n        kek,\n        keksByEpochId: input.keksByEpochId,\n      }),\n    };\n  }\n}\n\ninterface UnwrappedContainerKekPathResult {\n  readonly keksByEpochId: ReadonlyMap<string, Uint8Array>;\n  readonly predecessorFailuresByEpochId: ReadonlyMap<string, Error>;\n  readonly unattributedPredecessorFailuresByContainerId: ReadonlyMap<\n    string,\n    Error\n  >;\n}\n\nfunction recordPredecessorFailure(\n  failuresByEpochId: Map<string, Error>,\n  unattributedFailuresByContainerId: Map<string, Error>,\n  failure: NonNullable<Awaited<ReturnType<typeof unwrapContainerKekAtIndex>>>,\n): void {\n  if (failure.unreachableEpochIds.length === 0) {\n    if (!unattributedFailuresByContainerId.has(failure.containerId)) {\n      unattributedFailuresByContainerId.set(failure.containerId, failure.error);\n    }\n    return;\n  }\n  for (const containerKeyEpochId of failure.unreachableEpochIds) {\n    if (!failuresByEpochId.has(containerKeyEpochId)) {\n      failuresByEpochId.set(containerKeyEpochId, failure.error);\n    }\n  }\n}\n\n/**\n * No wrap on the path opens the target for this reader, and no recorded\n * history failure explains it: the reader simply holds no key here. Distinct\n * from keyring damage, which rethrows the underlying integrity error instead.\n */\nexport class ContainerKekTargetUnreachableError extends Error {\n  constructor(\n    readonly containerId: string,\n    label: string,\n  ) {\n    super(`${label} could not be unwrapped`);\n    this.name = \"ContainerKekTargetUnreachableError\";\n  }\n}\n\nfunction assertTargetKekUnwrapped(input: {\n  readonly keyMaterialByEpochId: ReadonlyMap<string, Uint8Array>;\n  readonly predecessorFailuresByEpochId: ReadonlyMap<string, Error>;\n  readonly projection: ContainerWriterProjectionResponse;\n  readonly unattributedPredecessorFailuresByContainerId: ReadonlyMap<\n    string,\n    Error\n  >;\n}): void {\n  const targetKek = input.projection.containerKeks.at(-1);\n  if (\n    !targetKek ||\n    input.keyMaterialByEpochId.has(targetKek.containerKeyEpochId)\n  ) {\n    return;\n  }\n  for (\n    let index = input.projection.containerKeks.length - 1;\n    index >= 0;\n    index -= 1\n  ) {\n    const pathKek = input.projection.containerKeks[index];\n    if (!pathKek) {\n      continue;\n    }\n    const predecessorFailure =\n      input.predecessorFailuresByEpochId.get(pathKek.containerKeyEpochId) ??\n      (pathKek.parentContainerKeyEpochId\n        ? input.predecessorFailuresByEpochId.get(\n            pathKek.parentContainerKeyEpochId,\n          )\n        : undefined) ??\n      input.unattributedPredecessorFailuresByContainerId.get(\n        pathKek.containerId,\n      );\n    if (predecessorFailure) {\n      throw predecessorFailure;\n    }\n  }\n  throw new ContainerKekTargetUnreachableError(\n    targetKek.containerId,\n    projectionKekLabel(input.projection.containerKeks.length - 1),\n  );\n}\n\nexport async function unwrapContainerKekPathWithHistoryFailures(\n  rawInput: UnwrapContainerKekPathInput,\n): Promise<UnwrappedContainerKekPathResult> {\n  // Kept for the keyring checks, which anchor to the verified lineage.\n  const input = {\n    ...rawInput,\n    verifiedByHash:\n      rawInput.verifiedByHash ??\n      new Map<string, VerifiedContainerAccessManifest>(),\n  };\n  await verifyContainerKekPathProjection(input);\n\n  const keksByEpochId = await seedKnownContainerKeks({\n    knownContainerKeks: input.knownContainerKeks,\n    projection: input.projection,\n  });\n  const predecessorFailuresByEpochId = new Map<string, Error>();\n  const unattributedPredecessorFailuresByContainerId = new Map<string, Error>();\n\n  for (\n    let index = 0;\n    index < input.projection.containerKeks.length;\n    index += 1\n  ) {\n    const currentFailure = await unwrapContainerKekAtIndex({\n      execSql: input.execSql,\n      index,\n      keksByEpochId,\n      projection: input.projection,\n      secretKey: input.secretKey,\n      verifiedByHash: input.verifiedByHash,\n      verifyBridgeCommitment: input.trustedLocalProjection !== true,\n    });\n    if (currentFailure) {\n      recordPredecessorFailure(\n        predecessorFailuresByEpochId,\n        unattributedPredecessorFailuresByContainerId,\n        currentFailure,\n      );\n    }\n  }\n\n  const keyMaterialByEpochId = new Map<string, Uint8Array>();\n  for (const [containerKeyEpochId, kek] of keksByEpochId) {\n    keyMaterialByEpochId.set(containerKeyEpochId, kek.keyMaterial);\n  }\n  assertTargetKekUnwrapped({\n    keyMaterialByEpochId,\n    predecessorFailuresByEpochId,\n    projection: input.projection,\n    unattributedPredecessorFailuresByContainerId,\n  });\n  return {\n    keksByEpochId: keyMaterialByEpochId,\n    predecessorFailuresByEpochId,\n    unattributedPredecessorFailuresByContainerId,\n  };\n}\n\nexport async function unwrapContainerKekPath(\n  input: UnwrapContainerKekPathInput,\n): Promise<ReadonlyMap<string, Uint8Array>> {\n  return (await unwrapContainerKekPathWithHistoryFailures(input)).keksByEpochId;\n}\n"]}

package/data/documents/shared/{containerKekPathHistory.d.ts → containerKek/containerKekPathHistory.d.ts}

@@ -1,6 +1,6 @@
-import { type VerifiedContainerAccessManifest } from "../../../internal/crypto/index.js";
-import type { ContainerWriterProjectionResponse } from "../../../internal/validators/response/index.js";
-import type { UnwrappedContainerKek } from "./types.js";
+import { type VerifiedContainerAccessManifest } from "../../../../internal/crypto/index.js";
+import type { ContainerWriterProjectionResponse } from "../../../../internal/validators/response/index.js";
+import type { UnwrappedContainerKek } from "../types.js";
 type ProjectionKek = ContainerWriterProjectionResponse["containerKeks"][number];
 type VerifiedManifests = ReadonlyMap<string, VerifiedContainerAccessManifest>;
 /** The projection proves a predecessor existed, but no retained keyring can recover it. */

package/data/documents/shared/{containerKekPathHistory.js → containerKek/containerKekPathHistory.js}

@@ -1,8 +1,8 @@
-import { computeContainerKekKeyringHash, computeContainerKekMaterialId, isContainerKekMaterialId, KeyingVerificationError, normalizeContainerAccessEventBody, normalizeContainerKekKeyring, openContainerKekKeyring, } from "../../../internal/crypto/index.js";
-import { readCanonicalJson, readCanonicalRecord, } from "../../keying/canonicalJson.js";
-import { readContainerKeyEpoch } from "../../keyingProjectionVerification/readers.js";
+import { computeContainerKekKeyringHash, computeContainerKekMaterialId, isContainerKekMaterialId, KeyingVerificationError, normalizeContainerAccessEventBody, normalizeContainerKekKeyring, openContainerKekKeyring, } from "../../../../internal/crypto/index.js";
+import { readCanonicalJson, readCanonicalRecord, } from "../../../keying/canonicalJson.js";
+import { readContainerKeyEpoch } from "../../../keyingProjectionVerification/readers.js";
+import { readManifestContainerId } from "../readers.js";
 import { verifyContainerKekEntries } from "./containerKekEntryVerification.js";
-import { readManifestContainerId } from "./readers.js";
 /** The projection proves a predecessor existed, but no retained keyring can recover it. */
 export class ContainerKekHistoryUnavailableError extends Error {
     constructor(label) {

package/data/documents/shared/containerKek/containerKekPathHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containerKekPathHistory.js","sourceRoot":"","sources":["containerKekPathHistory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  computeContainerKekKeyringHash,\n  computeContainerKekMaterialId,\n  isContainerKekMaterialId,\n  KeyingVerificationError,\n  normalizeContainerAccessEventBody,\n  normalizeContainerKekKeyring,\n  openContainerKekKeyring,\n  type VerifiedContainerAccessManifest,\n} from \"@tearleads/crypto\";\nimport type { ContainerWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport {\n  readCanonicalJson,\n  readCanonicalRecord,\n} from \"../../../keying/canonicalJson\";\nimport { readContainerKeyEpoch } from \"../../../keyingProjectionVerification/readers\";\nimport { readManifestContainerId } from \"../readers\";\nimport type { UnwrappedContainerKek } from \"../types\";\nimport { verifyContainerKekEntries } from \"./containerKekEntryVerification\";\n\ntype ProjectionKek = ContainerWriterProjectionResponse[\"containerKeks\"][number];\ntype VerifiedManifests = ReadonlyMap<string, VerifiedContainerAccessManifest>;\n\n/** The projection proves a predecessor existed, but no retained keyring can recover it. */\nexport class ContainerKekHistoryUnavailableError extends Error {\n  constructor(label: string) {\n    super(`${label} keyring is missing`);\n    this.name = \"ContainerKekHistoryUnavailableError\";\n  }\n}\n\nexport function projectionKekLabel(index: number): string {\n  return `Container writer projection KEK[${index}]`;\n}\n\nexport async function assertUnwrappedContainerKekMatchesMaterialId(input: {\n  label: string;\n  keyMaterial: Uint8Array;\n  kek: Pick<\n    ProjectionKek,\n    \"containerId\" | \"containerKeyEpoch\" | \"containerKeyEpochId\"\n  >;\n}): Promise<void> {\n  if (!isContainerKekMaterialId(input.kek.containerKeyEpochId)) {\n    throw new Error(\n      `${input.label} KEK epoch id does not commit to key material`,\n    );\n  }\n  const expectedId = await computeContainerKekMaterialId({\n    containerId: input.kek.containerId,\n    keyEpoch: input.kek.containerKeyEpoch,\n    keyMaterial: input.keyMaterial,\n  });\n  if (expectedId !== input.kek.containerKeyEpochId) {\n    throw new Error(\n      `${input.label} KEK material does not match committed epoch id`,\n    );\n  }\n}\n\nfunction sameContainerManifestHistory(kek: ProjectionKek) {\n  return kek.containerManifestHistory.filter(\n    (bundle) => readManifestContainerId(bundle) === kek.containerId,\n  );\n}\n\n/**\n * Proves the served keyring is the one the rotation that minted the current\n * epoch committed to in its signed event body.\n */\nasync function assertKeyringCommitment(input: {\n  currentManifest: ContainerWriterProjectionResponse[\"path\"][number];\n  index: number;\n  kek: ProjectionKek;\n  keyring: ReturnType<typeof normalizeContainerKekKeyring>;\n}): Promise<void> {\n  const rotationManifestHash = readContainerKeyEpoch(\n    input.kek.keyEpoch,\n    `${projectionKekLabel(input.index)} key epoch`,\n  ).accessManifestHash;\n  const rotationManifest =\n    rotationManifestHash === input.currentManifest.manifestHash\n      ? input.currentManifest\n      : sameContainerManifestHistory(input.kek).find(\n          (bundle) => bundle.manifestHash === rotationManifestHash,\n        );\n  if (!rotationManifest) {\n    throw new Error(\n      `${projectionKekLabel(input.index)} keyring signer is missing`,\n    );\n  }\n  const eventBundle = readCanonicalRecord(\n    rotationManifest.event,\n    `${projectionKekLabel(input.index)} keyring event`,\n  );\n  const eventBody = normalizeContainerAccessEventBody(\n    readCanonicalJson(\n      Reflect.get(eventBundle, \"body\"),\n      `${projectionKekLabel(input.index)} keyring event body`,\n    ),\n  );\n  if (\n    (eventBody.eventType !== \"container.move\" &&\n      eventBody.eventType !== \"container.rekey\" &&\n      eventBody.eventType !== \"container.revoke\") ||\n    eventBody.keyringHash !==\n      (await computeContainerKekKeyringHash(input.keyring))\n  ) {\n    throw new Error(\n      `${projectionKekLabel(input.index)} keyring does not match its signed event`,\n    );\n  }\n}\n\nasync function openVerifiedKeyringEntries(input: {\n  currentManifest: ContainerWriterProjectionResponse[\"path\"][number];\n  index: number;\n  kek: ProjectionKek;\n  successorKeyMaterial: Uint8Array;\n  verifiedByHash: VerifiedManifests;\n  verifyKeyringCommitment: boolean;\n}): Promise<Awaited<ReturnType<typeof openContainerKekKeyring>>> {\n  const { kek } = input;\n  const keyring = normalizeContainerKekKeyring(kek.keyring);\n  if (\n    keyring.containerId !== kek.containerId ||\n    keyring.containerKeyEpochId !== kek.containerKeyEpochId\n  ) {\n    throw new Error(\n      `${projectionKekLabel(input.index)} keyring is inconsistent`,\n    );\n  }\n  if (input.verifyKeyringCommitment) {\n    await assertKeyringCommitment({\n      currentManifest: input.currentManifest,\n      index: input.index,\n      kek,\n      keyring,\n    });\n  }\n\n  let entries: Awaited<ReturnType<typeof openContainerKekKeyring>>;\n  try {\n    entries = await openContainerKekKeyring({\n      keyEpoch: kek.containerKeyEpoch,\n      keyring,\n      successorContainerKey: input.successorKeyMaterial,\n    });\n  } catch (error) {\n    if (error instanceof KeyingVerificationError) {\n      throw error;\n    }\n    // Label opaque AEAD failures; structural verification errors already\n    // carry their own diagnosis.\n    throw new Error(\n      `${projectionKekLabel(input.index)} keyring could not be opened`,\n      { cause: error },\n    );\n  }\n  // Per-entry material-id verification proves an entry's key matches the id\n  // it declares, but a poisoned keyring can declare a self-consistent FAKE\n  // id — fresh key, matching commitment — for an epoch the container never\n  // had. Anchor every entry the projection can name to the epoch id its\n  // signed history actually committed; anything else is a forged epoch.\n  await verifyContainerKekEntries(kek.containerId, entries);\n\n  // Every epoch id the signed manifest history names must be present in the\n  // keyring. A forged entry can be self-consistent, but it cannot also make\n  // the real epoch id — which a signed state already named — disappear.\n  const entryEpochIds = new Set(\n    entries.map((entry) => entry.containerKeyEpochId),\n  );\n  const signedEpochIds = signedHistoryEpochIds({\n    headManifestHash: input.currentManifest.manifestHash,\n    kek,\n    verifiedByHash: input.verifiedByHash,\n  });\n  for (const historicalEpochId of signedEpochIds) {\n    if (!entryEpochIds.has(historicalEpochId)) {\n      throw new KeyingVerificationError(\n        \"missing_dependency\",\n        `${projectionKekLabel(input.index)} keyring omits an epoch its manifest history commits to`,\n      );\n    }\n  }\n  return entries;\n}\n\n/**\n * Epoch ids named by verified historical manifest states for this container.\n * Those states are signed, so an id they name is an epoch the container\n * provably had — and a keyring that omits it in favor of a forged id for the\n * same position is detectable even when no epoch RECORD was shipped.\n */\nexport function manifestHistoryEpochIds(kek: ProjectionKek): Set<string> {\n  const epochIds = new Set<string>();\n  for (const bundle of sameContainerManifestHistory(kek)) {\n    const state = readCanonicalRecord(\n      bundle.state,\n      \"Container writer projection historical manifest state\",\n    );\n    const containerKeyEpochId = Reflect.get(state, \"containerKeyEpochId\");\n    if (\n      typeof containerKeyEpochId === \"string\" &&\n      containerKeyEpochId !== kek.containerKeyEpochId\n    ) {\n      epochIds.add(containerKeyEpochId);\n    }\n  }\n  return epochIds;\n}\n\n/**\n * The epoch ids this KEK's own history names, plus every one its head's\n * verified lineage names wherever the projection served it. Verification pools\n * every KEK's history, so a server can serve a container's older manifests\n * under another KEK; walking the lineage keeps a forged keyring id from passing\n * because the real id it displaces moved (#2365 finding 32). The walk stops at\n * the first manifest verification did not record, so it only ever adds ids.\n */\nexport function signedHistoryEpochIds(input: {\n  readonly headManifestHash: string;\n  readonly kek: ProjectionKek;\n  readonly verifiedByHash: VerifiedManifests;\n}): Set<string> {\n  const epochIds = manifestHistoryEpochIds(input.kek);\n  const visited = new Set<string>();\n  let current = input.verifiedByHash.get(input.headManifestHash);\n  while (\n    current &&\n    current.state.containerId === input.kek.containerId &&\n    !visited.has(current.manifestHash)\n  ) {\n    visited.add(current.manifestHash);\n    const epochId = current.state.containerKeyEpochId;\n    if (epochId !== null && epochId !== input.kek.containerKeyEpochId) {\n      epochIds.add(epochId);\n    }\n    const previousHash = current.state.previousManifestHash;\n    current =\n      previousHash === null\n        ? undefined\n        : input.verifiedByHash.get(previousHash);\n  }\n  return epochIds;\n}\n\nfunction admitKeyringEntry(input: {\n  entry: Awaited<ReturnType<typeof openContainerKekKeyring>>[number];\n  index: number;\n  kek: ProjectionKek;\n  keksByEpochId: Map<string, UnwrappedContainerKek>;\n}): void {\n  const { entry, kek } = input;\n  const cached = input.keksByEpochId.get(entry.containerKeyEpochId);\n  if (cached) {\n    if (cached.containerId !== kek.containerId) {\n      throw new Error(\n        `${projectionKekLabel(input.index)} cached historical KEK is inconsistent`,\n      );\n    }\n    return;\n  }\n  input.keksByEpochId.set(entry.containerKeyEpochId, {\n    containerId: kek.containerId,\n    // A keyring entry is key material plus the epoch id that commits to it —\n    // there is no epoch record, so no fingerprint. Selection falls back to the\n    // epoch id and AEAD authenticates; the commitment check above is what\n    // makes the material itself trustworthy.\n    keyEpochHash: null,\n    keyMaterial: entry.keyMaterial,\n  });\n}\n\n/**\n * Opens the sealed keyring for one path index and admits every entry into\n * `keksByEpochId` after verifying it against the material-id commitment its\n * ordinal position implies (entry i is key epoch i + 1). No chain walk:\n * one decrypt yields the container's complete retained history, and entry\n * verification is independent per entry.\n */\nexport async function unwrapKeyringContainerKeksAtIndex(input: {\n  currentManifest: ContainerWriterProjectionResponse[\"path\"][number];\n  index: number;\n  kek: ProjectionKek;\n  keksByEpochId: Map<string, UnwrappedContainerKek>;\n  successorKeyMaterial: Uint8Array | null;\n  /** Every manifest projection verification recorded; anchors the keyring. */\n  verifiedByHash: VerifiedManifests;\n  verifyKeyringCommitment: boolean;\n}): Promise<void> {\n  const { kek, successorKeyMaterial } = input;\n  if (!successorKeyMaterial) {\n    return;\n  }\n\n  if (kek.keyring === null) {\n    if (kek.containerKeyEpoch !== 1) {\n      throw new ContainerKekHistoryUnavailableError(\n        projectionKekLabel(input.index),\n      );\n    }\n    return;\n  }\n\n  const entries = await openVerifiedKeyringEntries({\n    currentManifest: input.currentManifest,\n    index: input.index,\n    kek,\n    successorKeyMaterial,\n    verifiedByHash: input.verifiedByHash,\n    verifyKeyringCommitment: input.verifyKeyringCommitment,\n  });\n  for (const entry of entries) {\n    admitKeyringEntry({\n      entry,\n      index: input.index,\n      kek,\n      keksByEpochId: input.keksByEpochId,\n    });\n  }\n}\n\n/**\n * Epoch ids this projection implies exist but that were not recovered —\n * used to attribute history failures to the material they orphan.\n */\nexport function projectedUnreachablePredecessorEpochIds(input: {\n  kek: ProjectionKek;\n  keksByEpochId: ReadonlyMap<string, UnwrappedContainerKek>;\n}): string[] {\n  const projectedEpochIds = new Set<string>();\n  for (const bundle of sameContainerManifestHistory(input.kek)) {\n    const state = readCanonicalRecord(\n      bundle.state,\n      \"Container writer projection historical manifest state\",\n    );\n    const containerKeyEpochId = Reflect.get(state, \"containerKeyEpochId\");\n    if (typeof containerKeyEpochId === \"string\") {\n      projectedEpochIds.add(containerKeyEpochId);\n    }\n  }\n  projectedEpochIds.delete(input.kek.containerKeyEpochId);\n  return [...projectedEpochIds].filter(\n    (containerKeyEpochId) => !input.keksByEpochId.has(containerKeyEpochId),\n  );\n}\n"]}

package/data/documents/shared/{containerKekPathVerification.d.ts → containerKek/containerKekPathVerification.d.ts}

@@ -1,8 +1,8 @@
-import type { VerifiedContainerAccessManifest } from "../../../internal/crypto/index.js";
-import type { ContainerWriterProjectionResponse } from "../../../internal/validators/response/index.js";
-import { type PrincipalPolicyCache } from "../../keyingProjectionVerification/index.js";
-import type { ExecSql } from "../../sqlite/sqlSchema.js";
-import type { ProjectionVerificationOptions } from "./types.js";
+import type { VerifiedContainerAccessManifest } from "../../../../internal/crypto/index.js";
+import type { ContainerWriterProjectionResponse } from "../../../../internal/validators/response/index.js";
+import { type PrincipalPolicyCache } from "../../../keyingProjectionVerification/index.js";
+import type { ExecSql } from "../../../sqlite/sqlSchema.js";
+import type { ProjectionVerificationOptions } from "../types.js";
 export type UnwrapContainerKekPathInput = {
     execSql?: ExecSql | undefined;
     knownContainerKeks?: ReadonlyMap<string, Uint8Array> | undefined;

package/data/documents/shared/{containerKekPathVerification.js → containerKek/containerKekPathVerification.js}

@@ -1,5 +1,5 @@
-import { collectContainerWriterProjectionPrincipalPolicies, } from "../../keyingProjectionVerification/index.js";
-import { resolveProjectionVerifier } from "./types.js";
+import { collectContainerWriterProjectionPrincipalPolicies, } from "../../../keyingProjectionVerification/index.js";
+import { resolveProjectionVerifier } from "../types.js";
 export async function verifyContainerKekPathProjection(input) {
     if (input.projection.path.length !== input.projection.containerKeks.length) {
         throw new Error("Container writer projection path and KEKs are inconsistent");

package/data/documents/shared/containerKek/containerKekPathVerification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containerKekPathVerification.js","sourceRoot":"","sources":["containerKekPathVerification.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,iDAAiD,GAElD,MAAM,uCAAuC,CAAC;AAG/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAYrD,MAAM,CAAC,KAAK,UAAU,gCAAgC,CACpD,KAAkC;IAElC,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;QAC3E,MAAM,IAAI,KAAK,CACb,4DAA4D,CAC7D,CAAC;IACJ,CAAC;IACD,MAAM,wBAAwB,GAAG,yBAAyB,CACxD,KAAK,EACL,sBAAsB,CACvB,CAAC;IACF,IACE,KAAK,CAAC,sBAAsB,KAAK,IAAI;QACrC,wBAAwB,KAAK,IAAI,EACjC,CAAC;QACD,OAAO;IACT,CAAC;IAED,MAAM,iDAAiD,CAAC;QACtD,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,8BAA8B,EAAE,KAAK,CAAC,8BAA8B;QACpE,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;QAChD,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,cAAc,EAAE,wBAAwB;QACxC,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,+BAA+B,EAAE,KAAK,CAAC,+BAA+B;KACvE,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { VerifiedContainerAccessManifest } from \"@tearleads/crypto\";\nimport type { ContainerWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport {\n  collectContainerWriterProjectionPrincipalPolicies,\n  type PrincipalPolicyCache,\n} from \"../../../keyingProjectionVerification\";\nimport type { ExecSql } from \"../../../sqlite/sqlSchema\";\nimport type { ProjectionVerificationOptions } from \"../types\";\nimport { resolveProjectionVerifier } from \"../types\";\n\nexport type UnwrapContainerKekPathInput = {\n  execSql?: ExecSql | undefined;\n  knownContainerKeks?: ReadonlyMap<string, Uint8Array> | undefined;\n  persistVerificationCheckpoints?: boolean | undefined;\n  principalPolicyCache?: PrincipalPolicyCache | undefined;\n  projection: ContainerWriterProjectionResponse;\n  secretKey: Uint8Array;\n  verifiedByHash?: Map<string, VerifiedContainerAccessManifest> | undefined;\n} & ProjectionVerificationOptions;\n\nexport async function verifyContainerKekPathProjection(\n  input: UnwrapContainerKekPathInput,\n): Promise<void> {\n  if (input.projection.path.length !== input.projection.containerKeks.length) {\n    throw new Error(\n      \"Container writer projection path and KEKs are inconsistent\",\n    );\n  }\n  const resolveProjectionUserKey = resolveProjectionVerifier(\n    input,\n    \"Container KEK unwrap\",\n  );\n  if (\n    input.trustedLocalProjection === true ||\n    resolveProjectionUserKey === null\n  ) {\n    return;\n  }\n\n  await collectContainerWriterProjectionPrincipalPolicies({\n    execSql: input.execSql,\n    persistVerificationCheckpoints: input.persistVerificationCheckpoints,\n    principalPolicyCache: input.principalPolicyCache,\n    projection: input.projection,\n    resolveUserKey: resolveProjectionUserKey,\n    stillCurrent: input.stillCurrent,\n    verifiedByHash: input.verifiedByHash,\n    warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,\n  });\n}\n"]}

package/data/documents/shared/{containerKekWrapping.js → containerKek/containerKekWrapping.js}

@@ -1,7 +1,7 @@
-import { deriveContainerKekWrappingPublicKey, unwrapContainerKekParentWrap, } from "../../../internal/crypto/index.js";
-import { isPlainObject as isPlainRecord } from "../../../internal/validators/isPlainObject.js";
+import { deriveContainerKekWrappingPublicKey, unwrapContainerKekParentWrap, } from "../../../../internal/crypto/index.js";
+import { isPlainObject as isPlainRecord } from "../../../../internal/validators/isPlainObject.js";
+import { readManifestContainerId } from "../readers.js";
 import { projectionKekLabel } from "./containerKekPathHistory.js";
-import { readManifestContainerId } from "./readers.js";
 export async function unwrapContainerKekFromParentWrap(input) {
     if (!input.parentContainerKeyEpochId) {
         return null;

package/data/documents/shared/containerKek/containerKekWrapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containerKekWrapping.js","sourceRoot":"","sources":["containerKekWrapping.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,mCAAmC,EACnC,4BAA4B,GAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,aAAa,IAAI,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAErF,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D,MAAM,CAAC,KAAK,UAAU,gCAAgC,CAAC,KAKtD;IACC,IAAI,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,SAAS,GAAG,KAAK,CAAC,mBAAmB,CAAC,GAAG,CAC7C,KAAK,CAAC,yBAAyB,CAChC,CAAC;IACF,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IAED,4EAA4E;IAC5E,wEAAwE;IACxE,2EAA2E;IAC3E,2EAA2E;IAC3E,qEAAqE;IACrE,EAAE;IACF,yEAAyE;IACzE,uEAAuE;IACvE,6EAA6E;IAC7E,0EAA0E;IAC1E,eAAe;IACf,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CACjC,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,CAAC,aAAa,KAAK,WAAW;QAClC,IAAI,CAAC,WAAW,KAAK,SAAS,CAAC,WAAW;QAC1C,IAAI,CAAC,mBAAmB,KAAK,KAAK,CAAC,yBAAyB;QAC5D,CAAC,SAAS,CAAC,YAAY,KAAK,IAAI;YAC9B,IAAI,CAAC,uBAAuB,KAAK,SAAS,CAAC,YAAY,CAAC,CAC7D,CAAC;IACF,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,OAAO,MAAM,4BAA4B,CAAC;YACxC,iBAAiB,EAAE,SAAS,CAAC,WAAW;YACxC,iBAAiB,EAAE,SAAS,CAAC,WAAW;YACxC,aAAa,EAAE,UAAU,CAAC,aAAa;YACvC,UAAU,EAAE,UAAU,CAAC,UAAU;SAClC,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,qCAAqC,EAAE;YACnE,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,6BAA6B,CACjD,UAA6C,EAC7C,KAAa,EACb,WAAuB;IAEvB,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,IAAI,CAAC,QAAQ,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC;QAC7C,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,MAAM,WAAW,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IACtD,IAAI,CAAC,WAAW;QAAE,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;IACtE,MAAM,SAAS,GAAG,MAAM,mCAAmC,CAAC;QAC1D,WAAW;QACX,WAAW;KACZ,CAAC,CAAC;IACH,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,uBAAuB,CAAC,KAAK,SAAS,EAAE,CAAC;QACvE,MAAM,IAAI,KAAK,CACb,GAAG,kBAAkB,CAAC,KAAK,CAAC,kDAAkD,CAC/E,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["import {\n  type ContainerKeyWrap,\n  deriveContainerKekWrappingPublicKey,\n  unwrapContainerKekParentWrap,\n} from \"@tearleads/crypto\";\nimport { isPlainObject as isPlainRecord } from \"@tearleads/validators/isPlainObject\";\nimport type { ContainerWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { readManifestContainerId } from \"../readers\";\nimport type { UnwrappedContainerKek } from \"../types\";\nimport { projectionKekLabel } from \"./containerKekPathHistory\";\n\nexport async function unwrapContainerKekFromParentWrap(input: {\n  label: string;\n  parentContainerKeyEpochId: string | null;\n  parentKeksByEpochId: ReadonlyMap<string, UnwrappedContainerKek>;\n  wraps: readonly ContainerKeyWrap[];\n}): Promise<Uint8Array | null> {\n  if (!input.parentContainerKeyEpochId) {\n    return null;\n  }\n\n  const parentKek = input.parentKeksByEpochId.get(\n    input.parentContainerKeyEpochId,\n  );\n  if (!parentKek) {\n    return null;\n  }\n\n  // The epoch-record fingerprint is a SELECTOR for picking the right envelope\n  // among several, not the security boundary — the AEAD tag below is what\n  // authenticates the parent key. Keyring-recovered historical KEKs carry no\n  // epoch record (only the material and the epoch id that commits to it), so\n  // for those the epoch id alone selects and decryption authenticates.\n  //\n  // Without this, an ancestor rotation would strand every descendant still\n  // pinned to the predecessor epoch: opening the descendant requires the\n  // parent's historical KEK, and that is exactly the key a lazy rekey needs in\n  // order to materialize a post-rotation epoch. A cold client would have no\n  // way back in.\n  const parentWrap = input.wraps.find(\n    (wrap) =>\n      wrap.recipientKind === \"container\" &&\n      wrap.recipientId === parentKek.containerId &&\n      wrap.recipientKeyEpochId === input.parentContainerKeyEpochId &&\n      (parentKek.keyEpochHash === null ||\n        wrap.recipientKeyFingerprint === parentKek.keyEpochHash),\n  );\n  if (!parentWrap) {\n    return null;\n  }\n\n  try {\n    return await unwrapContainerKekParentWrap({\n      parentContainerId: parentKek.containerId,\n      parentKeyMaterial: parentKek.keyMaterial,\n      kemCipherText: parentWrap.kemCipherText,\n      wrappedKey: parentWrap.wrappedKey,\n    });\n  } catch (error) {\n    throw new Error(`${input.label} parent wrap could not be unwrapped`, {\n      cause: error,\n    });\n  }\n}\n\nexport async function assertSignedWrappingPublicKey(\n  projection: ContainerWriterProjectionResponse,\n  index: number,\n  keyMaterial: Uint8Array,\n): Promise<void> {\n  const manifest = projection.path[index];\n  if (!manifest || !isPlainRecord(manifest.state))\n    throw new Error(\"Container manifest is missing\");\n  const containerId = readManifestContainerId(manifest);\n  if (!containerId) throw new Error(\"Container manifest ID is missing\");\n  const publicKey = await deriveContainerKekWrappingPublicKey({\n    containerId,\n    keyMaterial,\n  });\n  if (Reflect.get(manifest.state, \"containerKeyPublicKey\") !== publicKey) {\n    throw new Error(\n      `${projectionKekLabel(index)} wrapping public key does not match KEK material`,\n    );\n  }\n}\n"]}

package/data/documents/shared/{keyringLogWalk.d.ts → containerKek/keyringLogWalk.d.ts}

@@ -1,5 +1,5 @@
-import type { ContainerKekKeyringEntry } from "../../../internal/crypto/index.js";
-import type { ContainerKekLogEpochResponse } from "../../../internal/validators/response/index.js";
+import type { ContainerKekKeyringEntry } from "../../../../internal/crypto/index.js";
+import type { ContainerKekLogEpochResponse } from "../../../../internal/validators/response/index.js";
 /**
  * A whole rotation log assembled from pages. Distinct from the wire type,
  * which describes ONE bounded page and rejects more epochs than a page may

package/data/documents/shared/{keyringLogWalk.js → containerKek/keyringLogWalk.js}

@@ -1,4 +1,4 @@
-import { computeContainerKekMaterialId, normalizeContainerKekKeyring, normalizeContainerKekPredecessorBridge, openContainerKekKeyring, unwrapContainerKekPredecessorBridge, } from "../../../internal/crypto/index.js";
+import { computeContainerKekMaterialId, normalizeContainerKekKeyring, normalizeContainerKekPredecessorBridge, openContainerKekKeyring, unwrapContainerKekPredecessorBridge, } from "../../../../internal/crypto/index.js";
 /**
  * Recovers a predecessor key through one bridge, or null when the link is
  * absent, malformed, undecryptable, or decrypts to material that contradicts

package/data/documents/shared/{keyringRebuild.d.ts → containerKek/keyringRebuild.d.ts}

@@ -1,6 +1,6 @@
-import type { ContainerKekKeyringEntry } from "../../../internal/crypto/index.js";
-import type { ContainerKekLogEpochResponse } from "../../../internal/validators/response/index.js";
-import type { ExecSql } from "../../sqlite/sqlSchema.js";
+import type { ContainerKekKeyringEntry } from "../../../../internal/crypto/index.js";
+import type { ContainerKekLogEpochResponse } from "../../../../internal/validators/response/index.js";
+import type { ExecSql } from "../../../sqlite/sqlSchema.js";
 /**
  * Raised when the requester holds no envelope they can open for a historical
  * epoch. Distinct from corruption: the log is intact, the caller simply is

package/data/documents/shared/{keyringRebuild.js → containerKek/keyringRebuild.js}

@@ -1,6 +1,6 @@
-import { computeContainerKekMaterialId, unwrapContainerKekParentWrap, } from "../../../internal/crypto/index.js";
-import { unwrapKeyEnvelopesWithPrincipalPolicies } from "../../principals/principalPolicyCrypto.js";
-import { normalizeContainerKeyWrap } from "./readers.js";
+import { computeContainerKekMaterialId, unwrapContainerKekParentWrap, } from "../../../../internal/crypto/index.js";
+import { unwrapKeyEnvelopesWithPrincipalPolicies } from "../../../principals/principalPolicyCrypto.js";
+import { normalizeContainerKeyWrap } from "../readers.js";
 /**
  * Splits an epoch's envelopes into the anchor kinds this requester could use:
  * their own direct envelope, principal envelopes their policies may resolve,

package/data/documents/shared/containerKek/keyringRebuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyringRebuild.js","sourceRoot":"","sources":["keyringRebuild.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  ContainerKekKeyringEntry,\n  ContainerKeyWrap,\n} from \"@tearleads/crypto\";\nimport {\n  computeContainerKekMaterialId,\n  unwrapContainerKekParentWrap,\n} from \"@tearleads/crypto\";\nimport type { ContainerKekLogEpochResponse } from \"@tearleads/validators/response\";\nimport { unwrapKeyEnvelopesWithPrincipalPolicies } from \"../../../principals/principalPolicyCrypto\";\nimport type { ExecSql } from \"../../../sqlite/sqlSchema\";\nimport { normalizeContainerKeyWrap } from \"../readers\";\n\n/**\n * Splits an epoch's envelopes into the anchor kinds this requester could use:\n * their own direct envelope, principal envelopes their policies may resolve,\n * and parent-container envelopes. Anything else is not an identity anchor and\n * is dropped, so it never produces a misleading failure.\n */\nfunction partitionAnchorWraps(\n  wraps: readonly Record<string, unknown>[],\n  containerKeyEpochId: string,\n  userId: string,\n): {\n  directWraps: ContainerKeyWrap[];\n  epochWraps: ContainerKeyWrap[];\n  parentWraps: ContainerKeyWrap[];\n  principalWraps: ContainerKeyWrap[];\n} {\n  const forEpoch = wraps\n    .map((wrap) => normalizeContainerKeyWrap(wrap))\n    .filter((wrap) => wrap.containerKeyEpochId === containerKeyEpochId);\n  const directWraps = forEpoch.filter(\n    (wrap) => wrap.recipientKind === \"user\" && wrap.recipientId === userId,\n  );\n  const principalWraps = forEpoch.filter(\n    (wrap) => wrap.recipientKind === \"group\",\n  );\n  const parentWraps = forEpoch.filter(\n    (wrap) => wrap.recipientKind === \"container\",\n  );\n  return {\n    directWraps,\n    epochWraps: [...directWraps, ...principalWraps, ...parentWraps],\n    parentWraps,\n    principalWraps,\n  };\n}\n\n/**\n * Opens the first parent-container envelope whose parent epoch key the caller\n * supplied. Reports whether any key was available, so a missing parent key is\n * distinguishable from a corrupt envelope.\n */\nasync function openParentAnchor(\n  parentWraps: readonly ContainerKeyWrap[],\n  parentKeys: ReadonlyMap<string, Uint8Array>,\n): Promise<{\n  failure: unknown;\n  key: Uint8Array | null;\n  keyWasAvailable: boolean;\n}> {\n  let failure: unknown;\n  let keyWasAvailable = false;\n  for (const wrap of parentWraps) {\n    const parentKey = parentKeys.get(wrap.recipientKeyEpochId);\n    if (!parentKey) {\n      continue;\n    }\n    keyWasAvailable = true;\n    try {\n      return {\n        failure: undefined,\n        key: await unwrapContainerKekParentWrap({\n          parentContainerId: wrap.recipientId,\n          parentKeyMaterial: parentKey,\n          kemCipherText: wrap.kemCipherText,\n          wrappedKey: wrap.wrappedKey,\n        }),\n        keyWasAvailable,\n      };\n    } catch (error) {\n      failure = error;\n    }\n  }\n  return { failure, key: null, keyWasAvailable };\n}\n\n/**\n * Every anchor kind was tried; report the most specific reason. A wrap that\n * was actually attempted and failed is corruption; one that could not be\n * attempted names the key that was missing.\n */\nfunction throwMostSpecificAnchorFailure(input: {\n  containerKeyEpoch: number;\n  directFailure: unknown;\n  hadParentWraps: boolean;\n  parentFailure: unknown;\n  parentKeyWasAvailable: boolean;\n  principalFailure: unknown;\n}): never {\n  if (input.directFailure !== undefined || input.parentFailure !== undefined) {\n    throw new HistoricalWrapUnavailableError(\n      input.containerKeyEpoch,\n      \"corrupt-envelope\",\n      input.directFailure ?? input.parentFailure,\n    );\n  }\n  if (input.principalFailure !== undefined) {\n    throw new HistoricalWrapUnavailableError(\n      input.containerKeyEpoch,\n      \"principal-key-unreachable\",\n      input.principalFailure,\n    );\n  }\n  throw new HistoricalWrapUnavailableError(\n    input.containerKeyEpoch,\n    input.hadParentWraps && !input.parentKeyWasAvailable\n      ? \"parent-key-unavailable\"\n      : \"no-addressed-envelope\",\n  );\n}\n\n/**\n * Raised when the requester holds no envelope they can open for a historical\n * epoch. Distinct from corruption: the log is intact, the caller simply is\n * not an anchor for this epoch.\n */\nexport type HistoricalWrapUnavailableReason =\n  /** No envelope at this epoch is addressed to the requester at all. */\n  | \"no-addressed-envelope\"\n  /** A direct user envelope exists for the requester but did not open. */\n  | \"corrupt-envelope\"\n  /** Only principal-addressed envelopes, whose key epoch is unreachable. */\n  | \"principal-key-unreachable\"\n  /** Only a parent-container envelope, and the parent KEK was not supplied. */\n  | \"parent-key-unavailable\";\n\nconst HISTORICAL_WRAP_UNAVAILABLE_MESSAGES: Record<\n  HistoricalWrapUnavailableReason,\n  (epoch: number) => string\n> = {\n  \"no-addressed-envelope\": (epoch) =>\n    `Container KEK log has no envelope addressed to this requester at epoch ${epoch}`,\n  \"corrupt-envelope\": (epoch) =>\n    `Container KEK log envelope for this requester at epoch ${epoch} could not be opened`,\n  \"principal-key-unreachable\": (epoch) =>\n    `Container KEK log envelope at epoch ${epoch} is addressed to a principal key epoch this client cannot resolve`,\n  \"parent-key-unavailable\": (epoch) =>\n    `Container KEK log envelope at epoch ${epoch} is inherited from a parent container whose KEK was not supplied`,\n};\n\nexport class HistoricalWrapUnavailableError extends Error {\n  constructor(\n    readonly containerKeyEpoch: number,\n    readonly reason: HistoricalWrapUnavailableReason,\n    cause?: unknown,\n  ) {\n    super(\n      HISTORICAL_WRAP_UNAVAILABLE_MESSAGES[reason](containerKeyEpoch),\n      cause === undefined ? undefined : { cause },\n    );\n    this.name = \"HistoricalWrapUnavailableError\";\n  }\n}\n\n/**\n * The first candidate envelope that both decrypts AND matches the epoch's\n * material-id commitment.\n *\n * Candidates are tried ONE AT A TIME. An envelope can be AEAD-valid and still\n * carry the WRONG key — a stale or misaddressed wrap — so decrypting a batch\n * together would let that one envelope answer for the whole group and mask a\n * later envelope that would have opened the epoch. The reported failure is the\n * first real decrypt failure, since a commitment mismatch is a wrong envelope\n * rather than an unreachable one.\n */\nasync function firstCommittedAnchor(input: {\n  attempt: (\n    wraps: ContainerKeyWrap[],\n  ) => Promise<{ failure: unknown; key: Uint8Array | null }>;\n  candidates: ContainerKeyWrap[];\n  containerId: string;\n  containerKeyEpoch: number;\n  containerKeyEpochId: string;\n}): Promise<{ failure: unknown; key: Uint8Array | null }> {\n  let firstFailure: unknown;\n  for (const candidate of input.candidates) {\n    const result = await input.attempt([candidate]);\n    if (result.key === null) {\n      firstFailure ??= result.failure;\n      continue;\n    }\n    const materialId = await computeContainerKekMaterialId({\n      containerId: input.containerId,\n      keyEpoch: input.containerKeyEpoch,\n      keyMaterial: result.key,\n    });\n    if (materialId === input.containerKeyEpochId) {\n      return result;\n    }\n    // An envelope that decrypts to the WRONG key is a misaddressed or stale\n    // envelope, not an unreachable principal. Recording it keeps the reported\n    // reason `corrupt-envelope`; dropping it silently would let the epoch\n    // report as unaddressed, which points a repair at the wrong problem.\n    //\n    // Only reachable when the server files a wrap under an epoch id its\n    // material does not hash to — the addressing filter already rejects a\n    // wrap whose epoch id simply differs.\n    firstFailure ??= new Error(\n      `Container KEK envelope decrypts to material that is not epoch ${input.containerKeyEpochId}`,\n    );\n  }\n  return { failure: firstFailure, key: null };\n}\n\n/**\n * Opens one group of envelopes with the requester's CURRENT policies, folding\n * failure into a value rather than throwing.\n *\n * The caller tries several groups in order, and a failure in one is not the\n * end of the search — so the failure has to travel back alongside the miss\n * instead of unwinding the whole recovery.\n */\nasync function unwrapWrapsWithCurrentPolicies(input: {\n  execSql?: ExecSql | undefined;\n  secretKey: Uint8Array;\n  wraps: readonly ContainerKeyWrap[];\n}): Promise<{ failure: unknown; key: Uint8Array | null }> {\n  if (input.wraps.length === 0) {\n    return { failure: undefined, key: null };\n  }\n  try {\n    return {\n      failure: undefined,\n      key: await unwrapKeyEnvelopesWithPrincipalPolicies({\n        envelopes: input.wraps.map((wrap) => ({\n          keyFingerprint: wrap.recipientKeyFingerprint,\n          kemCipherText: wrap.kemCipherText,\n          wrappedKey: wrap.wrappedKey,\n        })),\n        execSql: input.execSql,\n        secretKey: input.secretKey,\n      }),\n    };\n  } catch (error) {\n    return { failure: error, key: null };\n  }\n}\n\n/**\n * The severed-bridge backstop: recovers one historical epoch's KEK from the\n * requester's own retained recipient envelope served in the kek-log. Wraps\n * are written by that epoch's rotator and never deleted, so this path is\n * independent of every later rotation — it works even when the bridge chain\n * above the epoch is destroyed. The recovered key is verified against the\n * epoch id's material commitment before use.\n *\n * Scope bound: a direct user envelope is recoverable from identity keys\n * alone, so a pristine client anchors on it. A group- or organization-\n * addressed envelope additionally requires the current principal secret key.\n * Principal rotation rematerializes every retained container grant against\n * the new principal head, so a current reader never needs an older principal\n * key to use this recovery path. Unreachable principal keys fail closed with\n * `HistoricalWrapUnavailableError` rather than appearing to be corruption.\n */\nexport async function recoverKeyringEntryFromWraps(input: {\n  containerId: string;\n  epoch: Pick<\n    ContainerKekLogEpochResponse,\n    \"containerKeyEpoch\" | \"containerKeyEpochId\" | \"wraps\"\n  >;\n  execSql?: ExecSql | undefined;\n  secretKey: Uint8Array;\n  /**\n   * Parent container KEKs by epoch id. An inherited-only child has no direct\n   * or principal envelope of its own; its anchor is the parent-container\n   * wrap, which opens under the parent epoch's KEK. Recover the parent's\n   * epoch first (recursively, through the parent's own log) and pass it here.\n   */\n  parentKeysByEpochId?: ReadonlyMap<string, Uint8Array> | undefined;\n  /**\n   * The requester's user id. Direct user envelopes are matched against it, so\n   * another member's envelope is never mistaken for an anchor — attempting it\n   * would only produce a misleading failure.\n   */\n  userId: string;\n}): Promise<ContainerKekKeyringEntry> {\n  const { directWraps, epochWraps, parentWraps, principalWraps } =\n    partitionAnchorWraps(\n      input.epoch.wraps,\n      input.epoch.containerKeyEpochId,\n      input.userId,\n    );\n  if (epochWraps.length === 0) {\n    throw new HistoricalWrapUnavailableError(\n      input.epoch.containerKeyEpoch,\n      \"no-addressed-envelope\",\n    );\n  }\n\n  const attempt = (wraps: typeof epochWraps) =>\n    unwrapWrapsWithCurrentPolicies({\n      execSql: input.execSql,\n      secretKey: input.secretKey,\n      wraps,\n    });\n\n  // A direct envelope is decryptable from identity keys alone, so its failure\n  // means corruption — not an unreachable principal key. Neither failure ends\n  // the search: a parent-container wrap may still anchor this epoch.\n  //\n  // Candidates are tried ONE AT A TIME, and each must match the epoch's\n  // material-id commitment rather than merely decrypt. An envelope can be\n  // AEAD-valid and still carry the WRONG key — a stale or misaddressed wrap —\n  // so batching would let that one envelope answer for the whole group and\n  // mask a later envelope that would have opened the epoch.\n  const attemptCommitted = (candidates: ContainerKeyWrap[]) =>\n    firstCommittedAnchor({\n      attempt,\n      candidates,\n      containerId: input.containerId,\n      containerKeyEpoch: input.epoch.containerKeyEpoch,\n      containerKeyEpochId: input.epoch.containerKeyEpochId,\n    });\n\n  const direct = await attemptCommitted(directWraps);\n  let keyMaterial = direct.key;\n  const directFailure = direct.failure;\n  let principalFailure: unknown;\n  if (keyMaterial === null) {\n    const principal = await attemptCommitted(principalWraps);\n    keyMaterial = principal.key;\n    // Preserve the current-policy failure in case no inherited anchor opens.\n    principalFailure = principal.failure;\n  }\n  // The inherited-only path: a parent-container envelope opens under the\n  // parent epoch's KEK, which the caller recovers from the parent's own log.\n  const parent =\n    keyMaterial === null\n      ? await openParentAnchor(\n          parentWraps,\n          input.parentKeysByEpochId ?? new Map(),\n        )\n      : { failure: undefined, key: null, keyWasAvailable: false };\n  keyMaterial ??= parent.key;\n  const parentFailure = parent.failure;\n  const parentKeyWasAvailable = parent.keyWasAvailable;\n  if (keyMaterial === null) {\n    throwMostSpecificAnchorFailure({\n      containerKeyEpoch: input.epoch.containerKeyEpoch,\n      directFailure,\n      hadParentWraps: parentWraps.length > 0,\n      parentFailure,\n      parentKeyWasAvailable,\n      principalFailure,\n    });\n  }\n  const expectedId = await computeContainerKekMaterialId({\n    containerId: input.containerId,\n    keyEpoch: input.epoch.containerKeyEpoch,\n    keyMaterial,\n  });\n  if (expectedId !== input.epoch.containerKeyEpochId) {\n    throw new Error(\n      `Container KEK log wrap does not match its committed epoch id at epoch ${input.epoch.containerKeyEpoch}`,\n    );\n  }\n  return {\n    containerKeyEpochId: input.epoch.containerKeyEpochId,\n    keyMaterial,\n  };\n}\n\nexport { fetchContainerKekLog } from \"./containerKekLogFetch\";\nexport type {\n  AggregatedContainerKekLog,\n  KeyringRebuildResult,\n} from \"./keyringLogWalk\";\nexport { rebuildKeyringEntriesFromLog } from \"./keyringLogWalk\";\n"]}

package/data/documents/shared/crypto.js

@@ -2,9 +2,9 @@ import { CONTENT_RECORD_ENCRYPTION_SUITE, computeContentRecordNonceDomainHash, c
 import { base64ToBytes, bytesToBase64 } from "../../../internal/encoding/index.js";
 import { contentRecordAdditionalDataBytes } from "./contentRecordAdditionalData.js";
 import { deriveDocumentContentRecordKey, deriveDocumentPlaintextHashKey, importContentKeyMaterial, } from "./contentRecordKeys.js";
-import { decryptDocumentSyncUpdate } from "./documentSyncUpdateDecryption.js";
-import { isDocumentSyncUpdateIsolationError, isolateDocumentSyncBatchError, isolateDocumentSyncUpdateError, } from "./documentSyncUpdateIsolation.js";
 import { asWebCryptoBytes, readWriteHeader } from "./readers.js";
+import { decryptDocumentSyncUpdate } from "./sync/documentSyncUpdateDecryption.js";
+import { isDocumentSyncUpdateIsolationError, isolateDocumentSyncBatchError, isolateDocumentSyncUpdateError, } from "./sync/documentSyncUpdateIsolation.js";
 import { DOCUMENT_ENCRYPTED_LORO_UPDATE_FORMAT, } from "./types.js";
 export async function encryptDocumentPendingUpdate(input) {
     const plaintext = base64ToBytes(input.update.updateData);