@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/data/keyingProjectionVerification/readers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readers.js","sourceRoot":"","sources":["readers.ts"],"names":[],"mappings":"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","sourcesContent":["import { normalizeDocumentAccessEventBody } from \"@tearleads/crypto\";\n\nexport {\n  readRecordNullableString,\n  readRecordString,\n  readRequiredRecordValue,\n} from \"../recordReaders\";\n\nimport type {\n  AccessEvent,\n  AccessManifest,\n  ContainerKekRecipientTarget,\n  ContainerKeyEpoch,\n  ContainerKeyWrap,\n  DocumentLinkAccessEventBody,\n  DocumentUnlinkAccessEventBody,\n} from \"@tearleads/crypto\";\nimport { readCanonicalJson, readCanonicalRecord } from \"../keyingCanonicalJson\";\nimport {\n  readRecordNullableString,\n  readRecordPositiveInteger,\n  readRecordString,\n  readRequiredRecordValue,\n  readStringArray,\n} from \"../recordReaders\";\nimport { readKeyingVerificationShape } from \"./error\";\n\nfunction isAccessEventType(value: unknown): value is AccessEvent[\"eventType\"] {\n  return (\n    value === \"attachment.bind\" ||\n    value === \"attachment.detach\" ||\n    value === \"container.create\" ||\n    value === \"container.grant\" ||\n    value === \"container.move\" ||\n    value === \"container.rekey\" ||\n    value === \"container.recite\" ||\n    value === \"container.revoke\" ||\n    value === \"document.link\" ||\n    value === \"document.purge\" ||\n    value === \"document.unlink\"\n  );\n}\n\nfunction isAccessObjectKind(\n  value: unknown,\n): value is AccessEvent[\"objectKind\"] {\n  return value === \"blob\" || value === \"container\" || value === \"document\";\n}\n\nfunction isRecipientKind(\n  value: unknown,\n): value is ContainerKekRecipientTarget[\"recipientKind\"] {\n  return value === \"container\" || value === \"group\" || value === \"user\";\n}\n\nexport function readAccessEvent(value: unknown, label: string): AccessEvent {\n  return readKeyingVerificationShape(() => readAccessEventShape(value, label));\n}\n\nfunction readAccessEventShape(value: unknown, label: string): AccessEvent {\n  const record = readCanonicalRecord(value, label);\n  const eventType = readRequiredRecordValue(record, \"eventType\", label);\n  const objectKind = readRequiredRecordValue(record, \"objectKind\", label);\n  if (!isAccessEventType(eventType)) {\n    throw new Error(`${label}.eventType is invalid`);\n  }\n  if (!isAccessObjectKind(objectKind)) {\n    throw new Error(`${label}.objectKind is invalid`);\n  }\n  if (readRecordPositiveInteger(record, \"version\", label) !== 1) {\n    throw new Error(`${label}.version must be 1`);\n  }\n\n  return {\n    version: 1,\n    eventId: readRecordString(record, \"eventId\", label),\n    eventType,\n    objectKind,\n    objectId: readRecordString(record, \"objectId\", label),\n    organizationId: readRecordString(record, \"organizationId\", label),\n    previousManifestHash: readRecordNullableString(\n      record,\n      \"previousManifestHash\",\n      label,\n    ),\n    dependencyManifestHashes: readStringArray(\n      readRequiredRecordValue(record, \"dependencyManifestHashes\", label),\n      `${label}.dependencyManifestHashes`,\n    ),\n    bodyHash: readRecordString(record, \"bodyHash\", label),\n    signerUserId: readRecordString(record, \"signerUserId\", label),\n    signerDeviceId: readRecordString(record, \"signerDeviceId\", label),\n    signerKeyFingerprint: readRecordString(\n      record,\n      \"signerKeyFingerprint\",\n      label,\n    ),\n    signedAt: readRecordString(record, \"signedAt\", label),\n    signature: readRecordString(record, \"signature\", label),\n  };\n}\n\nexport function readAccessManifest(\n  value: unknown,\n  label: string,\n): AccessManifest {\n  return readKeyingVerificationShape(() =>\n    readAccessManifestShape(value, label),\n  );\n}\n\nfunction readAccessManifestShape(\n  value: unknown,\n  label: string,\n): AccessManifest {\n  const record = readCanonicalRecord(value, label);\n  const objectKind = readRequiredRecordValue(record, \"objectKind\", label);\n  if (!isAccessObjectKind(objectKind)) {\n    throw new Error(`${label}.objectKind is invalid`);\n  }\n  if (readRecordPositiveInteger(record, \"version\", label) !== 1) {\n    throw new Error(`${label}.version must be 1`);\n  }\n  const referencedPrincipalHeads = readRequiredRecordValue(\n    record,\n    \"referencedPrincipalHeads\",\n    label,\n  );\n  if (!Array.isArray(referencedPrincipalHeads)) {\n    throw new Error(`${label}.referencedPrincipalHeads must be an array`);\n  }\n\n  return {\n    version: 1,\n    objectKind,\n    objectId: readRecordString(record, \"objectId\", label),\n    organizationId: readRecordString(record, \"organizationId\", label),\n    epoch: readRecordPositiveInteger(record, \"epoch\", label),\n    previousManifestHash: readRecordNullableString(\n      record,\n      \"previousManifestHash\",\n      label,\n    ),\n    eventHash: readRecordString(record, \"eventHash\", label),\n    structuralHash: readRecordString(record, \"structuralHash\", label),\n    grantRoot: readRecordString(record, \"grantRoot\", label),\n    referencedPrincipalHeads: referencedPrincipalHeads.map((head, index) => {\n      const headRecord = readCanonicalRecord(\n        head,\n        `${label}.referencedPrincipalHeads[${index}]`,\n      );\n      const principalType = readRequiredRecordValue(\n        headRecord,\n        \"principalType\",\n        `${label}.referencedPrincipalHeads[${index}]`,\n      );\n      if (principalType !== \"group\" && principalType !== \"organization\") {\n        throw new Error(\n          `${label}.referencedPrincipalHeads[${index}].principalType is invalid`,\n        );\n      }\n      return {\n        principalType,\n        principalId: readRecordString(\n          headRecord,\n          \"principalId\",\n          `${label}.referencedPrincipalHeads[${index}]`,\n        ),\n        version: readRecordPositiveInteger(\n          headRecord,\n          \"version\",\n          `${label}.referencedPrincipalHeads[${index}]`,\n        ),\n        keyEpoch: readRecordPositiveInteger(\n          headRecord,\n          \"keyEpoch\",\n          `${label}.referencedPrincipalHeads[${index}]`,\n        ),\n        stateHash: readRecordString(\n          headRecord,\n          \"stateHash\",\n          `${label}.referencedPrincipalHeads[${index}]`,\n        ),\n        keyFingerprint: readRecordString(\n          headRecord,\n          \"keyFingerprint\",\n          `${label}.referencedPrincipalHeads[${index}]`,\n        ),\n      };\n    }),\n    keyTargetHash: readRecordString(record, \"keyTargetHash\", label),\n  };\n}\n\nexport function readContainerKeyEpoch(\n  value: unknown,\n  label: string,\n): ContainerKeyEpoch {\n  return readKeyingVerificationShape(() => {\n    const record = readCanonicalRecord(value, label);\n\n    return {\n      id: readRecordString(record, \"id\", label),\n      containerId: readRecordString(record, \"containerId\", label),\n      keyEpoch: readRecordPositiveInteger(record, \"keyEpoch\", label),\n      accessManifestHash: readRecordString(record, \"accessManifestHash\", label),\n      parentContainerKeyEpochId: readRecordNullableString(\n        record,\n        \"parentContainerKeyEpochId\",\n        label,\n      ),\n      createdByEventHash: readRecordString(record, \"createdByEventHash\", label),\n      createdByManifestHash: readRecordString(\n        record,\n        \"createdByManifestHash\",\n        label,\n      ),\n    };\n  });\n}\n\nexport function readContainerKeyWrap(\n  value: unknown,\n  label: string,\n): ContainerKeyWrap {\n  return readKeyingVerificationShape(() => {\n    const record = readCanonicalRecord(value, label);\n    const recipientKind = readRequiredRecordValue(\n      record,\n      \"recipientKind\",\n      label,\n    );\n    if (!isRecipientKind(recipientKind)) {\n      throw new Error(`${label}.recipientKind is invalid`);\n    }\n\n    return {\n      containerKeyEpochId: readRecordString(\n        record,\n        \"containerKeyEpochId\",\n        label,\n      ),\n      recipientKind,\n      recipientId: readRecordString(record, \"recipientId\", label),\n      recipientKeyEpochId: readRecordString(\n        record,\n        \"recipientKeyEpochId\",\n        label,\n      ),\n      recipientKeyFingerprint: readRecordString(\n        record,\n        \"recipientKeyFingerprint\",\n        label,\n      ),\n      kemCipherText: readRecordString(record, \"kemCipherText\", label),\n      wrappedKey: readRecordString(record, \"wrappedKey\", label),\n      wrapManifestHash: readRecordString(record, \"wrapManifestHash\", label),\n    };\n  });\n}\n\nexport function readContainerKekRecipientTarget(\n  value: unknown,\n  label: string,\n): ContainerKekRecipientTarget {\n  return readKeyingVerificationShape(() => {\n    const record = readCanonicalRecord(value, label);\n    const recipientKind = readRequiredRecordValue(\n      record,\n      \"recipientKind\",\n      label,\n    );\n    if (!isRecipientKind(recipientKind)) {\n      throw new Error(`${label}.recipientKind is invalid`);\n    }\n\n    return {\n      recipientKind,\n      recipientId: readRecordString(record, \"recipientId\", label),\n      recipientKeyEpochId: readRecordString(\n        record,\n        \"recipientKeyEpochId\",\n        label,\n      ),\n      recipientKeyFingerprint: readRecordString(\n        record,\n        \"recipientKeyFingerprint\",\n        label,\n      ),\n    };\n  });\n}\n\nexport function readDocumentAccessEventBody(\n  value: unknown,\n  label: string,\n): DocumentLinkAccessEventBody | DocumentUnlinkAccessEventBody {\n  return readKeyingVerificationShape(() =>\n    normalizeDocumentAccessEventBody(readCanonicalJson(value, label)),\n  );\n}\n"]}

package/data/keyingProjectionVerification/resolvedPrincipalPolicy.js

@@ -0,0 +1,70 @@
+import { KeyingVerificationError, } from "../../internal/crypto/index.js";
+import { loadPrincipalPolicyCheckpoint } from "../persistence/keyingCheckpointPersistence.js";
+import { verifiedPrincipalPolicyMeetsCheckpoint } from "../persistence/principalPolicyCheckpointSelection.js";
+import { observePrincipalPolicy, } from "./checkpointContext.js";
+import { referencedPrincipalPolicyKey, verifiedPrincipalPolicyContainsReference, } from "./principalPolicyCache.js";
+import { assertProjectionVerificationCurrent, } from "./types.js";
+// Sparse cache hits must carry the organization binding and every dependency
+// into each new admission batch; a bare current-policy capability is insufficient.
+// The caller owns this cache. Cross-generation reuse is deliberately disabled by
+// the saved guard; a new lifetime restores authenticated persistent evidence.
+const recoveredByCache = new WeakMap();
+async function meetsCheckpoints(context, result, refreshMissing) {
+    for (const policy of [...result.dependencies, result.policy]) {
+        const checkpoint = await loadPrincipalPolicyCheckpoint(context.execSql, policy.principalType, policy.principalId);
+        if (refreshMissing &&
+            checkpoint &&
+            (policy.version < checkpoint.version ||
+                (policy.version > checkpoint.version &&
+                    !policy.retainedHistory.some((entry) => entry.state.version === checkpoint.version))))
+            return false;
+        if (!verifiedPrincipalPolicyMeetsCheckpoint(policy, checkpoint))
+            throw new KeyingVerificationError("rollback", "Recovered principal evidence predates the durable checkpoint");
+    }
+    return true;
+}
+export async function resolveReferencedPrincipalPolicy(input) {
+    assertProjectionVerificationCurrent(input.stillCurrent);
+    const key = referencedPrincipalPolicyKey(input.reference);
+    const remembered = recoveredByCache.get(input.principalPolicyCache)?.get(key);
+    let result = remembered?.organizationId === input.organizationId &&
+        remembered.policy === input.principalPolicyCache.get(key) &&
+        remembered.stillCurrent()
+        ? remembered
+        : undefined;
+    if (result &&
+        !(await meetsCheckpoints(input.checkpointContext, result, true)))
+        result = undefined;
+    if (!result) {
+        const resolve = input.warmReferencedPrincipalPolicies?.resolveReference;
+        if (!resolve)
+            return null;
+        result = await resolve({
+            recoveryBatch: input.recoveryBatch,
+            organizationId: input.organizationId,
+            reference: input.reference,
+            stillCurrent: input.stillCurrent,
+        });
+        await meetsCheckpoints(input.checkpointContext, result, false);
+    }
+    assertProjectionVerificationCurrent(input.stillCurrent);
+    assertProjectionVerificationCurrent(result.stillCurrent);
+    if (result.organizationId !== input.organizationId)
+        throw new KeyingVerificationError("object_mismatch", "Recovered principal evidence belongs to another organization");
+    if (!verifiedPrincipalPolicyContainsReference(result.policy, input.reference))
+        throw new KeyingVerificationError("object_mismatch", "Recovered principal evidence does not contain the exact citation");
+    for (const policy of [...result.dependencies, result.policy])
+        observePrincipalPolicy(input.checkpointContext, policy, input.organizationId);
+    let rememberedPolicies = recoveredByCache.get(input.principalPolicyCache);
+    if (!rememberedPolicies) {
+        rememberedPolicies = new Map();
+        recoveredByCache.set(input.principalPolicyCache, rememberedPolicies);
+    }
+    rememberedPolicies.set(key, {
+        ...result,
+        dependencies: [...result.dependencies],
+    });
+    input.principalPolicyCache.set(key, result.policy);
+    return result.policy;
+}
+//# sourceMappingURL=resolvedPrincipalPolicy.js.map

package/data/keyingProjectionVerification/resolvedPrincipalPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvedPrincipalPolicy.js","sourceRoot":"","sources":["resolvedPrincipalPolicy.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  KeyingVerificationError,\n  type ReferencedPrincipalHead,\n  type VerifiedPrincipalPolicyCurrent,\n} from \"@tearleads/crypto\";\nimport { loadPrincipalPolicyCheckpoint } from \"../persistence/keyingCheckpointPersistence\";\nimport { verifiedPrincipalPolicyMeetsCheckpoint } from \"../persistence/principalPolicyCheckpointSelection\";\nimport {\n  observePrincipalPolicy,\n  type ProjectionCheckpointContext,\n} from \"./checkpointContext\";\nimport {\n  referencedPrincipalPolicyKey,\n  verifiedPrincipalPolicyContainsReference,\n} from \"./principalPolicyCache\";\nimport {\n  assertProjectionVerificationCurrent,\n  type PrincipalPolicyCache,\n  type ReferencedPrincipalPolicyWarmer,\n  type ResolvedPrincipalPolicyEvidence,\n} from \"./types\";\n\n// Sparse cache hits must carry the organization binding and every dependency\n// into each new admission batch; a bare current-policy capability is insufficient.\n// The caller owns this cache. Cross-generation reuse is deliberately disabled by\n// the saved guard; a new lifetime restores authenticated persistent evidence.\nconst recoveredByCache = new WeakMap<\n  PrincipalPolicyCache,\n  Map<string, ResolvedPrincipalPolicyEvidence>\n>();\n\nasync function meetsCheckpoints(\n  context: ProjectionCheckpointContext,\n  result: ResolvedPrincipalPolicyEvidence,\n  refreshMissing: boolean,\n): Promise<boolean> {\n  for (const policy of [...result.dependencies, result.policy]) {\n    const checkpoint = await loadPrincipalPolicyCheckpoint(\n      context.execSql,\n      policy.principalType,\n      policy.principalId,\n    );\n    if (\n      refreshMissing &&\n      checkpoint &&\n      (policy.version < checkpoint.version ||\n        (policy.version > checkpoint.version &&\n          !policy.retainedHistory.some(\n            (entry) => entry.state.version === checkpoint.version,\n          )))\n    )\n      return false;\n    if (!verifiedPrincipalPolicyMeetsCheckpoint(policy, checkpoint))\n      throw new KeyingVerificationError(\n        \"rollback\",\n        \"Recovered principal evidence predates the durable checkpoint\",\n      );\n  }\n  return true;\n}\n\nexport async function resolveReferencedPrincipalPolicy(input: {\n  readonly recoveryBatch?: object | undefined;\n  readonly checkpointContext: ProjectionCheckpointContext;\n  readonly organizationId: string;\n  readonly stillCurrent?: (() => boolean) | undefined;\n  readonly principalPolicyCache: PrincipalPolicyCache;\n  readonly reference: ReferencedPrincipalHead;\n  readonly warmReferencedPrincipalPolicies?:\n    | ReferencedPrincipalPolicyWarmer\n    | undefined;\n}): Promise<VerifiedPrincipalPolicyCurrent | null> {\n  assertProjectionVerificationCurrent(input.stillCurrent);\n  const key = referencedPrincipalPolicyKey(input.reference);\n  const remembered = recoveredByCache.get(input.principalPolicyCache)?.get(key);\n  let result =\n    remembered?.organizationId === input.organizationId &&\n    remembered.policy === input.principalPolicyCache.get(key) &&\n    remembered.stillCurrent()\n      ? remembered\n      : undefined;\n  if (\n    result &&\n    !(await meetsCheckpoints(input.checkpointContext, result, true))\n  )\n    result = undefined;\n  if (!result) {\n    const resolve = input.warmReferencedPrincipalPolicies?.resolveReference;\n    if (!resolve) return null;\n    result = await resolve({\n      recoveryBatch: input.recoveryBatch,\n      organizationId: input.organizationId,\n      reference: input.reference,\n      stillCurrent: input.stillCurrent,\n    });\n    await meetsCheckpoints(input.checkpointContext, result, false);\n  }\n  assertProjectionVerificationCurrent(input.stillCurrent);\n  assertProjectionVerificationCurrent(result.stillCurrent);\n  if (result.organizationId !== input.organizationId)\n    throw new KeyingVerificationError(\n      \"object_mismatch\",\n      \"Recovered principal evidence belongs to another organization\",\n    );\n  if (!verifiedPrincipalPolicyContainsReference(result.policy, input.reference))\n    throw new KeyingVerificationError(\n      \"object_mismatch\",\n      \"Recovered principal evidence does not contain the exact citation\",\n    );\n  for (const policy of [...result.dependencies, result.policy])\n    observePrincipalPolicy(\n      input.checkpointContext,\n      policy,\n      input.organizationId,\n    );\n  let rememberedPolicies = recoveredByCache.get(input.principalPolicyCache);\n  if (!rememberedPolicies) {\n    rememberedPolicies = new Map();\n    recoveredByCache.set(input.principalPolicyCache, rememberedPolicies);\n  }\n  rememberedPolicies.set(key, {\n    ...result,\n    dependencies: [...result.dependencies],\n  });\n  input.principalPolicyCache.set(key, result.policy);\n  return result.policy;\n}\n"]}

package/data/keyingProjectionVerification/snapshotVerificationCache.js

@@ -0,0 +1,39 @@
+import { bytesToHex, createIncrementalSha256, verifyPrincipalPolicySnapshot, } from "../../internal/crypto/index.js";
+// Bind independently decoded responses to their actual bytes, reference, trusted
+// signer keys and external authority. Checkpoints remain checked by the caller.
+const verified = new Map();
+const MAX_CACHED_SOURCE_CHARACTERS = 4_000_000;
+const MAX_ENTRIES = 16;
+function freezeResult(value) {
+    for (const child of Object.values(value)) {
+        if (typeof child === "object" && child !== null && !Object.isFrozen(child))
+            freezeResult(child);
+    }
+    Object.freeze(value);
+}
+export async function verifyReceivedPolicySnapshot(input) {
+    const source = JSON.stringify(input);
+    if (source.length > MAX_CACHED_SOURCE_CHARACTERS)
+        return verifyPrincipalPolicySnapshot(input);
+    const hash = createIncrementalSha256();
+    hash.update(new TextEncoder().encode(source));
+    const key = bytesToHex(hash.digest());
+    const cached = verified.get(key);
+    if (cached) {
+        verified.delete(key);
+        verified.set(key, cached);
+        return cached;
+    }
+    const result = await verifyPrincipalPolicySnapshot(structuredClone(input));
+    if (result.ok) {
+        freezeResult(result);
+        verified.set(key, result);
+        while (verified.size > MAX_ENTRIES) {
+            const oldest = verified.keys().next().value;
+            if (oldest !== undefined)
+                verified.delete(oldest);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=snapshotVerificationCache.js.map

package/data/keyingProjectionVerification/snapshotVerificationCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotVerificationCache.js","sourceRoot":"","sources":["snapshotVerificationCache.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,uBAAuB,EACvB,6BAA6B,GAC9B,MAAM,mBAAmB,CAAC;AAK3B,iFAAiF;AACjF,gFAAgF;AAChF,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA0B,CAAC;AACnD,MAAM,4BAA4B,GAAG,SAAS,CAAC;AAC/C,MAAM,WAAW,GAAG,EAAE,CAAC;AAEvB,SAAS,YAAY,CAAC,KAAa;IACjC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACzC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YACxE,YAAY,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IACD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,KAAoB;IAEpB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACrC,IAAI,MAAM,CAAC,MAAM,GAAG,4BAA4B;QAC9C,OAAO,6BAA6B,CAAC,KAAK,CAAC,CAAC;IAC9C,MAAM,IAAI,GAAG,uBAAuB,EAAE,CAAC;IACvC,IAAI,CAAC,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC9C,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,MAAM,EAAE,CAAC;QACX,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACrB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC1B,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,6BAA6B,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3E,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;QACd,YAAY,CAAC,MAAM,CAAC,CAAC;QACrB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC,IAAI,GAAG,WAAW,EAAE,CAAC;YACnC,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YAC5C,IAAI,MAAM,KAAK,SAAS;gBAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import {\n  bytesToHex,\n  createIncrementalSha256,\n  verifyPrincipalPolicySnapshot,\n} from \"@tearleads/crypto\";\n\ntype SnapshotInput = Parameters<typeof verifyPrincipalPolicySnapshot>[0];\ntype SnapshotResult = Awaited<ReturnType<typeof verifyPrincipalPolicySnapshot>>;\n\n// Bind independently decoded responses to their actual bytes, reference, trusted\n// signer keys and external authority. Checkpoints remain checked by the caller.\nconst verified = new Map<string, SnapshotResult>();\nconst MAX_CACHED_SOURCE_CHARACTERS = 4_000_000;\nconst MAX_ENTRIES = 16;\n\nfunction freezeResult(value: object): void {\n  for (const child of Object.values(value)) {\n    if (typeof child === \"object\" && child !== null && !Object.isFrozen(child))\n      freezeResult(child);\n  }\n  Object.freeze(value);\n}\n\nexport async function verifyReceivedPolicySnapshot(\n  input: SnapshotInput,\n): Promise<SnapshotResult> {\n  const source = JSON.stringify(input);\n  if (source.length > MAX_CACHED_SOURCE_CHARACTERS)\n    return verifyPrincipalPolicySnapshot(input);\n  const hash = createIncrementalSha256();\n  hash.update(new TextEncoder().encode(source));\n  const key = bytesToHex(hash.digest());\n  const cached = verified.get(key);\n  if (cached) {\n    verified.delete(key);\n    verified.set(key, cached);\n    return cached;\n  }\n  const result = await verifyPrincipalPolicySnapshot(structuredClone(input));\n  if (result.ok) {\n    freezeResult(result);\n    verified.set(key, result);\n    while (verified.size > MAX_ENTRIES) {\n      const oldest = verified.keys().next().value;\n      if (oldest !== undefined) verified.delete(oldest);\n    }\n  }\n  return result;\n}\n"]}

package/data/keyingProjectionVerification/types.d.ts

@@ -0,0 +1,47 @@
+import type { ReferencedPrincipalHead, VerifiedPrincipalPolicyCurrent } from "../../internal/crypto/index.js";
+import type { PrincipalPolicyBundleResponse } from "../../internal/validators/response/index.js";
+import type { PrincipalPolicyCurrentEvidence } from "../principals/principalPolicyEvidence.js";
+import type { TrustedUserIdentity } from "../trustedUserIdentity/index.js";
+export type ProjectionUserKey = TrustedUserIdentity;
+export type ProjectionUserKeyResolver = (userId: string) => Promise<ProjectionUserKey | null>;
+export type PrincipalPolicyCache = Map<string, PrincipalPolicyCurrentEvidence>;
+export interface PrincipalPolicyResolveRequest {
+    /** Identity of one projection collection, never caller-supplied evidence. */
+    readonly recoveryBatch?: object | undefined;
+    readonly organizationId: string;
+    readonly reference: ReferencedPrincipalHead;
+    readonly stillCurrent?: (() => boolean) | undefined;
+}
+export interface ResolvedPrincipalPolicyEvidence {
+    readonly stillCurrent: () => boolean;
+    readonly organizationId: string;
+    readonly policy: VerifiedPrincipalPolicyCurrent;
+    readonly dependencies: readonly VerifiedPrincipalPolicyCurrent[];
+}
+export interface ReferencedPrincipalPolicyWarmRequest {
+    readonly organizationId: string;
+    readonly references: readonly ReferencedPrincipalHead[];
+    readonly stillCurrent?: (() => boolean) | undefined;
+}
+export interface PrincipalPolicyBundleCacheRequest {
+    readonly bundles: readonly PrincipalPolicyBundleResponse[];
+    readonly organizationId: string;
+    readonly stillCurrent?: (() => boolean) | undefined;
+}
+export type PrincipalPolicyBundleCacher = (input: PrincipalPolicyBundleCacheRequest) => Promise<void>;
+export type ReferencedPrincipalPolicyWarmer = ((input: ReferencedPrincipalPolicyWarmRequest) => Promise<void>) & {
+    readonly cacheBundles?: PrincipalPolicyBundleCacher | undefined;
+    readonly resolveReference?: ((input: PrincipalPolicyResolveRequest) => Promise<ResolvedPrincipalPolicyEvidence>) | undefined;
+};
+export declare class ProjectionVerificationCancelledError extends Error {
+    constructor();
+}
+export declare function isProjectionVerificationCancelledError(error: unknown): error is ProjectionVerificationCancelledError;
+export declare function rethrowProjectionVerificationCancelled(error: unknown): void;
+export declare function nullOnProjectionVerificationCancellation<T>(operation: () => Promise<T>): Promise<T | null>;
+export declare function assertProjectionVerificationCurrent(stillCurrent: (() => boolean) | undefined): void;
+export declare function generationGuardedPrincipalPolicyWarmer(warmer: ReferencedPrincipalPolicyWarmer | undefined, stillCurrent: (() => boolean) | undefined): ReferencedPrincipalPolicyWarmer | undefined;
+export declare function withGenerationGuardedPolicyWarmer<Input extends {
+    readonly stillCurrent?: (() => boolean) | undefined;
+    readonly warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;
+}>(input: Input): Input;

package/data/keyingProjectionVerification/types.js

@@ -0,0 +1,72 @@
+export class ProjectionVerificationCancelledError extends Error {
+    constructor() {
+        super("Projection verification generation expired");
+        this.name = "ProjectionVerificationCancelledError";
+    }
+}
+const projectionVerificationCancellation = new ProjectionVerificationCancelledError();
+export function isProjectionVerificationCancelledError(error) {
+    return error === projectionVerificationCancellation;
+}
+export function rethrowProjectionVerificationCancelled(error) {
+    if (isProjectionVerificationCancelledError(error))
+        throw error;
+}
+export async function nullOnProjectionVerificationCancellation(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (isProjectionVerificationCancelledError(error))
+            return null;
+        throw error;
+    }
+}
+export function assertProjectionVerificationCurrent(stillCurrent) {
+    if (stillCurrent?.() === false) {
+        throw projectionVerificationCancellation;
+    }
+}
+export function generationGuardedPrincipalPolicyWarmer(warmer, stillCurrent) {
+    if (!warmer || !stillCurrent)
+        return warmer;
+    const guard = (operation) => async (input) => {
+        assertProjectionVerificationCurrent(stillCurrent);
+        await operation({ ...input, stillCurrent });
+        assertProjectionVerificationCurrent(stillCurrent);
+    };
+    const guardWithCapabilities = (operation) => {
+        const guarded = guard(operation);
+        const resolve = operation.resolveReference;
+        return Object.assign(guarded, {
+            ...(resolve
+                ? {
+                    resolveReference: async (input) => {
+                        const current = () => stillCurrent() && input.stillCurrent?.() !== false;
+                        assertProjectionVerificationCurrent(current);
+                        const result = await resolve({ ...input, stillCurrent: current });
+                        assertProjectionVerificationCurrent(current);
+                        return result;
+                    },
+                }
+                : {}),
+            ...(operation.cacheBundles
+                ? {
+                    cacheBundles: async (input) => {
+                        assertProjectionVerificationCurrent(stillCurrent);
+                        await operation.cacheBundles?.({ ...input, stillCurrent });
+                        assertProjectionVerificationCurrent(stillCurrent);
+                    },
+                }
+                : {}),
+        });
+    };
+    return guardWithCapabilities(warmer);
+}
+export function withGenerationGuardedPolicyWarmer(input) {
+    return {
+        ...input,
+        warmReferencedPrincipalPolicies: generationGuardedPrincipalPolicyWarmer(input.warmReferencedPrincipalPolicies, input.stillCurrent),
+    };
+}
+//# sourceMappingURL=types.js.map

package/data/keyingProjectionVerification/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AA0DA,MAAM,OAAO,oCAAqC,SAAQ,KAAK;IAC7D;QACE,KAAK,CAAC,4CAA4C,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,sCAAsC,CAAC;IACrD,CAAC;CACF;AAED,MAAM,kCAAkC,GACtC,IAAI,oCAAoC,EAAE,CAAC;AAE7C,MAAM,UAAU,sCAAsC,CACpD,KAAc;IAEd,OAAO,KAAK,KAAK,kCAAkC,CAAC;AACtD,CAAC;AAED,MAAM,UAAU,sCAAsC,CAAC,KAAc;IACnE,IAAI,sCAAsC,CAAC,KAAK,CAAC;QAAE,MAAM,KAAK,CAAC;AACjE,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wCAAwC,CAC5D,SAA2B;IAE3B,IAAI,CAAC;QACH,OAAO,MAAM,SAAS,EAAE,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,sCAAsC,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC/D,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,MAAM,UAAU,mCAAmC,CACjD,YAAyC;IAEzC,IAAI,YAAY,EAAE,EAAE,KAAK,KAAK,EAAE,CAAC;QAC/B,MAAM,kCAAkC,CAAC;IAC3C,CAAC;AACH,CAAC;AAED,MAAM,UAAU,sCAAsC,CACpD,MAAmD,EACnD,YAAyC;IAEzC,IAAI,CAAC,MAAM,IAAI,CAAC,YAAY;QAAE,OAAO,MAAM,CAAC;IAC5C,MAAM,KAAK,GACT,CAAC,SAA0C,EAAE,EAAE,CAC/C,KAAK,EAAE,KAA2C,EAAE,EAAE;QACpD,mCAAmC,CAAC,YAAY,CAAC,CAAC;QAClD,MAAM,SAAS,CAAC,EAAE,GAAG,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;QAC5C,mCAAmC,CAAC,YAAY,CAAC,CAAC;IACpD,CAAC,CAAC;IACJ,MAAM,qBAAqB,GAAG,CAC5B,SAA0C,EACT,EAAE;QACnC,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QACjC,MAAM,OAAO,GAAG,SAAS,CAAC,gBAAgB,CAAC;QAC3C,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE;YAC5B,GAAG,CAAC,OAAO;gBACT,CAAC,CAAC;oBACE,gBAAgB,EAAE,KAAK,EAAE,KAAoC,EAAE,EAAE;wBAC/D,MAAM,OAAO,GAAG,GAAG,EAAE,CACnB,YAAY,EAAE,IAAI,KAAK,CAAC,YAAY,EAAE,EAAE,KAAK,KAAK,CAAC;wBACrD,mCAAmC,CAAC,OAAO,CAAC,CAAC;wBAC7C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,EAAE,GAAG,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC;wBAClE,mCAAmC,CAAC,OAAO,CAAC,CAAC;wBAC7C,OAAO,MAAM,CAAC;oBAChB,CAAC;iBACF;gBACH,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,SAAS,CAAC,YAAY;gBACxB,CAAC,CAAC;oBACE,YAAY,EAAE,KAAK,EAAE,KAAwC,EAAE,EAAE;wBAC/D,mCAAmC,CAAC,YAAY,CAAC,CAAC;wBAClD,MAAM,SAAS,CAAC,YAAY,EAAE,CAAC,EAAE,GAAG,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;wBAC3D,mCAAmC,CAAC,YAAY,CAAC,CAAC;oBACpD,CAAC;iBACF;gBACH,CAAC,CAAC,EAAE,CAAC;SACR,CAAC,CAAC;IACL,CAAC,CAAC;IACF,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,iCAAiC,CAO/C,KAAY;IACZ,OAAO;QACL,GAAG,KAAK;QACR,+BAA+B,EAAE,sCAAsC,CACrE,KAAK,CAAC,+BAA+B,EACrC,KAAK,CAAC,YAAY,CACnB;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type {\n  ReferencedPrincipalHead,\n  VerifiedPrincipalPolicyCurrent,\n} from \"@tearleads/crypto\";\nimport type { PrincipalPolicyBundleResponse } from \"@tearleads/validators/response\";\nimport type { PrincipalPolicyCurrentEvidence } from \"../principals/principalPolicyEvidence\";\nimport type { TrustedUserIdentity } from \"../trustedUserIdentity\";\n\nexport type ProjectionUserKey = TrustedUserIdentity;\n\nexport type ProjectionUserKeyResolver = (\n  userId: string,\n) => Promise<ProjectionUserKey | null>;\n\nexport type PrincipalPolicyCache = Map<string, PrincipalPolicyCurrentEvidence>;\n\nexport interface PrincipalPolicyResolveRequest {\n  /** Identity of one projection collection, never caller-supplied evidence. */\n  readonly recoveryBatch?: object | undefined;\n  readonly organizationId: string;\n  readonly reference: ReferencedPrincipalHead;\n  readonly stillCurrent?: (() => boolean) | undefined;\n}\n\nexport interface ResolvedPrincipalPolicyEvidence {\n  readonly stillCurrent: () => boolean;\n  readonly organizationId: string;\n  readonly policy: VerifiedPrincipalPolicyCurrent;\n  readonly dependencies: readonly VerifiedPrincipalPolicyCurrent[];\n}\n\nexport interface ReferencedPrincipalPolicyWarmRequest {\n  readonly organizationId: string;\n  readonly references: readonly ReferencedPrincipalHead[];\n  readonly stillCurrent?: (() => boolean) | undefined;\n}\n\nexport interface PrincipalPolicyBundleCacheRequest {\n  readonly bundles: readonly PrincipalPolicyBundleResponse[];\n  readonly organizationId: string;\n  readonly stillCurrent?: (() => boolean) | undefined;\n}\n\nexport type PrincipalPolicyBundleCacher = (\n  input: PrincipalPolicyBundleCacheRequest,\n) => Promise<void>;\n\nexport type ReferencedPrincipalPolicyWarmer = ((\n  input: ReferencedPrincipalPolicyWarmRequest,\n) => Promise<void>) & {\n  readonly cacheBundles?: PrincipalPolicyBundleCacher | undefined;\n  readonly resolveReference?:\n    | ((\n        input: PrincipalPolicyResolveRequest,\n      ) => Promise<ResolvedPrincipalPolicyEvidence>)\n    | undefined;\n};\n\nexport class ProjectionVerificationCancelledError extends Error {\n  constructor() {\n    super(\"Projection verification generation expired\");\n    this.name = \"ProjectionVerificationCancelledError\";\n  }\n}\n\nconst projectionVerificationCancellation =\n  new ProjectionVerificationCancelledError();\n\nexport function isProjectionVerificationCancelledError(\n  error: unknown,\n): error is ProjectionVerificationCancelledError {\n  return error === projectionVerificationCancellation;\n}\n\nexport function rethrowProjectionVerificationCancelled(error: unknown): void {\n  if (isProjectionVerificationCancelledError(error)) throw error;\n}\n\nexport async function nullOnProjectionVerificationCancellation<T>(\n  operation: () => Promise<T>,\n): Promise<T | null> {\n  try {\n    return await operation();\n  } catch (error) {\n    if (isProjectionVerificationCancelledError(error)) return null;\n    throw error;\n  }\n}\n\nexport function assertProjectionVerificationCurrent(\n  stillCurrent: (() => boolean) | undefined,\n): void {\n  if (stillCurrent?.() === false) {\n    throw projectionVerificationCancellation;\n  }\n}\n\nexport function generationGuardedPrincipalPolicyWarmer(\n  warmer: ReferencedPrincipalPolicyWarmer | undefined,\n  stillCurrent: (() => boolean) | undefined,\n): ReferencedPrincipalPolicyWarmer | undefined {\n  if (!warmer || !stillCurrent) return warmer;\n  const guard =\n    (operation: ReferencedPrincipalPolicyWarmer) =>\n    async (input: ReferencedPrincipalPolicyWarmRequest) => {\n      assertProjectionVerificationCurrent(stillCurrent);\n      await operation({ ...input, stillCurrent });\n      assertProjectionVerificationCurrent(stillCurrent);\n    };\n  const guardWithCapabilities = (\n    operation: ReferencedPrincipalPolicyWarmer,\n  ): ReferencedPrincipalPolicyWarmer => {\n    const guarded = guard(operation);\n    const resolve = operation.resolveReference;\n    return Object.assign(guarded, {\n      ...(resolve\n        ? {\n            resolveReference: async (input: PrincipalPolicyResolveRequest) => {\n              const current = () =>\n                stillCurrent() && input.stillCurrent?.() !== false;\n              assertProjectionVerificationCurrent(current);\n              const result = await resolve({ ...input, stillCurrent: current });\n              assertProjectionVerificationCurrent(current);\n              return result;\n            },\n          }\n        : {}),\n      ...(operation.cacheBundles\n        ? {\n            cacheBundles: async (input: PrincipalPolicyBundleCacheRequest) => {\n              assertProjectionVerificationCurrent(stillCurrent);\n              await operation.cacheBundles?.({ ...input, stillCurrent });\n              assertProjectionVerificationCurrent(stillCurrent);\n            },\n          }\n        : {}),\n    });\n  };\n  return guardWithCapabilities(warmer);\n}\n\nexport function withGenerationGuardedPolicyWarmer<\n  Input extends {\n    readonly stillCurrent?: (() => boolean) | undefined;\n    readonly warmReferencedPrincipalPolicies?:\n      | ReferencedPrincipalPolicyWarmer\n      | undefined;\n  },\n>(input: Input): Input {\n  return {\n    ...input,\n    warmReferencedPrincipalPolicies: generationGuardedPrincipalPolicyWarmer(\n      input.warmReferencedPrincipalPolicies,\n      input.stillCurrent,\n    ),\n  };\n}\n"]}

package/data/keyingProjectionVerification/userKeyResolver.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectionUserKeyResolver } from "../keyingProjectionVerification.js";
+import { type TrustedUserIdentityResolver } from "../trustedUserIdentity/index.js";
+interface ProjectionUserKeyRuntime {
+    readonly resolveTrustedUserIdentity: TrustedUserIdentityResolver;
+}
+export declare function createProjectionUserKeyResolver(runtime: ProjectionUserKeyRuntime): ProjectionUserKeyResolver;
+export {};

package/data/keyingProjectionVerification/userKeyResolver.js

@@ -0,0 +1,17 @@
+import { requireTrustedUserIdentityResolver, } from "../trustedUserIdentity/index.js";
+export function createProjectionUserKeyResolver(runtime) {
+    const resolveTrustedUserIdentity = requireTrustedUserIdentityResolver(runtime.resolveTrustedUserIdentity);
+    const cache = new Map();
+    return async (userId) => {
+        let cached = cache.get(userId);
+        if (!cached) {
+            cached = resolveTrustedUserIdentity(userId).catch((error) => {
+                cache.delete(userId);
+                throw error;
+            });
+            cache.set(userId, cached);
+        }
+        return cached;
+    };
+}
+//# sourceMappingURL=userKeyResolver.js.map

package/data/keyingProjectionVerification/userKeyResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userKeyResolver.js","sourceRoot":"","sources":["userKeyResolver.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,kCAAkC,GAEnC,MAAM,wBAAwB,CAAC;AAMhC,MAAM,UAAU,+BAA+B,CAC7C,OAAiC;IAEjC,MAAM,0BAA0B,GAAG,kCAAkC,CACnE,OAAO,CAAC,0BAA0B,CACnC,CAAC;IACF,MAAM,KAAK,GAAG,IAAI,GAAG,EAA6C,CAAC;IAEnE,OAAO,KAAK,EAAE,MAAM,EAAE,EAAE;QACtB,IAAI,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,GAAG,0BAA0B,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;gBACnE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACrB,MAAM,KAAK,CAAC;YACd,CAAC,CAAC,CAAC;YACH,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC5B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import type {\n  ProjectionUserKey,\n  ProjectionUserKeyResolver,\n} from \"../keyingProjectionVerification\";\nimport {\n  requireTrustedUserIdentityResolver,\n  type TrustedUserIdentityResolver,\n} from \"../trustedUserIdentity\";\n\ninterface ProjectionUserKeyRuntime {\n  readonly resolveTrustedUserIdentity: TrustedUserIdentityResolver;\n}\n\nexport function createProjectionUserKeyResolver(\n  runtime: ProjectionUserKeyRuntime,\n): ProjectionUserKeyResolver {\n  const resolveTrustedUserIdentity = requireTrustedUserIdentityResolver(\n    runtime.resolveTrustedUserIdentity,\n  );\n  const cache = new Map<string, Promise<ProjectionUserKey | null>>();\n\n  return async (userId) => {\n    let cached = cache.get(userId);\n    if (!cached) {\n      cached = resolveTrustedUserIdentity(userId).catch((error: unknown) => {\n        cache.delete(userId);\n        throw error;\n      });\n      cache.set(userId, cached);\n    }\n\n    return cached;\n  };\n}\n"]}

package/data/keyingProjectionVerification.d.ts

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

package/data/keyingProjectionVerification.js

@@ -0,0 +1,16 @@
+import { requireTrustedUserIdentityResolver } from "./trustedUserIdentity/requiredResolver.js";
+export { resolveEventContainerPaths } from "./keyingProjectionVerification/documentDependencyPaths.js";
+export { readAccessEvent, readRecordString, readRequiredRecordValue, } from "./keyingProjectionVerification/readers.js";
+export { isProjectionVerificationCancelledError, nullOnProjectionVerificationCancellation, } from "./keyingProjectionVerification/types.js";
+export function requireProjectionUserKeyResolver(resolveProjectionUserKey, label) {
+    if (!resolveProjectionUserKey) {
+        throw new Error(`${label} requires projection key verification`);
+    }
+    // A ProjectionUserKey is a TrustedUserIdentity, so the shared adapter
+    // provides the untrusted-shape and wrong-user guards (with identity caching).
+    return requireTrustedUserIdentityResolver(resolveProjectionUserKey);
+}
+export { collectContainerWriterProjectionPrincipalPolicies, verifyContainerWriterProjection, } from "./keyingProjectionVerification/containerProjectionVerification.js";
+export { verifyDocumentWriterProjection, verifyDocumentWriterProjectionAuthorization, } from "./keyingProjectionVerification/documentProjectionVerification.js";
+export { verifyDocumentPurgeProof, verifyDocumentPurgeProofBaseline, } from "./keyingProjectionVerification/documentPurgeProofVerification.js";
+//# sourceMappingURL=keyingProjectionVerification.js.map

package/data/keyingProjectionVerification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyingProjectionVerification.js","sourceRoot":"","sources":["keyingProjectionVerification.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kCAAkC,EAAE,MAAM,wCAAwC,CAAC;AAE5F,OAAO,EAAE,0BAA0B,EAAE,MAAM,wDAAwD,CAAC;AACpG,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,wCAAwC,CAAC;AAShD,OAAO,EACL,sCAAsC,EACtC,wCAAwC,GACzC,MAAM,sCAAsC,CAAC;AAE9C,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,gEAAgE,CAAC;AACxE,OAAO,EAEL,8BAA8B,EAC9B,2CAA2C,GAC5C,MAAM,+DAA+D,CAAC;AACvE,OAAO,EACL,wBAAwB,EACxB,gCAAgC,GACjC,MAAM,+DAA+D,CAAC","sourcesContent":["import type { ProjectionUserKeyResolver } from \"./keyingProjectionVerification/types\";\nimport { requireTrustedUserIdentityResolver } from \"./trustedUserIdentity/requiredResolver\";\n\nexport { resolveEventContainerPaths } from \"./keyingProjectionVerification/documentDependencyPaths\";\nexport {\n  readAccessEvent,\n  readRecordString,\n  readRequiredRecordValue,\n} from \"./keyingProjectionVerification/readers\";\n\nexport type {\n  PrincipalPolicyBundleCacheRequest,\n  PrincipalPolicyCache,\n  ProjectionUserKey,\n  ProjectionUserKeyResolver,\n  ReferencedPrincipalPolicyWarmer,\n} from \"./keyingProjectionVerification/types\";\nexport {\n  isProjectionVerificationCancelledError,\n  nullOnProjectionVerificationCancellation,\n} from \"./keyingProjectionVerification/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 \"./keyingProjectionVerification/containerProjectionVerification\";\nexport {\n  type DocumentWriterProjectionAuthorization,\n  verifyDocumentWriterProjection,\n  verifyDocumentWriterProjectionAuthorization,\n} from \"./keyingProjectionVerification/documentProjectionVerification\";\nexport {\n  verifyDocumentPurgeProof,\n  verifyDocumentPurgeProofBaseline,\n} from \"./keyingProjectionVerification/documentPurgeProofVerification\";\n"]}

package/data/persistence/container-contents/containerContentsPersistence.d.ts

@@ -0,0 +1,4 @@
+export type { ContainerContentsPersistence, ContainerCreateIntentRecord, ContainerHydrationTombstone, ContainerMetadataRecord, ContainerMoveIntentRecord, LocalRootDescendantReparentInput, StoredContainerState, } from "./containerContentsPersistenceTypes.js";
+export { CONTAINER_METADATA_APP_KIND } from "./dormantContainerMetadata.js";
+import type { ContainerContentsPersistence } from "./containerContentsPersistenceTypes.js";
+export declare const sqlContainerContentsPersistence: ContainerContentsPersistence;

package/data/persistence/container-contents/containerContentsPersistence.js

@@ -0,0 +1,199 @@
+import { and, eq, inArray } from "drizzle-orm";
+import { enqueueDocumentPendingUpdate, ensureDocumentProjectionTables, ensureDocumentTables, } from "../../sqlite/documentPersistence.js";
+import { containerCreateIntentTables, containerHydrationTombstones, containerMoveIntentTables, containers, documentContainerProjectionTables, documentPendingUpdates, } from "../../sqlite/schema.js";
+import { getClientSQLitePersistenceRuntime, } from "../../sqlite/sqlitePersistenceRuntime.js";
+import { ensureSqlTables, runOncePerConnection, runSerializedSqlMutation, } from "../../sqlite/sqlSchema.js";
+import { ensureContainerTables, loadContainerById, loadContainers as loadContainerRecords, } from "../containers/containerPersistence.js";
+import { sqlContainerSyncWatermarkPersistence } from "../containers/containerSyncWatermarkPersistence.js";
+import { getLatestTimestamp } from "../latestTimestamp.js";
+import { CONTAINER_METADATA_APP_KIND } from "./dormantContainerMetadata.js";
+import { claimDormantMetadataSweepAttempt, completeDormantMetadataSweepRequest, listDormantMetadataSweepRequests, } from "./dormantMetadataSweep.js";
+export { CONTAINER_METADATA_APP_KIND } from "./dormantContainerMetadata.js";
+import { deleteStoredContainers } from "./containerDeletionPersistence.js";
+import { commitStoredHydratedContainer, loadStoredHeldContainerBinding, } from "./containerHydrationPersistence.js";
+import { containerIntentPersistence } from "./containerIntentPersistence.js";
+import { commitStoredMetadataMutation, settleStoredMetadataPendingUpdates, } from "./containerMetadataMutationPersistence.js";
+import { containerMetadataPullContinuationPersistence } from "./containerMetadataPullContinuationPersistence.js";
+import { getContainerMetadataScope, saveContainerContentsContainerRows, selectContainerMetadataRecord, } from "./containerMetadataRows.js";
+import { abandonStoredMoveIntentRevision } from "./containerMoveAbandonPersistence.js";
+import { containerPendingUpdatePersistence } from "./containerPendingUpdatePersistence.js";
+import { rebindStoredHeldContainer } from "./containerRebindPersistence.js";
+import { containerReconcilePersistence } from "./containerReconcilePersistence.js";
+import { isSupersededContainerBinding } from "./supersededContainerBindings.js";
+async function saveStoredContainer(execSql, container, record, options) {
+    return runSerializedSqlMutation(execSql, async (lockedExecSql) => {
+        const localUpdatedAt = options?.localUpdatedAt ?? options?.updatedAt ?? new Date().toISOString();
+        const runtime = getClientSQLitePersistenceRuntime(lockedExecSql);
+        const save = async (tx) => {
+            const saved = await saveContainerContentsContainerRows({
+                container,
+                createIntent: options?.createIntent,
+                moveIntent: options?.moveIntent,
+                record,
+                serverTimestamps: options?.serverTimestamps,
+                tx,
+                localUpdatedAt,
+            });
+            if (options && "pendingUpdate" in options) {
+                await enqueueDocumentPendingUpdate(lockedExecSql, getContainerMetadataScope(container.id), options.pendingUpdate);
+            }
+            return saved;
+        };
+        if (!options?.stillCurrent) {
+            return runtime.transaction(save);
+        }
+        const outcome = await runtime.guardedTransaction(save, options.stillCurrent, { behavior: "immediate" });
+        // Guarded callers recheck the same monotonic generation immediately after
+        // this await. Returning the untouched candidate keeps the long-standing
+        // non-null save contract while the transaction itself remains rolled back.
+        return outcome.result ?? container;
+    });
+}
+async function hasPendingContainerMetadataUpdates(input) {
+    const rows = await input.tx
+        .select({ id: documentPendingUpdates.id })
+        .from(documentPendingUpdates)
+        .where(and(eq(documentPendingUpdates.appKind, CONTAINER_METADATA_APP_KIND), eq(documentPendingUpdates.localId, input.containerId)))
+        .limit(1);
+    return rows.length > 0;
+}
+export const sqlContainerContentsPersistence = {
+    ...containerIntentPersistence,
+    ...containerMetadataPullContinuationPersistence,
+    commitHydratedContainer: commitStoredHydratedContainer,
+    commitMetadataMutation: commitStoredMetadataMutation,
+    settleAcceptedMetadataPendingUpdates: settleStoredMetadataPendingUpdates,
+    listDormantMetadataSweepRequests,
+    ...containerPendingUpdatePersistence,
+    ...containerReconcilePersistence,
+    claimDormantMetadataSweepAttempt,
+    completeDormantMetadataSweepRequest,
+    async containerExists(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        const { db } = getClientSQLitePersistenceRuntime(execSql);
+        const rows = await db
+            .select({ id: containers.id })
+            .from(containers)
+            .where(eq(containers.id, containerId))
+            .limit(1);
+        return rows.length > 0;
+    },
+    async deleteContainer(execSql, containerId, options) {
+        await sqlContainerContentsPersistence.deleteContainers(execSql, [
+            {
+                containerId,
+                reason: options?.reason ?? "deleted",
+                updatedAt: options?.updatedAt ?? new Date().toISOString(),
+            },
+        ]);
+    },
+    async deleteContainers(execSql, removals, options) {
+        return deleteStoredContainers(execSql, removals, options);
+    },
+    async ensureSchema(execSql) {
+        // Once ensured on this connection, skip the outer mutation lock entirely:
+        // ensureSchema runs on every query path, and re-acquiring the lock just to
+        // no-op would queue reads behind unrelated writes.
+        await runOncePerConnection(execSql, "ensure:container-contents", () => runSerializedSqlMutation(execSql, async (lockedExecSql) => {
+            await ensureContainerTables(lockedExecSql);
+            await ensureDocumentTables(lockedExecSql);
+            await ensureSqlTables(lockedExecSql, containerCreateIntentTables);
+            await ensureSqlTables(lockedExecSql, containerMoveIntentTables);
+            await ensureSqlTables(lockedExecSql, documentContainerProjectionTables);
+            await ensureDocumentProjectionTables(lockedExecSql);
+            await sqlContainerSyncWatermarkPersistence.ensureSchema(lockedExecSql);
+        }));
+    },
+    async loadHeldContainerBinding(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return loadStoredHeldContainerBinding(execSql, containerId);
+    },
+    async isSupersededContainerBinding(execSql, input) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return isSupersededContainerBinding(execSql, input);
+    },
+    async abandonMoveIntentRevision(execSql, input) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return abandonStoredMoveIntentRevision(execSql, input);
+    },
+    async rebindHeldContainer(execSql, input) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return rebindStoredHeldContainer(execSql, input);
+    },
+    async loadContainerMetadataRecord(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return selectContainerMetadataRecord(execSql, containerId);
+    },
+    async loadContainerHydrationTombstones(execSql) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        const { db } = getClientSQLitePersistenceRuntime(execSql);
+        const rows = await db
+            .select({
+            containerId: containerHydrationTombstones.containerId,
+            generation: containerHydrationTombstones.generation,
+            reason: containerHydrationTombstones.reason,
+            updatedAt: containerHydrationTombstones.updatedAt,
+        })
+            .from(containerHydrationTombstones)
+            .where(eq(containerHydrationTombstones.cleared, false));
+        return rows.flatMap((row) => row.reason === "access_revoked" || row.reason === "deleted"
+            ? [{ ...row, reason: row.reason }]
+            : []);
+    },
+    async loadContainers(execSql) {
+        const containers = await loadContainerRecords(execSql);
+        const storedContainers = await Promise.all(containers.map(async (container) => ({
+            container,
+            record: await selectContainerMetadataRecord(execSql, container.id),
+        })));
+        return storedContainers;
+    },
+    async loadContainerMetadataState(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        const container = await loadContainerById(execSql, containerId);
+        if (!container) {
+            return null;
+        }
+        return {
+            container,
+            record: await selectContainerMetadataRecord(execSql, containerId),
+        };
+    },
+    async saveContainer(execSql, container, record, options) {
+        return saveStoredContainer(execSql, container, record, options);
+    },
+    async saveContainerWithPendingUpdate(execSql, container, record, options) {
+        return saveStoredContainer(execSql, container, record, options);
+    },
+    async saveContainerAndDeletePendingUpdates(execSql, container, record, pendingUpdateIds) {
+        const uniquePendingUpdateIds = [...new Set(pendingUpdateIds)];
+        return runSerializedSqlMutation(execSql, async (lockedExecSql) => {
+            const localUpdatedAt = new Date().toISOString();
+            return getClientSQLitePersistenceRuntime(lockedExecSql).transaction(async (tx) => {
+                if (uniquePendingUpdateIds.length > 0) {
+                    await tx
+                        .delete(documentPendingUpdates)
+                        .where(and(eq(documentPendingUpdates.appKind, CONTAINER_METADATA_APP_KIND), eq(documentPendingUpdates.localId, container.id), inArray(documentPendingUpdates.id, uniquePendingUpdateIds)))
+                        .run();
+                }
+                const hasRemainingPendingUpdates = await hasPendingContainerMetadataUpdates({
+                    containerId: container.id,
+                    tx,
+                });
+                const containerToSave = hasRemainingPendingUpdates
+                    ? container
+                    : {
+                        ...container,
+                        serverUpdatedAt: getLatestTimestamp(container.serverUpdatedAt, localUpdatedAt),
+                    };
+                return saveContainerContentsContainerRows({
+                    container: containerToSave,
+                    record,
+                    tx,
+                    localUpdatedAt,
+                });
+            });
+        });
+    },
+};
+//# sourceMappingURL=containerContentsPersistence.js.map