@tearleads/client-sdk 0.1.63 → 0.1.65

package/data/keyingProjectionVerification/documentPurgePolicyCheckpoints.js

@@ -1,17 +0,0 @@
-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/documentPurgePolicyCheckpoints.js.map

@@ -1 +0,0 @@
-{"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,4CAA4C,CAAC;AAGpD,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/documentPurgePolicyCurrency.js

@@ -1,55 +0,0 @@
-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/documentPurgePolicyCurrency.js.map

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

@@ -1,116 +0,0 @@
-import { KeyingVerificationError, principalPolicyMatchesReference, verifyDocumentPurgeEvent, } from "../../internal/crypto/index.js";
-import { parseOrganizationAuthorityDescriptor } from "../principals/organizationAuthorityDescriptor.js";
-import { verifyStandaloneAccessEventBundle } from "./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/documentPurgePrincipalEvidence.js.map

@@ -1 +0,0 @@
-{"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 \"./bundleVerification\";\nimport type { ProjectionCheckpointContext } from \"./checkpointContext\";\nimport { verifyPurgeDocumentManifest } from \"./documentPurgeDocumentChainVerification\";\nimport type { PrincipalPolicyCache, ProjectionUserKeyResolver } from \"./types\";\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/documentPurgeProofVerification.d.ts

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

@@ -1,208 +0,0 @@
-import { KeyingVerificationError, } from "../../internal/crypto/index.js";
-import { isDocumentPurgeProofResponse } from "../../internal/validators/response/index.js";
-import { addBundleByHash } from "./bundleVerification.js";
-import { createProjectionCheckpointContext, observeAccessManifestCheckpoints, } from "./checkpointContext.js";
-import { verifyContainerManifestPath } from "./containerPathVerification.js";
-import { verifiedContainerManifestsForBundles } from "./containerProjectionVerification.js";
-import { commitDocumentPurgeCheckpoints, validateDocumentPurgeCheckpoints, } from "./documentPurgeCheckpointCurrency.js";
-import { recoverDocumentPurgePolicyCurrency } from "./documentPurgePolicyCurrency.js";
-import { authenticateDocumentPurgeArtifacts } from "./documentPurgePrincipalEvidence.js";
-import { observeProjectionLifetime } from "./projectionLifetimes.js";
-import { verifyProjectionPolicyEvidence } from "./projectionPolicyEvidence.js";
-import { readAccessManifest } from "./readers.js";
-import { assertProjectionVerificationCurrent, } from "./types.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/documentPurgeProofVerification.js.map

@@ -1 +0,0 @@
-{"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 \"./bundleVerification\";\nimport {\n  createProjectionCheckpointContext,\n  observeAccessManifestCheckpoints,\n} from \"./checkpointContext\";\nimport { verifyContainerManifestPath } from \"./containerPathVerification\";\nimport { verifiedContainerManifestsForBundles } from \"./containerProjectionVerification\";\nimport {\n  commitDocumentPurgeCheckpoints,\n  validateDocumentPurgeCheckpoints,\n} from \"./documentPurgeCheckpointCurrency\";\nimport { recoverDocumentPurgePolicyCurrency } from \"./documentPurgePolicyCurrency\";\nimport { authenticateDocumentPurgeArtifacts } from \"./documentPurgePrincipalEvidence\";\nimport { observeProjectionLifetime } from \"./projectionLifetimes\";\nimport { verifyProjectionPolicyEvidence } from \"./projectionPolicyEvidence\";\nimport { readAccessManifest } from \"./readers\";\nimport {\n  assertProjectionVerificationCurrent,\n  type PrincipalPolicyCache,\n  type ProjectionUserKeyResolver,\n  type ReferencedPrincipalPolicyWarmer,\n} from \"./types\";\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/manifestCheckpointVerification.js

@@ -1,64 +0,0 @@
-import { verifyAccessManifestLocalCheckpoint, } from "../../internal/crypto/index.js";
-import { loadAccessManifestCheckpoint } from "../persistence/keyingCheckpointPersistence.js";
-/**
- * The local checkpoint for one object, read once per verification: every
- * checkpoint-enforced element of a served path reads its own checkpoint,
- * and the atomic advance re-validates every checkpoint at commit.
- */
-async function loadLocalAccessManifestCheckpoint(input) {
-    const key = JSON.stringify([
-        input.objectKind,
-        input.organizationId,
-        input.objectId,
-    ]);
-    const cached = input.localCheckpoints.get(key);
-    if (cached !== undefined)
-        return cached;
-    const loaded = await loadAccessManifestCheckpoint(input.execSql, input.objectKind, input.organizationId, input.objectId);
-    input.localCheckpoints.set(key, loaded);
-    return loaded;
-}
-function isCheckpointPredecessor(input) {
-    const candidate = input.candidate.checkpoint;
-    return (candidate.objectKind === input.current.objectKind &&
-        candidate.organizationId === input.current.organizationId &&
-        candidate.objectId === input.current.objectId &&
-        candidate.epoch > input.localCheckpoint.epoch &&
-        candidate.epoch < input.current.epoch);
-}
-export async function loadManifestCheckpointVerification(input) {
-    const localCheckpoint = await loadLocalAccessManifestCheckpoint({
-        execSql: input.execSql,
-        localCheckpoints: input.localCheckpoints,
-        objectId: input.current.objectId,
-        objectKind: input.current.objectKind,
-        organizationId: input.current.organizationId,
-    });
-    const checkpointPredecessors = localCheckpoint
-        ? [...input.verifiedManifests.values()]
-            .filter((candidate) => isCheckpointPredecessor({
-            candidate,
-            current: input.current,
-            localCheckpoint,
-        }))
-            .sort((left, right) => left.checkpoint.epoch - right.checkpoint.epoch)
-        : [];
-    return { checkpointPredecessors, localCheckpoint };
-}
-export async function verifyCachedManifestCheckpoint(input) {
-    const checkpoint = await loadManifestCheckpointVerification({
-        current: input.current.manifest,
-        execSql: input.execSql,
-        localCheckpoints: input.localCheckpoints,
-        verifiedManifests: input.verifiedManifests,
-    });
-    verifyAccessManifestLocalCheckpoint({
-        checkpointPredecessors: checkpoint.checkpointPredecessors,
-        current: {
-            ...input.current.checkpoint,
-            previousManifestHash: input.current.manifest.previousManifestHash,
-        },
-        localCheckpoint: checkpoint.localCheckpoint,
-    });
-}
-//# sourceMappingURL=manifestCheckpointVerification.js.map

package/data/keyingProjectionVerification/manifestCheckpointVerification.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifestCheckpointVerification.js","sourceRoot":"","sources":["manifestCheckpointVerification.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type AccessManifest,\n  type AccessManifestCheckpoint,\n  type VerifiedAccessManifestCheckpointEvidence,\n  verifyAccessManifestLocalCheckpoint,\n} from \"@tearleads/crypto\";\nimport { loadAccessManifestCheckpoint } from \"../persistence/keyingCheckpointPersistence\";\nimport type { ExecSql } from \"../sqlite/sqlSchema\";\n\n/**\n * The local checkpoint for one object, read once per verification: every\n * checkpoint-enforced element of a served path reads its own checkpoint,\n * and the atomic advance re-validates every checkpoint at commit.\n */\nasync function loadLocalAccessManifestCheckpoint(input: {\n  readonly execSql: ExecSql;\n  readonly localCheckpoints: Map<string, AccessManifestCheckpoint | null>;\n  readonly objectId: string;\n  readonly objectKind: AccessManifest[\"objectKind\"];\n  readonly organizationId: string;\n}): Promise<AccessManifestCheckpoint | null> {\n  const key = JSON.stringify([\n    input.objectKind,\n    input.organizationId,\n    input.objectId,\n  ]);\n  const cached = input.localCheckpoints.get(key);\n  if (cached !== undefined) return cached;\n  const loaded = await loadAccessManifestCheckpoint(\n    input.execSql,\n    input.objectKind,\n    input.organizationId,\n    input.objectId,\n  );\n  input.localCheckpoints.set(key, loaded);\n  return loaded;\n}\n\ninterface ManifestCheckpointVerificationInput<\n  TManifest extends VerifiedAccessManifestCheckpointEvidence,\n> {\n  readonly checkpointPredecessors: readonly TManifest[];\n  readonly localCheckpoint: AccessManifestCheckpoint | null;\n}\n\nfunction isCheckpointPredecessor(input: {\n  readonly candidate: VerifiedAccessManifestCheckpointEvidence;\n  readonly current: AccessManifest;\n  readonly localCheckpoint: AccessManifestCheckpoint;\n}): boolean {\n  const candidate = input.candidate.checkpoint;\n  return (\n    candidate.objectKind === input.current.objectKind &&\n    candidate.organizationId === input.current.organizationId &&\n    candidate.objectId === input.current.objectId &&\n    candidate.epoch > input.localCheckpoint.epoch &&\n    candidate.epoch < input.current.epoch\n  );\n}\n\nexport async function loadManifestCheckpointVerification<\n  TManifest extends VerifiedAccessManifestCheckpointEvidence,\n>(input: {\n  readonly current: AccessManifest;\n  readonly execSql: ExecSql;\n  readonly localCheckpoints: Map<string, AccessManifestCheckpoint | null>;\n  readonly verifiedManifests: ReadonlyMap<string, TManifest>;\n}): Promise<ManifestCheckpointVerificationInput<TManifest>> {\n  const localCheckpoint = await loadLocalAccessManifestCheckpoint({\n    execSql: input.execSql,\n    localCheckpoints: input.localCheckpoints,\n    objectId: input.current.objectId,\n    objectKind: input.current.objectKind,\n    organizationId: input.current.organizationId,\n  });\n  const checkpointPredecessors = localCheckpoint\n    ? [...input.verifiedManifests.values()]\n        .filter((candidate) =>\n          isCheckpointPredecessor({\n            candidate,\n            current: input.current,\n            localCheckpoint,\n          }),\n        )\n        .sort((left, right) => left.checkpoint.epoch - right.checkpoint.epoch)\n    : [];\n  return { checkpointPredecessors, localCheckpoint };\n}\n\nexport async function verifyCachedManifestCheckpoint(input: {\n  readonly current: VerifiedAccessManifestCheckpointEvidence;\n  readonly execSql: ExecSql;\n  readonly localCheckpoints: Map<string, AccessManifestCheckpoint | null>;\n  readonly verifiedManifests: ReadonlyMap<\n    string,\n    VerifiedAccessManifestCheckpointEvidence\n  >;\n}): Promise<void> {\n  const checkpoint = await loadManifestCheckpointVerification({\n    current: input.current.manifest,\n    execSql: input.execSql,\n    localCheckpoints: input.localCheckpoints,\n    verifiedManifests: input.verifiedManifests,\n  });\n  verifyAccessManifestLocalCheckpoint({\n    checkpointPredecessors: checkpoint.checkpointPredecessors,\n    current: {\n      ...input.current.checkpoint,\n      previousManifestHash: input.current.manifest.previousManifestHash,\n    },\n    localCheckpoint: checkpoint.localCheckpoint,\n  });\n}\n"]}