@tearleads/client-sdk 0.1.62 → 0.1.64

package/data/keyingProjectionVerification/documentPurge/documentPurgePolicyCheckpoints.js

@@ -0,0 +1,17 @@
+import { KeyingVerificationError, principalPolicyMatchesReference, } from "../../../internal/crypto/index.js";
+import { loadStoredPrincipalPolicyCheckpoint, upsertPrincipalPolicyCheckpointInTransaction, } from "../../persistence/keyingCheckpointPersistence.js";
+/** After complete terminal-proof currency validation, admit only its bound sources. */
+export async function admitDocumentPurgePolicyCheckpoints(input) {
+    const updatedAt = new Date().toISOString();
+    for (const reference of input.heads) {
+        if (!input.policies.some((policy) => principalPolicyMatchesReference({ policy, reference })))
+            throw new KeyingVerificationError("missing_dependency", "Purge source lacks verified inclusion");
+        const checkpoint = await loadStoredPrincipalPolicyCheckpoint(input.transaction, reference);
+        // A newer privately authenticated prefix can prove ancestry, but is not an
+        // observation admitted by this terminal proof. Preserve any newer pin.
+        if (checkpoint && checkpoint.version >= reference.version)
+            continue;
+        await upsertPrincipalPolicyCheckpointInTransaction(input.transaction, reference, updatedAt, input.organizationId);
+    }
+}
+//# sourceMappingURL=documentPurgePolicyCheckpoints.js.map

package/data/keyingProjectionVerification/documentPurge/documentPurgePolicyCheckpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentPurgePolicyCheckpoints.js","sourceRoot":"","sources":["documentPurgePolicyCheckpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,+BAA+B,GAGhC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,mCAAmC,EACnC,4CAA4C,GAC7C,MAAM,+CAA+C,CAAC;AAGvD,uFAAuF;AACvF,MAAM,CAAC,KAAK,UAAU,mCAAmC,CAAC,KAKzD;IACC,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC3C,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QACpC,IACE,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAC9B,+BAA+B,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CACvD;YAED,MAAM,IAAI,uBAAuB,CAC/B,oBAAoB,EACpB,uCAAuC,CACxC,CAAC;QACJ,MAAM,UAAU,GAAG,MAAM,mCAAmC,CAC1D,KAAK,CAAC,WAAW,EACjB,SAAS,CACV,CAAC;QACF,2EAA2E;QAC3E,uEAAuE;QACvE,IAAI,UAAU,IAAI,UAAU,CAAC,OAAO,IAAI,SAAS,CAAC,OAAO;YAAE,SAAS;QACpE,MAAM,4CAA4C,CAChD,KAAK,CAAC,WAAW,EACjB,SAAS,EACT,SAAS,EACT,KAAK,CAAC,cAAc,CACrB,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["import {\n  KeyingVerificationError,\n  principalPolicyMatchesReference,\n  type ReferencedPrincipalHead,\n  type VerifiedPrincipalPolicySelection,\n} from \"@tearleads/crypto\";\nimport {\n  loadStoredPrincipalPolicyCheckpoint,\n  upsertPrincipalPolicyCheckpointInTransaction,\n} from \"../../persistence/keyingCheckpointPersistence\";\nimport type { ClientSQLiteTransactionScope } from \"../../sqlite/sqlitePersistenceRuntime\";\n\n/** After complete terminal-proof currency validation, admit only its bound sources. */\nexport async function admitDocumentPurgePolicyCheckpoints(input: {\n  readonly transaction: ClientSQLiteTransactionScope;\n  readonly organizationId: string | undefined;\n  readonly policies: readonly VerifiedPrincipalPolicySelection[];\n  readonly heads: readonly ReferencedPrincipalHead[];\n}): Promise<void> {\n  const updatedAt = new Date().toISOString();\n  for (const reference of input.heads) {\n    if (\n      !input.policies.some((policy) =>\n        principalPolicyMatchesReference({ policy, reference }),\n      )\n    )\n      throw new KeyingVerificationError(\n        \"missing_dependency\",\n        \"Purge source lacks verified inclusion\",\n      );\n    const checkpoint = await loadStoredPrincipalPolicyCheckpoint(\n      input.transaction,\n      reference,\n    );\n    // A newer privately authenticated prefix can prove ancestry, but is not an\n    // observation admitted by this terminal proof. Preserve any newer pin.\n    if (checkpoint && checkpoint.version >= reference.version) continue;\n    await upsertPrincipalPolicyCheckpointInTransaction(\n      input.transaction,\n      reference,\n      updatedAt,\n      input.organizationId,\n    );\n  }\n}\n"]}

package/data/keyingProjectionVerification/documentPurge/documentPurgePolicyCurrency.js

@@ -0,0 +1,55 @@
+import { KeyingVerificationError, principalPolicyMatchesReference, } from "../../../internal/crypto/index.js";
+import { loadPrincipalPolicyCheckpoint } from "../../persistence/keyingCheckpointPersistence.js";
+import { observeProjectionLifetime, projectionLifetimeGuard, } from "../projectionLifetimes.js";
+import { assertProjectionVerificationCurrent, } from "../types.js";
+/** Authenticate connections to newer device pins without extending terminal grants or admitting heads. */
+export async function recoverDocumentPurgePolicyCurrency(input) {
+    const resolve = input.warmer?.resolveReference;
+    if (!resolve)
+        return [...input.policies];
+    const recoveryBatch = {};
+    const recovered = new Map();
+    const policies = [];
+    for (const policy of input.policies) {
+        // Returned leases may include their caller predicate. Pass the original
+        // lifetime, not the growing context guard, to avoid a recursive guard graph.
+        const stillCurrent = input.stillCurrent;
+        assertProjectionVerificationCurrent(projectionLifetimeGuard(input.context));
+        const checkpoint = await loadPrincipalPolicyCheckpoint(input.context.execSql, policy.principalType, policy.principalId);
+        if (!checkpoint || checkpoint.version <= policy.version) {
+            policies.push(policy);
+            continue;
+        }
+        const key = `${policy.principalType}:${policy.principalId}:${policy.stateHash}`;
+        let bridge = recovered.get(key);
+        if (!bridge) {
+            const reference = {
+                principalType: policy.principalType,
+                principalId: policy.principalId,
+                version: policy.version,
+                stateHash: policy.stateHash,
+                keyEpoch: policy.keyEpoch,
+                keyFingerprint: policy.state.keyFingerprint,
+            };
+            const result = await resolve({
+                organizationId: input.organizationId,
+                reference,
+                recoveryBatch,
+                preferLocalHistory: true,
+                stillCurrent,
+            });
+            assertProjectionVerificationCurrent(projectionLifetimeGuard(input.context));
+            assertProjectionVerificationCurrent(result.stillCurrent);
+            if (result.organizationId !== input.organizationId ||
+                !principalPolicyMatchesReference({ policy: result.policy, reference }))
+                throw new KeyingVerificationError("object_mismatch", "Purge currency recovery does not bind its historical policy");
+            observeProjectionLifetime(input.context, result.stillCurrent);
+            bridge = result.policy;
+            recovered.set(key, bridge);
+        }
+        policies.push(bridge);
+    }
+    assertProjectionVerificationCurrent(projectionLifetimeGuard(input.context));
+    return policies;
+}
+//# sourceMappingURL=documentPurgePolicyCurrency.js.map

package/data/keyingProjectionVerification/documentPurge/documentPurgePolicyCurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentPurgePolicyCurrency.js","sourceRoot":"","sources":["documentPurgePolicyCurrency.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  KeyingVerificationError,\n  principalPolicyMatchesReference,\n  type VerifiedPrincipalPolicyCurrent,\n  type VerifiedPrincipalPolicySelection,\n} from \"@tearleads/crypto\";\nimport { loadPrincipalPolicyCheckpoint } from \"../../persistence/keyingCheckpointPersistence\";\nimport type { ProjectionCheckpointContext } from \"../checkpoints/checkpointContext\";\nimport {\n  observeProjectionLifetime,\n  projectionLifetimeGuard,\n} from \"../projectionLifetimes\";\nimport {\n  assertProjectionVerificationCurrent,\n  type ReferencedPrincipalPolicyWarmer,\n} from \"../types\";\n\nexport type PurgePolicyCurrencyEvidence =\n  | VerifiedPrincipalPolicySelection\n  | VerifiedPrincipalPolicyCurrent;\n\n/** Authenticate connections to newer device pins without extending terminal grants or admitting heads. */\nexport async function recoverDocumentPurgePolicyCurrency(input: {\n  readonly context: ProjectionCheckpointContext;\n  readonly organizationId: string;\n  readonly policies: readonly VerifiedPrincipalPolicySelection[];\n  readonly warmer: ReferencedPrincipalPolicyWarmer | undefined;\n  readonly stillCurrent: () => boolean;\n}): Promise<PurgePolicyCurrencyEvidence[]> {\n  const resolve = input.warmer?.resolveReference;\n  if (!resolve) return [...input.policies];\n  const recoveryBatch = {};\n  const recovered = new Map<string, VerifiedPrincipalPolicyCurrent>();\n  const policies: PurgePolicyCurrencyEvidence[] = [];\n  for (const policy of input.policies) {\n    // Returned leases may include their caller predicate. Pass the original\n    // lifetime, not the growing context guard, to avoid a recursive guard graph.\n    const stillCurrent = input.stillCurrent;\n    assertProjectionVerificationCurrent(projectionLifetimeGuard(input.context));\n    const checkpoint = await loadPrincipalPolicyCheckpoint(\n      input.context.execSql,\n      policy.principalType,\n      policy.principalId,\n    );\n    if (!checkpoint || checkpoint.version <= policy.version) {\n      policies.push(policy);\n      continue;\n    }\n    const key = `${policy.principalType}:${policy.principalId}:${policy.stateHash}`;\n    let bridge = recovered.get(key);\n    if (!bridge) {\n      const reference = {\n        principalType: policy.principalType,\n        principalId: policy.principalId,\n        version: policy.version,\n        stateHash: policy.stateHash,\n        keyEpoch: policy.keyEpoch,\n        keyFingerprint: policy.state.keyFingerprint,\n      };\n      const result = await resolve({\n        organizationId: input.organizationId,\n        reference,\n        recoveryBatch,\n        preferLocalHistory: true,\n        stillCurrent,\n      });\n      assertProjectionVerificationCurrent(\n        projectionLifetimeGuard(input.context),\n      );\n      assertProjectionVerificationCurrent(result.stillCurrent);\n      if (\n        result.organizationId !== input.organizationId ||\n        !principalPolicyMatchesReference({ policy: result.policy, reference })\n      )\n        throw new KeyingVerificationError(\n          \"object_mismatch\",\n          \"Purge currency recovery does not bind its historical policy\",\n        );\n      observeProjectionLifetime(input.context, result.stillCurrent);\n      bridge = result.policy;\n      recovered.set(key, bridge);\n    }\n    policies.push(bridge);\n  }\n  assertProjectionVerificationCurrent(projectionLifetimeGuard(input.context));\n  return policies;\n}\n"]}

package/data/keyingProjectionVerification/documentPurge/documentPurgePrincipalEvidence.js

@@ -0,0 +1,116 @@
+import { KeyingVerificationError, principalPolicyMatchesReference, verifyDocumentPurgeEvent, } from "../../../internal/crypto/index.js";
+import { parseOrganizationAuthorityDescriptor } from "../../principals/organizationAuthorityDescriptor.js";
+import { verifyStandaloneAccessEventBundle } from "../checkpoints/bundleVerification.js";
+import { verifyPurgeDocumentManifest } from "./documentPurgeDocumentChainVerification.js";
+function principalIdentity(input) {
+    return `${input.principalType}:${input.principalId}`;
+}
+function collectEvidenceContainerManifests(input) {
+    const selected = new Map();
+    const pending = [...input.roots];
+    while (pending.length > 0) {
+        const manifest = pending.shift();
+        if (!manifest || selected.has(manifest.manifestHash))
+            continue;
+        selected.set(manifest.manifestHash, manifest);
+        for (const dependencyHash of [
+            manifest.manifest.previousManifestHash,
+            manifest.state.parentManifestHash,
+        ]) {
+            if (!dependencyHash)
+                continue;
+            const dependency = input.verifiedByHash.get(dependencyHash);
+            if (dependency)
+                pending.push(dependency);
+        }
+    }
+    return [...selected.values()];
+}
+function requireExactPurgePrincipalEvidence(input) {
+    const references = input.verifiedContainerManifests.flatMap((manifest) => manifest.state.referencedPrincipalHeads);
+    const requiredByPrincipal = new Set();
+    for (const reference of references) {
+        const policy = input.authorizationEvidence.find((candidate) => principalPolicyMatchesReference({ policy: candidate, reference }));
+        if (!policy) {
+            throw new KeyingVerificationError("missing_dependency", "Document purge proof omits referenced principal policy evidence");
+        }
+        const identity = principalIdentity(policy);
+        requiredByPrincipal.add(identity);
+        // External authority is verified incrementally by paged recovery. Its
+        // historical entries need not be copied into this returned selection.
+    }
+    const allowed = new Set(requiredByPrincipal);
+    // Paged recovery has authenticated these payloads against their signed
+    // organization states and verified their exact group-head bindings. This
+    // identity allow-list cannot authenticate an unverified directory payload.
+    for (const { payload } of input.policyEvidence.organizationPayloads) {
+        const directory = parseOrganizationAuthorityDescriptor(payload.ciphertext);
+        if (directory.groupHeads.some((head) => allowed.has(principalIdentity(head)))) {
+            allowed.add(`group:${directory.adminGroupId}`);
+            allowed.add(`organization:${directory.organizationId}`);
+        }
+    }
+    if (input.authorizationEvidence.some((policy) => !allowed.has(principalIdentity(policy))))
+        throw new KeyingVerificationError("invalid_shape", "Document purge proof includes unrelated principal policy evidence");
+    return input.authorizationEvidence.filter((policy) => requiredByPrincipal.has(principalIdentity(policy)));
+}
+async function authenticateDocumentPurgeEvent(input) {
+    const event = await verifyStandaloneAccessEventBundle({
+        bundle: input.purgeEvent,
+        label: "Document purge event",
+        resolveUserKey: input.resolveUserKey,
+    });
+    const evidenceContainerManifests = collectEvidenceContainerManifests({
+        roots: input.rootContainerManifests,
+        verifiedByHash: input.verifiedContainerManifests,
+    });
+    const principalPolicies = requireExactPurgePrincipalEvidence({
+        authorizationEvidence: input.authorizationEvidence,
+        verifiedContainerManifests: evidenceContainerManifests,
+        policyEvidence: input.policyEvidence,
+    });
+    const verified = await verifyDocumentPurgeEvent({
+        authorizingContainerPath: input.authorizingContainerPath,
+        documentManifest: input.documentManifest,
+        event,
+        expectedDocumentId: input.expectedDocumentId,
+        principalPolicies,
+    });
+    if (!verified.ok)
+        throw verified.error;
+    return {
+        principalPolicies: [...input.authorizationEvidence],
+        purgeEventHash: verified.value.eventHash,
+    };
+}
+export async function authenticateDocumentPurgeArtifacts(input) {
+    const usedContainerManifests = new Map();
+    const documentManifest = await verifyPurgeDocumentManifest({
+        authorizationEvidence: input.authorizationEvidence,
+        checkpointContext: input.checkpointContext,
+        containerPathByManifestHash: input.containerPathByManifestHash,
+        enforceLocalCheckpoints: input.enforceLocalCheckpoints,
+        principalPolicyCache: input.principalPolicyCache,
+        proof: input.proof,
+        resolveUserKey: input.resolveUserKey,
+        usedContainerManifests,
+    });
+    return {
+        documentManifest,
+        ...(await authenticateDocumentPurgeEvent({
+            authorizationEvidence: input.authorizationEvidence,
+            authorizingContainerPath: input.authorizingContainerPath,
+            documentManifest,
+            expectedDocumentId: input.expectedDocumentId,
+            purgeEvent: input.proof.purgeEvent,
+            policyEvidence: input.proof.policyEvidence,
+            resolveUserKey: input.resolveUserKey,
+            rootContainerManifests: [
+                ...input.authorizingContainerPath,
+                ...usedContainerManifests.values(),
+            ],
+            verifiedContainerManifests: input.verifiedContainerManifests,
+        })),
+    };
+}
+//# sourceMappingURL=documentPurgePrincipalEvidence.js.map

package/data/keyingProjectionVerification/documentPurge/documentPurgePrincipalEvidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentPurgePrincipalEvidence.js","sourceRoot":"","sources":["documentPurgePrincipalEvidence.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  KeyingVerificationError,\n  type PrincipalPolicyAuthorization,\n  principalPolicyMatchesReference,\n  type ReferencedPrincipalHead,\n  type VerifiedContainerAccessManifest,\n  type VerifiedDocumentLinkSetManifest,\n  type VerifiedDocumentLinkSetSnapshot,\n  type VerifiedPrincipalPolicySelection,\n  verifyDocumentPurgeEvent,\n} from \"@tearleads/crypto\";\nimport type { DocumentPurgeProofResponse } from \"@tearleads/validators/response\";\nimport { parseOrganizationAuthorityDescriptor } from \"../../principals/organizationAuthorityDescriptor\";\nimport { verifyStandaloneAccessEventBundle } from \"../checkpoints/bundleVerification\";\nimport type { ProjectionCheckpointContext } from \"../checkpoints/checkpointContext\";\nimport type { PrincipalPolicyCache, ProjectionUserKeyResolver } from \"../types\";\nimport { verifyPurgeDocumentManifest } from \"./documentPurgeDocumentChainVerification\";\n\nfunction principalIdentity(input: {\n  readonly principalId: string;\n  readonly principalType: string;\n}): string {\n  return `${input.principalType}:${input.principalId}`;\n}\n\nfunction collectEvidenceContainerManifests(input: {\n  readonly roots: readonly VerifiedContainerAccessManifest[];\n  readonly verifiedByHash: ReadonlyMap<string, VerifiedContainerAccessManifest>;\n}): VerifiedContainerAccessManifest[] {\n  const selected = new Map<string, VerifiedContainerAccessManifest>();\n  const pending = [...input.roots];\n  while (pending.length > 0) {\n    const manifest = pending.shift();\n    if (!manifest || selected.has(manifest.manifestHash)) continue;\n    selected.set(manifest.manifestHash, manifest);\n    for (const dependencyHash of [\n      manifest.manifest.previousManifestHash,\n      manifest.state.parentManifestHash,\n    ]) {\n      if (!dependencyHash) continue;\n      const dependency = input.verifiedByHash.get(dependencyHash);\n      if (dependency) pending.push(dependency);\n    }\n  }\n  return [...selected.values()];\n}\n\nfunction requireExactPurgePrincipalEvidence<\n  TPolicy extends PrincipalPolicyAuthorization,\n>(input: {\n  readonly authorizationEvidence: readonly TPolicy[];\n  readonly verifiedContainerManifests: readonly VerifiedContainerAccessManifest[];\n  readonly policyEvidence: DocumentPurgeProofResponse[\"policyEvidence\"];\n}): TPolicy[] {\n  const references: ReferencedPrincipalHead[] =\n    input.verifiedContainerManifests.flatMap(\n      (manifest) => manifest.state.referencedPrincipalHeads,\n    );\n  const requiredByPrincipal = new Set<string>();\n\n  for (const reference of references) {\n    const policy = input.authorizationEvidence.find((candidate) =>\n      principalPolicyMatchesReference({ policy: candidate, reference }),\n    );\n    if (!policy) {\n      throw new KeyingVerificationError(\n        \"missing_dependency\",\n        \"Document purge proof omits referenced principal policy evidence\",\n      );\n    }\n    const identity = principalIdentity(policy);\n    requiredByPrincipal.add(identity);\n    // External authority is verified incrementally by paged recovery. Its\n    // historical entries need not be copied into this returned selection.\n  }\n\n  const allowed = new Set(requiredByPrincipal);\n  // Paged recovery has authenticated these payloads against their signed\n  // organization states and verified their exact group-head bindings. This\n  // identity allow-list cannot authenticate an unverified directory payload.\n  for (const { payload } of input.policyEvidence.organizationPayloads) {\n    const directory = parseOrganizationAuthorityDescriptor(payload.ciphertext);\n    if (\n      directory.groupHeads.some((head) => allowed.has(principalIdentity(head)))\n    ) {\n      allowed.add(`group:${directory.adminGroupId}`);\n      allowed.add(`organization:${directory.organizationId}`);\n    }\n  }\n  if (\n    input.authorizationEvidence.some(\n      (policy) => !allowed.has(principalIdentity(policy)),\n    )\n  )\n    throw new KeyingVerificationError(\n      \"invalid_shape\",\n      \"Document purge proof includes unrelated principal policy evidence\",\n    );\n  return input.authorizationEvidence.filter((policy) =>\n    requiredByPrincipal.has(principalIdentity(policy)),\n  );\n}\n\nasync function authenticateDocumentPurgeEvent(input: {\n  readonly authorizationEvidence: readonly VerifiedPrincipalPolicySelection[];\n  readonly authorizingContainerPath: readonly VerifiedContainerAccessManifest[];\n  readonly documentManifest:\n    | VerifiedDocumentLinkSetManifest\n    | VerifiedDocumentLinkSetSnapshot;\n  readonly expectedDocumentId: string;\n  readonly purgeEvent: DocumentPurgeProofResponse[\"purgeEvent\"];\n  readonly policyEvidence: DocumentPurgeProofResponse[\"policyEvidence\"];\n  readonly resolveUserKey: ProjectionUserKeyResolver;\n  readonly rootContainerManifests: readonly VerifiedContainerAccessManifest[];\n  readonly verifiedContainerManifests: ReadonlyMap<\n    string,\n    VerifiedContainerAccessManifest\n  >;\n}): Promise<{\n  readonly principalPolicies: VerifiedPrincipalPolicySelection[];\n  readonly purgeEventHash: string;\n}> {\n  const event = await verifyStandaloneAccessEventBundle({\n    bundle: input.purgeEvent,\n    label: \"Document purge event\",\n    resolveUserKey: input.resolveUserKey,\n  });\n  const evidenceContainerManifests = collectEvidenceContainerManifests({\n    roots: input.rootContainerManifests,\n    verifiedByHash: input.verifiedContainerManifests,\n  });\n  const principalPolicies = requireExactPurgePrincipalEvidence({\n    authorizationEvidence: input.authorizationEvidence,\n    verifiedContainerManifests: evidenceContainerManifests,\n    policyEvidence: input.policyEvidence,\n  });\n  const verified = await verifyDocumentPurgeEvent({\n    authorizingContainerPath: input.authorizingContainerPath,\n    documentManifest: input.documentManifest,\n    event,\n    expectedDocumentId: input.expectedDocumentId,\n    principalPolicies,\n  });\n  if (!verified.ok) throw verified.error;\n  return {\n    principalPolicies: [...input.authorizationEvidence],\n    purgeEventHash: verified.value.eventHash,\n  };\n}\n\nexport async function authenticateDocumentPurgeArtifacts(input: {\n  readonly authorizationEvidence: readonly VerifiedPrincipalPolicySelection[];\n  readonly authorizingContainerPath: readonly VerifiedContainerAccessManifest[];\n  readonly checkpointContext: ProjectionCheckpointContext;\n  readonly containerPathByManifestHash: ReadonlyMap<\n    string,\n    readonly VerifiedContainerAccessManifest[]\n  >;\n  readonly enforceLocalCheckpoints: boolean;\n  readonly expectedDocumentId: string;\n  readonly principalPolicyCache: PrincipalPolicyCache;\n  readonly proof: DocumentPurgeProofResponse;\n  readonly resolveUserKey: ProjectionUserKeyResolver;\n  readonly verifiedContainerManifests: ReadonlyMap<\n    string,\n    VerifiedContainerAccessManifest\n  >;\n}) {\n  const usedContainerManifests = new Map<\n    string,\n    VerifiedContainerAccessManifest\n  >();\n  const documentManifest = await verifyPurgeDocumentManifest({\n    authorizationEvidence: input.authorizationEvidence,\n    checkpointContext: input.checkpointContext,\n    containerPathByManifestHash: input.containerPathByManifestHash,\n    enforceLocalCheckpoints: input.enforceLocalCheckpoints,\n    principalPolicyCache: input.principalPolicyCache,\n    proof: input.proof,\n    resolveUserKey: input.resolveUserKey,\n    usedContainerManifests,\n  });\n  return {\n    documentManifest,\n    ...(await authenticateDocumentPurgeEvent({\n      authorizationEvidence: input.authorizationEvidence,\n      authorizingContainerPath: input.authorizingContainerPath,\n      documentManifest,\n      expectedDocumentId: input.expectedDocumentId,\n      purgeEvent: input.proof.purgeEvent,\n      policyEvidence: input.proof.policyEvidence,\n      resolveUserKey: input.resolveUserKey,\n      rootContainerManifests: [\n        ...input.authorizingContainerPath,\n        ...usedContainerManifests.values(),\n      ],\n      verifiedContainerManifests: input.verifiedContainerManifests,\n    })),\n  };\n}\n"]}

package/data/keyingProjectionVerification/documentPurge/documentPurgeProofVerification.d.ts

@@ -0,0 +1,34 @@
+import { type AccessManifestCheckpoint, type PrincipalPolicyAuthorization, type VerifiedContainerAccessManifest } from "../../../internal/crypto/index.js";
+import type { DocumentPurgeProofResponse } from "../../../internal/validators/response/index.js";
+import type { ExecSql } from "../../sqlite/sqlSchema.js";
+import { createProjectionCheckpointContext } from "../checkpoints/checkpointContext.js";
+import { type PrincipalPolicyCache, type ProjectionUserKeyResolver, type ReferencedPrincipalPolicyWarmer } from "../types.js";
+interface VerifyDocumentPurgeProofInput {
+    readonly stillCurrent?: (() => boolean) | undefined;
+    readonly warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;
+    readonly execSql: ExecSql;
+    readonly expectedDocumentId: string;
+    readonly expectedOrganizationId: string;
+    readonly principalPolicyCache?: PrincipalPolicyCache | undefined;
+    readonly proof: DocumentPurgeProofResponse;
+    readonly resolveUserKey: ProjectionUserKeyResolver;
+}
+interface VerifiedDocumentPurgeProofCommit {
+    readonly commitCheckpoints: (execSql?: ExecSql) => Promise<void>;
+    readonly documentCheckpoint: AccessManifestCheckpoint;
+}
+type PurgeContainerEvidence = Pick<DocumentPurgeProofResponse, "authorizingContainerPath" | "documentContainerManifestHistory" | "documentManifestContainerPaths">;
+export declare function verifyPurgeContainerPaths(input: {
+    readonly authorizationEvidence: readonly PrincipalPolicyAuthorization[];
+    readonly checkpointContext: ReturnType<typeof createProjectionCheckpointContext>;
+    readonly principalPolicyCache: PrincipalPolicyCache;
+    readonly proof: PurgeContainerEvidence;
+    readonly resolveUserKey: ProjectionUserKeyResolver;
+}): Promise<{
+    authorizingContainerPath: VerifiedContainerAccessManifest[];
+    containerPathByManifestHash: Map<string, readonly VerifiedContainerAccessManifest[]>;
+    verifiedContainerManifests: Map<string, VerifiedContainerAccessManifest>;
+}>;
+export declare function verifyDocumentPurgeProofBaseline(input: VerifyDocumentPurgeProofInput): Promise<Pick<VerifiedDocumentPurgeProofCommit, "documentCheckpoint">>;
+export declare function verifyDocumentPurgeProof(input: VerifyDocumentPurgeProofInput): Promise<VerifiedDocumentPurgeProofCommit>;
+export {};

package/data/keyingProjectionVerification/documentPurge/documentPurgeProofVerification.js

@@ -0,0 +1,208 @@
+import { KeyingVerificationError, } from "../../../internal/crypto/index.js";
+import { isDocumentPurgeProofResponse } from "../../../internal/validators/response/index.js";
+import { addBundleByHash } from "../checkpoints/bundleVerification.js";
+import { createProjectionCheckpointContext, observeAccessManifestCheckpoints, } from "../checkpoints/checkpointContext.js";
+import { verifyContainerManifestPath } from "../container/containerPathVerification.js";
+import { verifiedContainerManifestsForBundles } from "../container/containerProjectionVerification.js";
+import { verifyProjectionPolicyEvidence } from "../principalPolicy/projectionPolicyEvidence.js";
+import { observeProjectionLifetime } from "../projectionLifetimes.js";
+import { readAccessManifest } from "../readers.js";
+import { assertProjectionVerificationCurrent, } from "../types.js";
+import { commitDocumentPurgeCheckpoints, validateDocumentPurgeCheckpoints, } from "./documentPurgeCheckpointCurrency.js";
+import { recoverDocumentPurgePolicyCurrency } from "./documentPurgePolicyCurrency.js";
+import { authenticateDocumentPurgeArtifacts } from "./documentPurgePrincipalEvidence.js";
+function collectContainerBundles(proof) {
+    const bundlesByHash = new Map();
+    for (const [index, bundle] of proof.authorizingContainerPath.entries()) {
+        addBundleByHash(bundlesByHash, bundle, `Document purge authorizing container path[${index}]`);
+    }
+    for (const [index, bundle,] of proof.documentContainerManifestHistory.entries()) {
+        addBundleByHash(bundlesByHash, bundle, `Document purge container history[${index}]`);
+    }
+    for (const [pathIndex, path,] of proof.documentManifestContainerPaths.entries()) {
+        for (const [bundleIndex, bundle] of path.entries()) {
+            addBundleByHash(bundlesByHash, bundle, `Document purge dependency path[${pathIndex}][${bundleIndex}]`);
+        }
+    }
+    return bundlesByHash;
+}
+export async function verifyPurgeContainerPaths(input) {
+    const bundlesByHash = collectContainerBundles(input.proof);
+    const verifiedByHash = new Map();
+    const authorizingContainerPath = await verifyContainerManifestPath({
+        servedAsCurrent: false,
+        authorizationMembership: "referenced",
+        authorizationEvidence: input.authorizationEvidence,
+        bundlesByHash,
+        checkpointContext: input.checkpointContext,
+        // Authenticate the signed path here; the complete purge's local currency
+        // is checked after its event and document evidence have authenticated.
+        enforceLocalCheckpoints: false,
+        label: "Document purge authorizing container path",
+        path: input.proof.authorizingContainerPath,
+        principalPolicyCache: input.principalPolicyCache,
+        resolveUserKey: input.resolveUserKey,
+        requireAuthorizationEvidence: true,
+        verifiedByHash,
+    });
+    const authorizingLeaf = authorizingContainerPath.at(-1);
+    if (!authorizingLeaf) {
+        throw new KeyingVerificationError("missing_dependency", "Document purge authorizing container path is empty");
+    }
+    const containerPathByManifestHash = new Map();
+    containerPathByManifestHash.set(authorizingLeaf.manifestHash, [
+        ...authorizingContainerPath,
+    ]);
+    for (const [index, path,] of input.proof.documentManifestContainerPaths.entries()) {
+        const verifiedPath = await verifyContainerManifestPath({
+            servedAsCurrent: false,
+            authorizationMembership: "referenced",
+            authorizationEvidence: input.authorizationEvidence,
+            bundlesByHash,
+            checkpointContext: input.checkpointContext,
+            enforceLocalCheckpoints: false,
+            label: `Document purge dependency path[${index}]`,
+            path,
+            principalPolicyCache: input.principalPolicyCache,
+            resolveUserKey: input.resolveUserKey,
+            requireAuthorizationEvidence: true,
+            verifiedByHash,
+        });
+        const leaf = verifiedPath.at(-1);
+        if (leaf && !containerPathByManifestHash.has(leaf.manifestHash)) {
+            containerPathByManifestHash.set(leaf.manifestHash, verifiedPath);
+        }
+    }
+    // Purge verification consumes event citations only, never content-write
+    // headers, so historical evidence needs no pinned target-path grouping.
+    for (const [hash, manifest] of verifiedByHash) {
+        if (!containerPathByManifestHash.has(hash)) {
+            containerPathByManifestHash.set(hash, [manifest]);
+        }
+    }
+    observeAccessManifestCheckpoints(input.checkpointContext, {
+        verifiedHeads: authorizingContainerPath,
+        verifiedManifests: verifiedContainerManifestsForBundles(bundlesByHash, verifiedByHash),
+    });
+    return {
+        authorizingContainerPath,
+        containerPathByManifestHash,
+        verifiedContainerManifests: new Map(verifiedByHash),
+    };
+}
+function requirePurgeProofShape(proof) {
+    if (!isDocumentPurgeProofResponse(proof)) {
+        throw new KeyingVerificationError("invalid_shape", "Document purge proof has an invalid shape");
+    }
+}
+function requirePurgeOrganization(actual, expected) {
+    if (actual !== expected)
+        throw new KeyingVerificationError("object_mismatch", "Document purge proof belongs to another organization");
+}
+async function recoverPurgePolicyEvidence(input) {
+    const references = [...collectContainerBundles(input.proof).values()].flatMap((bundle) => readAccessManifest(bundle.manifest, "Purge container manifest")
+        .referencedPrincipalHeads);
+    if (!references.length &&
+        (input.proof.policyEvidence.organization ||
+            input.proof.policyEvidence.groups.length ||
+            input.proof.policyEvidence.organizationPayloads.length))
+        throw new KeyingVerificationError("invalid_shape", "Document purge proof includes unrelated principal policy evidence");
+    return verifyProjectionPolicyEvidence({
+        evidence: input.proof.policyEvidence,
+        organizationId: input.expectedOrganizationId,
+        references,
+        historicalProof: true,
+        stillCurrent: input.stillCurrent,
+        warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,
+    });
+}
+function purgePrincipalSourceHeads(proof) {
+    return [
+        proof.policyEvidence.organization,
+        ...proof.policyEvidence.groups,
+    ].flatMap((source) => (source ? [source.head] : []));
+}
+async function verifyDocumentPurgeProofWithMode(input, enforceLocalCheckpoints) {
+    requirePurgeProofShape(input.proof);
+    input = { ...input, proof: structuredClone(input.proof) };
+    if (input.proof.documentId !== input.expectedDocumentId ||
+        input.proof.documentManifest.manifestHash.length === 0) {
+        throw new KeyingVerificationError("object_mismatch", "Document purge proof targets the wrong document");
+    }
+    const checkpointContext = createProjectionCheckpointContext({
+        execSql: input.execSql,
+        organizationId: input.expectedOrganizationId,
+    });
+    const principalPolicyCache = input.principalPolicyCache ?? new Map();
+    const recovered = await recoverPurgePolicyEvidence(input);
+    observeProjectionLifetime(checkpointContext, recovered.stillCurrent);
+    const authorizationEvidence = recovered.policies;
+    const { authorizingContainerPath, containerPathByManifestHash, verifiedContainerManifests, } = await verifyPurgeContainerPaths({
+        authorizationEvidence,
+        checkpointContext,
+        principalPolicyCache,
+        proof: input.proof,
+        resolveUserKey: input.resolveUserKey,
+    });
+    const { documentManifest, principalPolicies, purgeEventHash } = await authenticateDocumentPurgeArtifacts({
+        authorizationEvidence,
+        authorizingContainerPath,
+        checkpointContext,
+        containerPathByManifestHash,
+        enforceLocalCheckpoints,
+        expectedDocumentId: input.expectedDocumentId,
+        principalPolicyCache,
+        proof: input.proof,
+        resolveUserKey: input.resolveUserKey,
+        verifiedContainerManifests,
+    });
+    requirePurgeOrganization(documentManifest.state.organizationId, input.expectedOrganizationId);
+    const observedPrincipalHeads = purgePrincipalSourceHeads(input.proof);
+    assertProjectionVerificationCurrent(recovered.stillCurrent);
+    const currencyPolicies = enforceLocalCheckpoints
+        ? await recoverDocumentPurgePolicyCurrency({
+            context: checkpointContext,
+            organizationId: input.expectedOrganizationId,
+            policies: principalPolicies,
+            warmer: input.warmReferencedPrincipalPolicies,
+            stillCurrent: recovered.stillCurrent,
+        })
+        : principalPolicies;
+    if (enforceLocalCheckpoints) {
+        await validateDocumentPurgeCheckpoints({
+            context: checkpointContext,
+            execSql: input.execSql,
+            principalPolicies,
+            currencyPolicies,
+            observedPrincipalHeads,
+        });
+    }
+    const documentPurgeCheckpoint = {
+        documentId: input.expectedDocumentId,
+        documentManifestHash: documentManifest.manifestHash,
+        organizationId: documentManifest.state.organizationId,
+        purgeEventHash,
+    };
+    return {
+        commitCheckpoints: (execSql = input.execSql) => commitDocumentPurgeCheckpoints({
+            context: checkpointContext,
+            documentPurgeCheckpoint,
+            execSql,
+            principalPolicies,
+            currencyPolicies,
+            observedPrincipalHeads,
+        }),
+        documentCheckpoint: documentManifest.checkpoint,
+    };
+}
+export async function verifyDocumentPurgeProofBaseline(input) {
+    requirePurgeProofShape(input.proof);
+    const verified = await verifyDocumentPurgeProofWithMode(input, false);
+    return {
+        documentCheckpoint: verified.documentCheckpoint,
+    };
+}
+export function verifyDocumentPurgeProof(input) {
+    return verifyDocumentPurgeProofWithMode(input, true);
+}
+//# sourceMappingURL=documentPurgeProofVerification.js.map

package/data/keyingProjectionVerification/documentPurge/documentPurgeProofVerification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentPurgeProofVerification.js","sourceRoot":"","sources":["documentPurgeProofVerification.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type AccessManifestCheckpoint,\n  KeyingVerificationError,\n  type PrincipalPolicyAuthorization,\n  type VerifiedContainerAccessManifest,\n  type VerifiedPrincipalPolicy,\n} from \"@tearleads/crypto\";\nimport type {\n  AccessManifestBundleWireResponse,\n  DocumentPurgeProofResponse,\n} from \"@tearleads/validators/response\";\nimport { isDocumentPurgeProofResponse } from \"@tearleads/validators/response\";\nimport type { ExecSql } from \"../../sqlite/sqlSchema\";\nimport { addBundleByHash } from \"../checkpoints/bundleVerification\";\nimport {\n  createProjectionCheckpointContext,\n  observeAccessManifestCheckpoints,\n} from \"../checkpoints/checkpointContext\";\nimport { verifyContainerManifestPath } from \"../container/containerPathVerification\";\nimport { verifiedContainerManifestsForBundles } from \"../container/containerProjectionVerification\";\nimport { verifyProjectionPolicyEvidence } from \"../principalPolicy/projectionPolicyEvidence\";\nimport { observeProjectionLifetime } from \"../projectionLifetimes\";\nimport { readAccessManifest } from \"../readers\";\nimport {\n  assertProjectionVerificationCurrent,\n  type PrincipalPolicyCache,\n  type ProjectionUserKeyResolver,\n  type ReferencedPrincipalPolicyWarmer,\n} from \"../types\";\nimport {\n  commitDocumentPurgeCheckpoints,\n  validateDocumentPurgeCheckpoints,\n} from \"./documentPurgeCheckpointCurrency\";\nimport { recoverDocumentPurgePolicyCurrency } from \"./documentPurgePolicyCurrency\";\nimport { authenticateDocumentPurgeArtifacts } from \"./documentPurgePrincipalEvidence\";\n\ninterface VerifyDocumentPurgeProofInput {\n  readonly stillCurrent?: (() => boolean) | undefined;\n  readonly warmReferencedPrincipalPolicies?:\n    | ReferencedPrincipalPolicyWarmer\n    | undefined;\n  readonly execSql: ExecSql;\n  readonly expectedDocumentId: string;\n  readonly expectedOrganizationId: string;\n  readonly principalPolicyCache?: PrincipalPolicyCache | undefined;\n  readonly proof: DocumentPurgeProofResponse;\n  readonly resolveUserKey: ProjectionUserKeyResolver;\n}\n\ninterface VerifiedDocumentPurgeProofCommit {\n  readonly commitCheckpoints: (execSql?: ExecSql) => Promise<void>;\n  readonly documentCheckpoint: AccessManifestCheckpoint;\n}\n\ntype PurgeContainerEvidence = Pick<\n  DocumentPurgeProofResponse,\n  | \"authorizingContainerPath\"\n  | \"documentContainerManifestHistory\"\n  | \"documentManifestContainerPaths\"\n>;\n\nfunction collectContainerBundles(\n  proof: PurgeContainerEvidence,\n): Map<string, AccessManifestBundleWireResponse> {\n  const bundlesByHash = new Map<string, AccessManifestBundleWireResponse>();\n  for (const [index, bundle] of proof.authorizingContainerPath.entries()) {\n    addBundleByHash(\n      bundlesByHash,\n      bundle,\n      `Document purge authorizing container path[${index}]`,\n    );\n  }\n  for (const [\n    index,\n    bundle,\n  ] of proof.documentContainerManifestHistory.entries()) {\n    addBundleByHash(\n      bundlesByHash,\n      bundle,\n      `Document purge container history[${index}]`,\n    );\n  }\n  for (const [\n    pathIndex,\n    path,\n  ] of proof.documentManifestContainerPaths.entries()) {\n    for (const [bundleIndex, bundle] of path.entries()) {\n      addBundleByHash(\n        bundlesByHash,\n        bundle,\n        `Document purge dependency path[${pathIndex}][${bundleIndex}]`,\n      );\n    }\n  }\n  return bundlesByHash;\n}\n\nexport async function verifyPurgeContainerPaths(input: {\n  readonly authorizationEvidence: readonly PrincipalPolicyAuthorization[];\n  readonly checkpointContext: ReturnType<\n    typeof createProjectionCheckpointContext\n  >;\n  readonly principalPolicyCache: PrincipalPolicyCache;\n  readonly proof: PurgeContainerEvidence;\n  readonly resolveUserKey: ProjectionUserKeyResolver;\n}) {\n  const bundlesByHash = collectContainerBundles(input.proof);\n  const verifiedByHash = new Map<string, VerifiedContainerAccessManifest>();\n  const authorizingContainerPath = await verifyContainerManifestPath({\n    servedAsCurrent: false,\n    authorizationMembership: \"referenced\",\n    authorizationEvidence: input.authorizationEvidence,\n    bundlesByHash,\n    checkpointContext: input.checkpointContext,\n    // Authenticate the signed path here; the complete purge's local currency\n    // is checked after its event and document evidence have authenticated.\n    enforceLocalCheckpoints: false,\n    label: \"Document purge authorizing container path\",\n    path: input.proof.authorizingContainerPath,\n    principalPolicyCache: input.principalPolicyCache,\n    resolveUserKey: input.resolveUserKey,\n    requireAuthorizationEvidence: true,\n    verifiedByHash,\n  });\n  const authorizingLeaf = authorizingContainerPath.at(-1);\n  if (!authorizingLeaf) {\n    throw new KeyingVerificationError(\n      \"missing_dependency\",\n      \"Document purge authorizing container path is empty\",\n    );\n  }\n  const containerPathByManifestHash = new Map<\n    string,\n    readonly VerifiedContainerAccessManifest[]\n  >();\n  containerPathByManifestHash.set(authorizingLeaf.manifestHash, [\n    ...authorizingContainerPath,\n  ]);\n  for (const [\n    index,\n    path,\n  ] of input.proof.documentManifestContainerPaths.entries()) {\n    const verifiedPath = await verifyContainerManifestPath({\n      servedAsCurrent: false,\n      authorizationMembership: \"referenced\",\n      authorizationEvidence: input.authorizationEvidence,\n      bundlesByHash,\n      checkpointContext: input.checkpointContext,\n      enforceLocalCheckpoints: false,\n      label: `Document purge dependency path[${index}]`,\n      path,\n      principalPolicyCache: input.principalPolicyCache,\n      resolveUserKey: input.resolveUserKey,\n      requireAuthorizationEvidence: true,\n      verifiedByHash,\n    });\n    const leaf = verifiedPath.at(-1);\n    if (leaf && !containerPathByManifestHash.has(leaf.manifestHash)) {\n      containerPathByManifestHash.set(leaf.manifestHash, verifiedPath);\n    }\n  }\n  // Purge verification consumes event citations only, never content-write\n  // headers, so historical evidence needs no pinned target-path grouping.\n  for (const [hash, manifest] of verifiedByHash) {\n    if (!containerPathByManifestHash.has(hash)) {\n      containerPathByManifestHash.set(hash, [manifest]);\n    }\n  }\n  observeAccessManifestCheckpoints(input.checkpointContext, {\n    verifiedHeads: authorizingContainerPath,\n    verifiedManifests: verifiedContainerManifestsForBundles(\n      bundlesByHash,\n      verifiedByHash,\n    ),\n  });\n  return {\n    authorizingContainerPath,\n    containerPathByManifestHash,\n    verifiedContainerManifests: new Map(verifiedByHash),\n  };\n}\n\nfunction requirePurgeProofShape(\n  proof: unknown,\n): asserts proof is DocumentPurgeProofResponse {\n  if (!isDocumentPurgeProofResponse(proof)) {\n    throw new KeyingVerificationError(\n      \"invalid_shape\",\n      \"Document purge proof has an invalid shape\",\n    );\n  }\n}\n\nfunction requirePurgeOrganization(actual: string, expected: string): void {\n  if (actual !== expected)\n    throw new KeyingVerificationError(\n      \"object_mismatch\",\n      \"Document purge proof belongs to another organization\",\n    );\n}\n\nasync function recoverPurgePolicyEvidence(\n  input: VerifyDocumentPurgeProofInput,\n) {\n  const references = [...collectContainerBundles(input.proof).values()].flatMap(\n    (bundle) =>\n      readAccessManifest(bundle.manifest, \"Purge container manifest\")\n        .referencedPrincipalHeads,\n  );\n  if (\n    !references.length &&\n    (input.proof.policyEvidence.organization ||\n      input.proof.policyEvidence.groups.length ||\n      input.proof.policyEvidence.organizationPayloads.length)\n  )\n    throw new KeyingVerificationError(\n      \"invalid_shape\",\n      \"Document purge proof includes unrelated principal policy evidence\",\n    );\n  return verifyProjectionPolicyEvidence({\n    evidence: input.proof.policyEvidence,\n    organizationId: input.expectedOrganizationId,\n    references,\n    historicalProof: true,\n    stillCurrent: input.stillCurrent,\n    warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,\n  });\n}\n\nfunction purgePrincipalSourceHeads(proof: DocumentPurgeProofResponse) {\n  return [\n    proof.policyEvidence.organization,\n    ...proof.policyEvidence.groups,\n  ].flatMap((source) => (source ? [source.head] : []));\n}\n\nasync function verifyDocumentPurgeProofWithMode(\n  input: VerifyDocumentPurgeProofInput,\n  enforceLocalCheckpoints: boolean,\n): Promise<VerifiedDocumentPurgeProofCommit> {\n  requirePurgeProofShape(input.proof);\n  input = { ...input, proof: structuredClone(input.proof) };\n  if (\n    input.proof.documentId !== input.expectedDocumentId ||\n    input.proof.documentManifest.manifestHash.length === 0\n  ) {\n    throw new KeyingVerificationError(\n      \"object_mismatch\",\n      \"Document purge proof targets the wrong document\",\n    );\n  }\n  const checkpointContext = createProjectionCheckpointContext({\n    execSql: input.execSql,\n    organizationId: input.expectedOrganizationId,\n  });\n  const principalPolicyCache =\n    input.principalPolicyCache ?? new Map<string, VerifiedPrincipalPolicy>();\n  const recovered = await recoverPurgePolicyEvidence(input);\n  observeProjectionLifetime(checkpointContext, recovered.stillCurrent);\n  const authorizationEvidence = recovered.policies;\n  const {\n    authorizingContainerPath,\n    containerPathByManifestHash,\n    verifiedContainerManifests,\n  } = await verifyPurgeContainerPaths({\n    authorizationEvidence,\n    checkpointContext,\n    principalPolicyCache,\n    proof: input.proof,\n    resolveUserKey: input.resolveUserKey,\n  });\n  const { documentManifest, principalPolicies, purgeEventHash } =\n    await authenticateDocumentPurgeArtifacts({\n      authorizationEvidence,\n      authorizingContainerPath,\n      checkpointContext,\n      containerPathByManifestHash,\n      enforceLocalCheckpoints,\n      expectedDocumentId: input.expectedDocumentId,\n      principalPolicyCache,\n      proof: input.proof,\n      resolveUserKey: input.resolveUserKey,\n      verifiedContainerManifests,\n    });\n  requirePurgeOrganization(\n    documentManifest.state.organizationId,\n    input.expectedOrganizationId,\n  );\n  const observedPrincipalHeads = purgePrincipalSourceHeads(input.proof);\n  assertProjectionVerificationCurrent(recovered.stillCurrent);\n  const currencyPolicies = enforceLocalCheckpoints\n    ? await recoverDocumentPurgePolicyCurrency({\n        context: checkpointContext,\n        organizationId: input.expectedOrganizationId,\n        policies: principalPolicies,\n        warmer: input.warmReferencedPrincipalPolicies,\n        stillCurrent: recovered.stillCurrent,\n      })\n    : principalPolicies;\n  if (enforceLocalCheckpoints) {\n    await validateDocumentPurgeCheckpoints({\n      context: checkpointContext,\n      execSql: input.execSql,\n      principalPolicies,\n      currencyPolicies,\n      observedPrincipalHeads,\n    });\n  }\n  const documentPurgeCheckpoint = {\n    documentId: input.expectedDocumentId,\n    documentManifestHash: documentManifest.manifestHash,\n    organizationId: documentManifest.state.organizationId,\n    purgeEventHash,\n  };\n  return {\n    commitCheckpoints: (execSql = input.execSql) =>\n      commitDocumentPurgeCheckpoints({\n        context: checkpointContext,\n        documentPurgeCheckpoint,\n        execSql,\n        principalPolicies,\n        currencyPolicies,\n        observedPrincipalHeads,\n      }),\n    documentCheckpoint: documentManifest.checkpoint,\n  };\n}\n\nexport async function verifyDocumentPurgeProofBaseline(\n  input: VerifyDocumentPurgeProofInput,\n): Promise<Pick<VerifiedDocumentPurgeProofCommit, \"documentCheckpoint\">> {\n  requirePurgeProofShape(input.proof);\n  const verified = await verifyDocumentPurgeProofWithMode(input, false);\n  return {\n    documentCheckpoint: verified.documentCheckpoint,\n  };\n}\n\nexport function verifyDocumentPurgeProof(\n  input: VerifyDocumentPurgeProofInput,\n): Promise<VerifiedDocumentPurgeProofCommit> {\n  return verifyDocumentPurgeProofWithMode(input, true);\n}\n"]}

package/data/keyingProjectionVerification/index.d.ts

@@ -1,9 +1,9 @@
 import type { ProjectionUserKeyResolver } from "./types.js";
-export { resolveEventContainerPaths } from "./documentDependencyPaths.js";
+export { resolveEventContainerPaths } from "./document/documentDependencyPaths.js";
 export { readAccessEvent, readRecordString, readRequiredRecordValue, } from "./readers.js";
 export type { PrincipalPolicyCache, ProjectionUserKeyResolver, ReferencedPrincipalPolicyWarmer, } from "./types.js";
 export { isProjectionVerificationCancelledError, nullOnProjectionVerificationCancellation, } from "./types.js";
 export declare function requireProjectionUserKeyResolver(resolveProjectionUserKey: ProjectionUserKeyResolver | null | undefined, label: string): ProjectionUserKeyResolver;
-export { collectContainerWriterProjectionPrincipalPolicies, verifyContainerWriterProjection, } from "./containerProjectionVerification.js";
-export { type DocumentWriterProjectionAuthorization, verifyDocumentWriterProjection, verifyDocumentWriterProjectionAuthorization, } from "./documentProjectionVerification.js";
-export { verifyDocumentPurgeProof, verifyDocumentPurgeProofBaseline, } from "./documentPurgeProofVerification.js";
+export { collectContainerWriterProjectionPrincipalPolicies, verifyContainerWriterProjection, } from "./container/containerProjectionVerification.js";
+export { type DocumentWriterProjectionAuthorization, verifyDocumentWriterProjection, verifyDocumentWriterProjectionAuthorization, } from "./document/documentProjectionVerification.js";
+export { verifyDocumentPurgeProof, verifyDocumentPurgeProofBaseline, } from "./documentPurge/documentPurgeProofVerification.js";

package/data/keyingProjectionVerification/index.js

@@ -1,5 +1,5 @@
 import { requireTrustedUserIdentityResolver } from "../trustedUserIdentity/requiredResolver.js";
-export { resolveEventContainerPaths } from "./documentDependencyPaths.js";
+export { resolveEventContainerPaths } from "./document/documentDependencyPaths.js";
 export { readAccessEvent, readRecordString, readRequiredRecordValue, } from "./readers.js";
 export { isProjectionVerificationCancelledError, nullOnProjectionVerificationCancellation, } from "./types.js";
 export function requireProjectionUserKeyResolver(resolveProjectionUserKey, label) {
@@ -10,7 +10,7 @@ export function requireProjectionUserKeyResolver(resolveProjectionUserKey, label
     // provides the untrusted-shape and wrong-user guards (with identity caching).
     return requireTrustedUserIdentityResolver(resolveProjectionUserKey);
 }
-export { collectContainerWriterProjectionPrincipalPolicies, verifyContainerWriterProjection, } from "./containerProjectionVerification.js";
-export { verifyDocumentWriterProjection, verifyDocumentWriterProjectionAuthorization, } from "./documentProjectionVerification.js";
-export { verifyDocumentPurgeProof, verifyDocumentPurgeProofBaseline, } from "./documentPurgeProofVerification.js";
+export { collectContainerWriterProjectionPrincipalPolicies, verifyContainerWriterProjection, } from "./container/containerProjectionVerification.js";
+export { verifyDocumentWriterProjection, verifyDocumentWriterProjectionAuthorization, } from "./document/documentProjectionVerification.js";
+export { verifyDocumentPurgeProof, verifyDocumentPurgeProofBaseline, } from "./documentPurge/documentPurgeProofVerification.js";
 //# sourceMappingURL=index.js.map

package/data/keyingProjectionVerification/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yCAAyC,CAAC;AAG7F,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,WAAW,CAAC;AAOnB,OAAO,EACL,sCAAsC,EACtC,wCAAwC,GACzC,MAAM,SAAS,CAAC;AAEjB,MAAM,UAAU,gCAAgC,CAC9C,wBAAsE,EACtE,KAAa;IAEb,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,uCAAuC,CAAC,CAAC;IACnE,CAAC;IAED,sEAAsE;IACtE,8EAA8E;IAC9E,OAAO,kCAAkC,CAAC,wBAAwB,CAAC,CAAC;AACtE,CAAC;AAED,OAAO,EACL,iDAAiD,EACjD,+BAA+B,GAChC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAEL,8BAA8B,EAC9B,2CAA2C,GAC5C,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,wBAAwB,EACxB,gCAAgC,GACjC,MAAM,kCAAkC,CAAC","sourcesContent":["import { requireTrustedUserIdentityResolver } from \"../trustedUserIdentity/requiredResolver\";\nimport type { ProjectionUserKeyResolver } from \"./types\";\n\nexport { resolveEventContainerPaths } from \"./documentDependencyPaths\";\nexport {\n  readAccessEvent,\n  readRecordString,\n  readRequiredRecordValue,\n} from \"./readers\";\n\nexport type {\n  PrincipalPolicyCache,\n  ProjectionUserKeyResolver,\n  ReferencedPrincipalPolicyWarmer,\n} from \"./types\";\nexport {\n  isProjectionVerificationCancelledError,\n  nullOnProjectionVerificationCancellation,\n} from \"./types\";\n\nexport function requireProjectionUserKeyResolver(\n  resolveProjectionUserKey: ProjectionUserKeyResolver | null | undefined,\n  label: string,\n): ProjectionUserKeyResolver {\n  if (!resolveProjectionUserKey) {\n    throw new Error(`${label} requires projection key verification`);\n  }\n\n  // A ProjectionUserKey is a TrustedUserIdentity, so the shared adapter\n  // provides the untrusted-shape and wrong-user guards (with identity caching).\n  return requireTrustedUserIdentityResolver(resolveProjectionUserKey);\n}\n\nexport {\n  collectContainerWriterProjectionPrincipalPolicies,\n  verifyContainerWriterProjection,\n} from \"./containerProjectionVerification\";\nexport {\n  type DocumentWriterProjectionAuthorization,\n  verifyDocumentWriterProjection,\n  verifyDocumentWriterProjectionAuthorization,\n} from \"./documentProjectionVerification\";\nexport {\n  verifyDocumentPurgeProof,\n  verifyDocumentPurgeProofBaseline,\n} from \"./documentPurgeProofVerification\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yCAAyC,CAAC;AAG7F,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,WAAW,CAAC;AAOnB,OAAO,EACL,sCAAsC,EACtC,wCAAwC,GACzC,MAAM,SAAS,CAAC;AAEjB,MAAM,UAAU,gCAAgC,CAC9C,wBAAsE,EACtE,KAAa;IAEb,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,uCAAuC,CAAC,CAAC;IACnE,CAAC;IAED,sEAAsE;IACtE,8EAA8E;IAC9E,OAAO,kCAAkC,CAAC,wBAAwB,CAAC,CAAC;AACtE,CAAC;AAED,OAAO,EACL,iDAAiD,EACjD,+BAA+B,GAChC,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAEL,8BAA8B,EAC9B,2CAA2C,GAC5C,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACL,wBAAwB,EACxB,gCAAgC,GACjC,MAAM,gDAAgD,CAAC","sourcesContent":["import { requireTrustedUserIdentityResolver } from \"../trustedUserIdentity/requiredResolver\";\nimport type { ProjectionUserKeyResolver } from \"./types\";\n\nexport { resolveEventContainerPaths } from \"./document/documentDependencyPaths\";\nexport {\n  readAccessEvent,\n  readRecordString,\n  readRequiredRecordValue,\n} from \"./readers\";\n\nexport type {\n  PrincipalPolicyCache,\n  ProjectionUserKeyResolver,\n  ReferencedPrincipalPolicyWarmer,\n} from \"./types\";\nexport {\n  isProjectionVerificationCancelledError,\n  nullOnProjectionVerificationCancellation,\n} from \"./types\";\n\nexport function requireProjectionUserKeyResolver(\n  resolveProjectionUserKey: ProjectionUserKeyResolver | null | undefined,\n  label: string,\n): ProjectionUserKeyResolver {\n  if (!resolveProjectionUserKey) {\n    throw new Error(`${label} requires projection key verification`);\n  }\n\n  // A ProjectionUserKey is a TrustedUserIdentity, so the shared adapter\n  // provides the untrusted-shape and wrong-user guards (with identity caching).\n  return requireTrustedUserIdentityResolver(resolveProjectionUserKey);\n}\n\nexport {\n  collectContainerWriterProjectionPrincipalPolicies,\n  verifyContainerWriterProjection,\n} from \"./container/containerProjectionVerification\";\nexport {\n  type DocumentWriterProjectionAuthorization,\n  verifyDocumentWriterProjection,\n  verifyDocumentWriterProjectionAuthorization,\n} from \"./document/documentProjectionVerification\";\nexport {\n  verifyDocumentPurgeProof,\n  verifyDocumentPurgeProofBaseline,\n} from \"./documentPurge/documentPurgeProofVerification\";\n"]}

package/data/keyingProjectionVerification/principalPolicy/mergeProjectionPolicyEvidence.js

@@ -0,0 +1,45 @@
+import { KeyingVerificationError } from "../../../internal/crypto/index.js";
+import { principalHeadMatchesReference } from "../../principals/organizationAuthorityDescriptor.js";
+function newer(previous, next) {
+    if (!previous)
+        return true;
+    if (previous.head.principalId !== next.head.principalId)
+        throw new KeyingVerificationError("object_mismatch", "Projection evidence crosses principals");
+    if (previous.head.version === next.head.version &&
+        !principalHeadMatchesReference(previous.head, next.head))
+        throw new KeyingVerificationError("hash_mismatch", "Projection evidence contains conflicting heads");
+    return previous.head.version < next.head.version;
+}
+/** Combine proof material when locally composing projections; verification follows. */
+export function mergeProjectionPolicyEvidence(evidence) {
+    let directory;
+    const groups = new Map();
+    const payloads = new Map();
+    for (const proof of evidence) {
+        const organization = proof.organization;
+        if (organization && newer(directory?.organization, organization))
+            directory = proof;
+        for (const payload of proof.organizationPayloads) {
+            const previous = payloads.get(payload.reference.stateHash);
+            if (previous &&
+                (!principalHeadMatchesReference(previous.reference, payload.reference) ||
+                    previous.payload.principalId !== payload.payload.principalId ||
+                    previous.payload.principalType !== payload.payload.principalType ||
+                    previous.payload.ciphertext !== payload.payload.ciphertext ||
+                    previous.payload.ciphertextHash !== payload.payload.ciphertextHash))
+                throw new KeyingVerificationError("hash_mismatch", "Projection evidence contains conflicting directory payloads");
+            payloads.set(payload.reference.stateHash, payload);
+        }
+        for (const group of proof.groups) {
+            const prior = groups.get(group.head.principalId);
+            if (newer(prior, group))
+                groups.set(group.head.principalId, group);
+        }
+    }
+    return {
+        organization: directory?.organization ?? null,
+        organizationPayloads: [...payloads.values()],
+        groups: [...groups.values()],
+    };
+}
+//# sourceMappingURL=mergeProjectionPolicyEvidence.js.map