@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/internal/crypto/keying/accessEvent.js

@@ -0,0 +1,273 @@
+import { base64ToBytes, bytesToBase64 } from "../../encoding/index.js";
+import { toFingerprint } from "../fingerprint.js";
+import { sign } from "../signing/sign.js";
+import { verifyHistorySignature as verify } from "../signing/verifiedHistorySignature.js";
+import { computeKeyingDomainHash, encodeDomainPayload, normalizeCanonicalJsonValue, } from "./canonical.js";
+import { accessManifestCheckpointFromManifest, verifyAccessManifestLocalCheckpoint, } from "./checkpoints.js";
+import { assertExactKeys, compareCanonicalStrings, expectedObjectKindForEventType, normalizeAccessEventType, normalizeAccessObjectKind, normalizeManagedPrincipalKind, normalizeUniqueSortedStrings, readHashString, readNullableHashString, readPositiveInteger, readSignedAt, readString, readStringArray, readVersion, runVerifier, throwVerification, } from "./shared.js";
+import { makeVerifiedAccessEvent, makeVerifiedAccessManifest } from "./types.js";
+function normalizeUnsignedAccessEvent(value) {
+    const record = assertExactKeys(value, [
+        "bodyHash",
+        "dependencyManifestHashes",
+        "eventId",
+        "eventType",
+        "objectId",
+        "objectKind",
+        "organizationId",
+        "previousManifestHash",
+        "signedAt",
+        "signerDeviceId",
+        "signerKeyFingerprint",
+        "signerUserId",
+        "version",
+    ], "access event");
+    const eventType = normalizeAccessEventType(record.eventType, "access event");
+    const objectKind = normalizeAccessObjectKind(record.objectKind, "access event");
+    const expectedObjectKind = expectedObjectKindForEventType(eventType);
+    if (objectKind !== expectedObjectKind) {
+        throwVerification("object_mismatch", `access event ${eventType} must use objectKind ${expectedObjectKind}`);
+    }
+    return {
+        version: readVersion(record, "access event"),
+        eventId: readString(record, "eventId", "access event"),
+        eventType,
+        objectKind,
+        objectId: readString(record, "objectId", "access event"),
+        organizationId: readString(record, "organizationId", "access event"),
+        previousManifestHash: readNullableHashString(record, "previousManifestHash", "access event"),
+        dependencyManifestHashes: normalizeUniqueSortedStrings(readStringArray(record, "dependencyManifestHashes", "access event"), "access event dependencyManifestHashes"),
+        bodyHash: readHashString(record, "bodyHash", "access event"),
+        signerUserId: readString(record, "signerUserId", "access event"),
+        signerDeviceId: readString(record, "signerDeviceId", "access event"),
+        signerKeyFingerprint: readHashString(record, "signerKeyFingerprint", "access event"),
+        signedAt: readSignedAt(record, "signedAt", "access event"),
+    };
+}
+function normalizeAccessEvent(value) {
+    const record = assertExactKeys(value, [
+        "bodyHash",
+        "dependencyManifestHashes",
+        "eventId",
+        "eventType",
+        "objectId",
+        "objectKind",
+        "organizationId",
+        "previousManifestHash",
+        "signature",
+        "signedAt",
+        "signerDeviceId",
+        "signerKeyFingerprint",
+        "signerUserId",
+        "version",
+    ], "access event");
+    const unsignedEvent = normalizeUnsignedAccessEvent({
+        version: record.version,
+        eventId: record.eventId,
+        eventType: record.eventType,
+        objectKind: record.objectKind,
+        objectId: record.objectId,
+        organizationId: record.organizationId,
+        previousManifestHash: record.previousManifestHash,
+        dependencyManifestHashes: record.dependencyManifestHashes,
+        bodyHash: record.bodyHash,
+        signerUserId: record.signerUserId,
+        signerDeviceId: record.signerDeviceId,
+        signerKeyFingerprint: record.signerKeyFingerprint,
+        signedAt: record.signedAt,
+    });
+    return {
+        ...unsignedEvent,
+        signature: readString(record, "signature", "access event"),
+    };
+}
+function unsignedAccessEventPayload(event) {
+    return normalizeUnsignedAccessEvent(event);
+}
+function accessEventSigningBytes(event) {
+    return encodeDomainPayload("tearleads.keying.access-event-signing", unsignedAccessEventPayload(event));
+}
+function toUnsignedAccessEvent(event) {
+    return {
+        version: event.version,
+        eventId: event.eventId,
+        eventType: event.eventType,
+        objectKind: event.objectKind,
+        objectId: event.objectId,
+        organizationId: event.organizationId,
+        previousManifestHash: event.previousManifestHash,
+        dependencyManifestHashes: event.dependencyManifestHashes,
+        bodyHash: event.bodyHash,
+        signerUserId: event.signerUserId,
+        signerDeviceId: event.signerDeviceId,
+        signerKeyFingerprint: event.signerKeyFingerprint,
+        signedAt: event.signedAt,
+    };
+}
+export async function computeAccessEventBodyHash(body) {
+    return computeKeyingDomainHash("tearleads.keying.access-event-body", body);
+}
+export async function signAccessEvent(event, signingPrivateKey) {
+    const normalizedEvent = normalizeUnsignedAccessEvent(event);
+    const signature = sign(accessEventSigningBytes(normalizedEvent), signingPrivateKey);
+    return {
+        ...normalizedEvent,
+        signature: bytesToBase64(signature),
+    };
+}
+export async function computeAccessEventHash(event) {
+    const payload = normalizeAccessEvent(event);
+    return computeKeyingDomainHash("tearleads.keying.access-event", payload);
+}
+export async function verifySignedAccessEvent({ body, event, signerPublicKey, }) {
+    return runVerifier(async () => {
+        const normalizedBody = normalizeCanonicalJsonValue(body, "access event body");
+        const normalizedEvent = normalizeAccessEvent(event);
+        const computedBodyHash = await computeAccessEventBodyHash(normalizedBody);
+        if (computedBodyHash !== normalizedEvent.bodyHash) {
+            throwVerification("hash_mismatch", "access event body hash does not match body");
+        }
+        const signerKeyFingerprint = await toFingerprint(signerPublicKey);
+        if (signerKeyFingerprint !== normalizedEvent.signerKeyFingerprint) {
+            throwVerification("signer_mismatch", "access event signer fingerprint does not match signer public key");
+        }
+        let signature;
+        try {
+            signature = base64ToBytes(normalizedEvent.signature);
+        }
+        catch {
+            throwVerification("signature_mismatch", "access event signature invalid");
+        }
+        if (!verify(signature, accessEventSigningBytes(toUnsignedAccessEvent(normalizedEvent)), signerPublicKey)) {
+            throwVerification("signature_mismatch", "access event signature verification failed");
+        }
+        return makeVerifiedAccessEvent({
+            event: normalizedEvent,
+            body: normalizedBody,
+            eventHash: await computeAccessEventHash(normalizedEvent),
+        });
+    });
+}
+export function normalizeReferencedPrincipalHead(value) {
+    const record = assertExactKeys(value, [
+        "keyEpoch",
+        "keyFingerprint",
+        "principalId",
+        "principalType",
+        "stateHash",
+        "version",
+    ], "referenced principal head");
+    const version = readPositiveInteger(record, "version", "referenced principal head");
+    if (!Number.isSafeInteger(version))
+        throwVerification("invalid_shape", "referenced principal head version must be a safe integer");
+    return {
+        principalType: normalizeManagedPrincipalKind(record.principalType, "referenced principal head"),
+        principalId: readString(record, "principalId", "referenced principal head"),
+        version,
+        keyEpoch: readPositiveInteger(record, "keyEpoch", "referenced principal head"),
+        stateHash: readHashString(record, "stateHash", "referenced principal head"),
+        keyFingerprint: readHashString(record, "keyFingerprint", "referenced principal head"),
+    };
+}
+export function referencedPrincipalKey(principal) {
+    return `${principal.principalType}:${principal.principalId}`;
+}
+export function normalizeReferencedPrincipalHeads(values) {
+    const normalizedValues = values
+        .map(normalizeReferencedPrincipalHead)
+        .sort((left, right) => compareCanonicalStrings(referencedPrincipalKey(left), referencedPrincipalKey(right)));
+    let previousKey = null;
+    for (const principalHead of normalizedValues) {
+        const principalKey = referencedPrincipalKey(principalHead);
+        if (previousKey === principalKey) {
+            throwVerification("duplicate_entry", "access manifest referencedPrincipalHeads contains a duplicate");
+        }
+        previousKey = principalKey;
+    }
+    return normalizedValues;
+}
+export function normalizeAccessManifest(value) {
+    const record = assertExactKeys(value, [
+        "epoch",
+        "eventHash",
+        "grantRoot",
+        "keyTargetHash",
+        "objectId",
+        "objectKind",
+        "organizationId",
+        "previousManifestHash",
+        "referencedPrincipalHeads",
+        "structuralHash",
+        "version",
+    ], "access manifest");
+    const referencedPrincipalHeads = record.referencedPrincipalHeads;
+    if (!Array.isArray(referencedPrincipalHeads)) {
+        throwVerification("invalid_shape", "access manifest.referencedPrincipalHeads must be an array");
+    }
+    return {
+        version: readVersion(record, "access manifest"),
+        objectKind: normalizeAccessObjectKind(record.objectKind, "access manifest"),
+        objectId: readString(record, "objectId", "access manifest"),
+        organizationId: readString(record, "organizationId", "access manifest"),
+        epoch: readPositiveInteger(record, "epoch", "access manifest"),
+        previousManifestHash: readNullableHashString(record, "previousManifestHash", "access manifest"),
+        eventHash: readHashString(record, "eventHash", "access manifest"),
+        structuralHash: readHashString(record, "structuralHash", "access manifest"),
+        grantRoot: readHashString(record, "grantRoot", "access manifest"),
+        referencedPrincipalHeads: normalizeReferencedPrincipalHeads(referencedPrincipalHeads),
+        keyTargetHash: readHashString(record, "keyTargetHash", "access manifest"),
+    };
+}
+export async function computeAccessManifestHash(manifest) {
+    const payload = normalizeAccessManifest(manifest);
+    return computeKeyingDomainHash("tearleads.keying.access-manifest", payload);
+}
+export async function verifyAccessManifest({ checkpointPredecessors, event, expectedManifestHash, expectedObject, expectedPreviousManifestHash, localCheckpoint, manifest, }) {
+    return runVerifier(async () => {
+        const normalizedManifest = normalizeAccessManifest(manifest);
+        const manifestHash = await computeAccessManifestHash(normalizedManifest);
+        if (manifestHash !== expectedManifestHash) {
+            throwVerification("hash_mismatch", "access manifest hash does not match expected hash");
+        }
+        if (event.eventHash !== normalizedManifest.eventHash) {
+            throwVerification("hash_mismatch", "access manifest event hash does not match verified event");
+        }
+        if (event.event.objectKind !== normalizedManifest.objectKind ||
+            event.event.objectId !== normalizedManifest.objectId ||
+            event.event.organizationId !== normalizedManifest.organizationId) {
+            throwVerification("object_mismatch", "access manifest object does not match verified event");
+        }
+        if (event.event.previousManifestHash !==
+            normalizedManifest.previousManifestHash) {
+            throwVerification("stale_predecessor", "access manifest predecessor does not match verified event");
+        }
+        if (expectedPreviousManifestHash !== undefined &&
+            expectedPreviousManifestHash !== normalizedManifest.previousManifestHash) {
+            throwVerification("stale_predecessor", "access manifest predecessor does not match expected predecessor");
+        }
+        if (expectedObject &&
+            (expectedObject.objectKind !== normalizedManifest.objectKind ||
+                expectedObject.objectId !== normalizedManifest.objectId)) {
+            throwVerification("object_mismatch", "access manifest object does not match expected object");
+        }
+        const checkpoint = accessManifestCheckpointFromManifest({
+            manifest: normalizedManifest,
+            manifestHash,
+        });
+        verifyAccessManifestLocalCheckpoint({
+            current: {
+                ...checkpoint,
+                previousManifestHash: normalizedManifest.previousManifestHash,
+            },
+            localCheckpoint,
+            checkpointPredecessors,
+        });
+        return makeVerifiedAccessManifest({
+            manifest: normalizedManifest,
+            manifestHash,
+            event,
+            checkpoint,
+        });
+    });
+}
+//# sourceMappingURL=accessEvent.js.map

package/internal/crypto/keying/accessEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessEvent.js","sourceRoot":"","sources":["accessEvent.ts"],"names":[],"mappings":"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","sourcesContent":["import { base64ToBytes, bytesToBase64 } from \"@tearleads/encoding\";\nimport { toFingerprint } from \"../fingerprint\";\nimport { sign } from \"../signing/sign\";\nimport { verifyHistorySignature as verify } from \"../signing/verifiedHistorySignature\";\nimport {\n  computeKeyingDomainHash,\n  encodeDomainPayload,\n  normalizeCanonicalJsonValue,\n} from \"./canonical\";\nimport {\n  accessManifestCheckpointFromManifest,\n  verifyAccessManifestLocalCheckpoint,\n} from \"./checkpoints\";\nimport {\n  assertExactKeys,\n  compareCanonicalStrings,\n  expectedObjectKindForEventType,\n  normalizeAccessEventType,\n  normalizeAccessObjectKind,\n  normalizeManagedPrincipalKind,\n  normalizeUniqueSortedStrings,\n  readHashString,\n  readNullableHashString,\n  readPositiveInteger,\n  readSignedAt,\n  readString,\n  readStringArray,\n  readVersion,\n  runVerifier,\n  throwVerification,\n} from \"./shared\";\nimport type {\n  AccessEvent,\n  AccessManifest,\n  KeyingCanonicalJson,\n  KeyingCanonicalPayload,\n  KeyingVerificationResult,\n  ReferencedPrincipalHead,\n  UnsignedAccessEvent,\n  VerifiedAccessEvent,\n  VerifiedAccessManifest,\n  VerifyAccessEventInput,\n  VerifyAccessManifestInput,\n} from \"./types\";\nimport { makeVerifiedAccessEvent, makeVerifiedAccessManifest } from \"./types\";\n\nfunction normalizeUnsignedAccessEvent(value: unknown): UnsignedAccessEvent {\n  const record = assertExactKeys(\n    value,\n    [\n      \"bodyHash\",\n      \"dependencyManifestHashes\",\n      \"eventId\",\n      \"eventType\",\n      \"objectId\",\n      \"objectKind\",\n      \"organizationId\",\n      \"previousManifestHash\",\n      \"signedAt\",\n      \"signerDeviceId\",\n      \"signerKeyFingerprint\",\n      \"signerUserId\",\n      \"version\",\n    ],\n    \"access event\",\n  );\n  const eventType = normalizeAccessEventType(record.eventType, \"access event\");\n  const objectKind = normalizeAccessObjectKind(\n    record.objectKind,\n    \"access event\",\n  );\n  const expectedObjectKind = expectedObjectKindForEventType(eventType);\n\n  if (objectKind !== expectedObjectKind) {\n    throwVerification(\n      \"object_mismatch\",\n      `access event ${eventType} must use objectKind ${expectedObjectKind}`,\n    );\n  }\n\n  return {\n    version: readVersion(record, \"access event\"),\n    eventId: readString(record, \"eventId\", \"access event\"),\n    eventType,\n    objectKind,\n    objectId: readString(record, \"objectId\", \"access event\"),\n    organizationId: readString(record, \"organizationId\", \"access event\"),\n    previousManifestHash: readNullableHashString(\n      record,\n      \"previousManifestHash\",\n      \"access event\",\n    ),\n    dependencyManifestHashes: normalizeUniqueSortedStrings(\n      readStringArray(record, \"dependencyManifestHashes\", \"access event\"),\n      \"access event dependencyManifestHashes\",\n    ),\n    bodyHash: readHashString(record, \"bodyHash\", \"access event\"),\n    signerUserId: readString(record, \"signerUserId\", \"access event\"),\n    signerDeviceId: readString(record, \"signerDeviceId\", \"access event\"),\n    signerKeyFingerprint: readHashString(\n      record,\n      \"signerKeyFingerprint\",\n      \"access event\",\n    ),\n    signedAt: readSignedAt(record, \"signedAt\", \"access event\"),\n  };\n}\n\nfunction normalizeAccessEvent(value: unknown): AccessEvent {\n  const record = assertExactKeys(\n    value,\n    [\n      \"bodyHash\",\n      \"dependencyManifestHashes\",\n      \"eventId\",\n      \"eventType\",\n      \"objectId\",\n      \"objectKind\",\n      \"organizationId\",\n      \"previousManifestHash\",\n      \"signature\",\n      \"signedAt\",\n      \"signerDeviceId\",\n      \"signerKeyFingerprint\",\n      \"signerUserId\",\n      \"version\",\n    ],\n    \"access event\",\n  );\n  const unsignedEvent = normalizeUnsignedAccessEvent({\n    version: record.version,\n    eventId: record.eventId,\n    eventType: record.eventType,\n    objectKind: record.objectKind,\n    objectId: record.objectId,\n    organizationId: record.organizationId,\n    previousManifestHash: record.previousManifestHash,\n    dependencyManifestHashes: record.dependencyManifestHashes,\n    bodyHash: record.bodyHash,\n    signerUserId: record.signerUserId,\n    signerDeviceId: record.signerDeviceId,\n    signerKeyFingerprint: record.signerKeyFingerprint,\n    signedAt: record.signedAt,\n  });\n\n  return {\n    ...unsignedEvent,\n    signature: readString(record, \"signature\", \"access event\"),\n  };\n}\n\nfunction unsignedAccessEventPayload(\n  event: UnsignedAccessEvent,\n): KeyingCanonicalPayload<UnsignedAccessEvent> {\n  return normalizeUnsignedAccessEvent(event);\n}\n\nfunction accessEventSigningBytes(event: UnsignedAccessEvent): Uint8Array {\n  return encodeDomainPayload(\n    \"tearleads.keying.access-event-signing\",\n    unsignedAccessEventPayload(event),\n  );\n}\n\nfunction toUnsignedAccessEvent(event: AccessEvent): UnsignedAccessEvent {\n  return {\n    version: event.version,\n    eventId: event.eventId,\n    eventType: event.eventType,\n    objectKind: event.objectKind,\n    objectId: event.objectId,\n    organizationId: event.organizationId,\n    previousManifestHash: event.previousManifestHash,\n    dependencyManifestHashes: event.dependencyManifestHashes,\n    bodyHash: event.bodyHash,\n    signerUserId: event.signerUserId,\n    signerDeviceId: event.signerDeviceId,\n    signerKeyFingerprint: event.signerKeyFingerprint,\n    signedAt: event.signedAt,\n  };\n}\n\nexport async function computeAccessEventBodyHash(\n  body: KeyingCanonicalJson,\n): Promise<string> {\n  return computeKeyingDomainHash(\"tearleads.keying.access-event-body\", body);\n}\n\nexport async function signAccessEvent(\n  event: UnsignedAccessEvent,\n  signingPrivateKey: Uint8Array,\n): Promise<AccessEvent> {\n  const normalizedEvent = normalizeUnsignedAccessEvent(event);\n  const signature = sign(\n    accessEventSigningBytes(normalizedEvent),\n    signingPrivateKey,\n  );\n\n  return {\n    ...normalizedEvent,\n    signature: bytesToBase64(signature),\n  };\n}\n\nexport async function computeAccessEventHash(\n  event: AccessEvent,\n): Promise<string> {\n  const payload: KeyingCanonicalPayload<AccessEvent> =\n    normalizeAccessEvent(event);\n\n  return computeKeyingDomainHash(\"tearleads.keying.access-event\", payload);\n}\n\nexport async function verifySignedAccessEvent({\n  body,\n  event,\n  signerPublicKey,\n}: VerifyAccessEventInput): Promise<\n  KeyingVerificationResult<VerifiedAccessEvent>\n> {\n  return runVerifier(async () => {\n    const normalizedBody = normalizeCanonicalJsonValue(\n      body,\n      \"access event body\",\n    );\n    const normalizedEvent = normalizeAccessEvent(event);\n    const computedBodyHash = await computeAccessEventBodyHash(normalizedBody);\n\n    if (computedBodyHash !== normalizedEvent.bodyHash) {\n      throwVerification(\n        \"hash_mismatch\",\n        \"access event body hash does not match body\",\n      );\n    }\n\n    const signerKeyFingerprint = await toFingerprint(signerPublicKey);\n    if (signerKeyFingerprint !== normalizedEvent.signerKeyFingerprint) {\n      throwVerification(\n        \"signer_mismatch\",\n        \"access event signer fingerprint does not match signer public key\",\n      );\n    }\n\n    let signature: Uint8Array;\n    try {\n      signature = base64ToBytes(normalizedEvent.signature);\n    } catch {\n      throwVerification(\"signature_mismatch\", \"access event signature invalid\");\n    }\n\n    if (\n      !verify(\n        signature,\n        accessEventSigningBytes(toUnsignedAccessEvent(normalizedEvent)),\n        signerPublicKey,\n      )\n    ) {\n      throwVerification(\n        \"signature_mismatch\",\n        \"access event signature verification failed\",\n      );\n    }\n\n    return makeVerifiedAccessEvent({\n      event: normalizedEvent,\n      body: normalizedBody,\n      eventHash: await computeAccessEventHash(normalizedEvent),\n    });\n  });\n}\n\nexport function normalizeReferencedPrincipalHead(\n  value: unknown,\n): ReferencedPrincipalHead {\n  const record = assertExactKeys(\n    value,\n    [\n      \"keyEpoch\",\n      \"keyFingerprint\",\n      \"principalId\",\n      \"principalType\",\n      \"stateHash\",\n      \"version\",\n    ],\n    \"referenced principal head\",\n  );\n\n  const version = readPositiveInteger(\n    record,\n    \"version\",\n    \"referenced principal head\",\n  );\n  if (!Number.isSafeInteger(version))\n    throwVerification(\n      \"invalid_shape\",\n      \"referenced principal head version must be a safe integer\",\n    );\n  return {\n    principalType: normalizeManagedPrincipalKind(\n      record.principalType,\n      \"referenced principal head\",\n    ),\n    principalId: readString(record, \"principalId\", \"referenced principal head\"),\n    version,\n    keyEpoch: readPositiveInteger(\n      record,\n      \"keyEpoch\",\n      \"referenced principal head\",\n    ),\n    stateHash: readHashString(record, \"stateHash\", \"referenced principal head\"),\n    keyFingerprint: readHashString(\n      record,\n      \"keyFingerprint\",\n      \"referenced principal head\",\n    ),\n  };\n}\n\nexport function referencedPrincipalKey(\n  principal: ReferencedPrincipalHead,\n): string {\n  return `${principal.principalType}:${principal.principalId}`;\n}\n\nexport function normalizeReferencedPrincipalHeads(\n  values: readonly unknown[],\n): ReferencedPrincipalHead[] {\n  const normalizedValues = values\n    .map(normalizeReferencedPrincipalHead)\n    .sort((left, right) =>\n      compareCanonicalStrings(\n        referencedPrincipalKey(left),\n        referencedPrincipalKey(right),\n      ),\n    );\n\n  let previousKey: string | null = null;\n  for (const principalHead of normalizedValues) {\n    const principalKey = referencedPrincipalKey(principalHead);\n    if (previousKey === principalKey) {\n      throwVerification(\n        \"duplicate_entry\",\n        \"access manifest referencedPrincipalHeads contains a duplicate\",\n      );\n    }\n    previousKey = principalKey;\n  }\n\n  return normalizedValues;\n}\n\nexport function normalizeAccessManifest(value: unknown): AccessManifest {\n  const record = assertExactKeys(\n    value,\n    [\n      \"epoch\",\n      \"eventHash\",\n      \"grantRoot\",\n      \"keyTargetHash\",\n      \"objectId\",\n      \"objectKind\",\n      \"organizationId\",\n      \"previousManifestHash\",\n      \"referencedPrincipalHeads\",\n      \"structuralHash\",\n      \"version\",\n    ],\n    \"access manifest\",\n  );\n  const referencedPrincipalHeads = record.referencedPrincipalHeads;\n\n  if (!Array.isArray(referencedPrincipalHeads)) {\n    throwVerification(\n      \"invalid_shape\",\n      \"access manifest.referencedPrincipalHeads must be an array\",\n    );\n  }\n\n  return {\n    version: readVersion(record, \"access manifest\"),\n    objectKind: normalizeAccessObjectKind(record.objectKind, \"access manifest\"),\n    objectId: readString(record, \"objectId\", \"access manifest\"),\n    organizationId: readString(record, \"organizationId\", \"access manifest\"),\n    epoch: readPositiveInteger(record, \"epoch\", \"access manifest\"),\n    previousManifestHash: readNullableHashString(\n      record,\n      \"previousManifestHash\",\n      \"access manifest\",\n    ),\n    eventHash: readHashString(record, \"eventHash\", \"access manifest\"),\n    structuralHash: readHashString(record, \"structuralHash\", \"access manifest\"),\n    grantRoot: readHashString(record, \"grantRoot\", \"access manifest\"),\n    referencedPrincipalHeads: normalizeReferencedPrincipalHeads(\n      referencedPrincipalHeads,\n    ),\n    keyTargetHash: readHashString(record, \"keyTargetHash\", \"access manifest\"),\n  };\n}\n\nexport async function computeAccessManifestHash(\n  manifest: AccessManifest,\n): Promise<string> {\n  const payload: KeyingCanonicalPayload<AccessManifest> =\n    normalizeAccessManifest(manifest);\n\n  return computeKeyingDomainHash(\"tearleads.keying.access-manifest\", payload);\n}\n\nexport async function verifyAccessManifest({\n  checkpointPredecessors,\n  event,\n  expectedManifestHash,\n  expectedObject,\n  expectedPreviousManifestHash,\n  localCheckpoint,\n  manifest,\n}: VerifyAccessManifestInput): Promise<\n  KeyingVerificationResult<VerifiedAccessManifest>\n> {\n  return runVerifier(async () => {\n    const normalizedManifest = normalizeAccessManifest(manifest);\n    const manifestHash = await computeAccessManifestHash(normalizedManifest);\n\n    if (manifestHash !== expectedManifestHash) {\n      throwVerification(\n        \"hash_mismatch\",\n        \"access manifest hash does not match expected hash\",\n      );\n    }\n\n    if (event.eventHash !== normalizedManifest.eventHash) {\n      throwVerification(\n        \"hash_mismatch\",\n        \"access manifest event hash does not match verified event\",\n      );\n    }\n\n    if (\n      event.event.objectKind !== normalizedManifest.objectKind ||\n      event.event.objectId !== normalizedManifest.objectId ||\n      event.event.organizationId !== normalizedManifest.organizationId\n    ) {\n      throwVerification(\n        \"object_mismatch\",\n        \"access manifest object does not match verified event\",\n      );\n    }\n\n    if (\n      event.event.previousManifestHash !==\n      normalizedManifest.previousManifestHash\n    ) {\n      throwVerification(\n        \"stale_predecessor\",\n        \"access manifest predecessor does not match verified event\",\n      );\n    }\n\n    if (\n      expectedPreviousManifestHash !== undefined &&\n      expectedPreviousManifestHash !== normalizedManifest.previousManifestHash\n    ) {\n      throwVerification(\n        \"stale_predecessor\",\n        \"access manifest predecessor does not match expected predecessor\",\n      );\n    }\n\n    if (\n      expectedObject &&\n      (expectedObject.objectKind !== normalizedManifest.objectKind ||\n        expectedObject.objectId !== normalizedManifest.objectId)\n    ) {\n      throwVerification(\n        \"object_mismatch\",\n        \"access manifest object does not match expected object\",\n      );\n    }\n\n    const checkpoint = accessManifestCheckpointFromManifest({\n      manifest: normalizedManifest,\n      manifestHash,\n    });\n    verifyAccessManifestLocalCheckpoint({\n      current: {\n        ...checkpoint,\n        previousManifestHash: normalizedManifest.previousManifestHash,\n      },\n      localCheckpoint,\n      checkpointPredecessors,\n    });\n\n    return makeVerifiedAccessManifest({\n      manifest: normalizedManifest,\n      manifestHash,\n      event,\n      checkpoint,\n    });\n  });\n}\n"]}

package/internal/crypto/keying/accessManifestSnapshot.d.ts

@@ -0,0 +1,14 @@
+import type { VerifiedAccessManifestCheckpointEvidence, VerifiedAccessManifestSnapshot } from "./accessManifestSnapshotTypes.js";
+import type { AccessManifest, AccessManifestCheckpoint, KeyingVerificationResult, VerifiedDocumentLinkSetSnapshot } from "./types.js";
+export type { VerifiedAccessManifestCheckpointEvidence, VerifiedAccessManifestSnapshot, } from "./accessManifestSnapshotTypes.js";
+export declare function verifyAccessManifestSnapshot(input: {
+    readonly expectedManifestHash: string;
+    readonly manifest: AccessManifest;
+}): Promise<KeyingVerificationResult<VerifiedAccessManifestSnapshot>>;
+export declare function verifyDocumentLinkSetSnapshot(input: {
+    readonly checkpointPredecessors?: readonly VerifiedAccessManifestCheckpointEvidence[] | undefined;
+    readonly expectedManifestHash: string;
+    readonly localCheckpoint?: AccessManifestCheckpoint | null | undefined;
+    readonly manifest: AccessManifest;
+    readonly state: unknown;
+}): Promise<KeyingVerificationResult<VerifiedDocumentLinkSetSnapshot>>;

package/internal/crypto/keying/accessManifestSnapshot.js

@@ -0,0 +1,52 @@
+import { computeAccessManifestHash, normalizeAccessManifest, } from "./accessEvent.js";
+import { makeVerifiedAccessManifestSnapshot } from "./accessManifestSnapshotTypes.js";
+import { accessManifestCheckpointFromManifest, verifyAccessManifestLocalCheckpoint, } from "./checkpoints.js";
+import { deriveDocumentLinkSetManifest, normalizeDocumentLinkSetManifestState, } from "./documentAccess.js";
+import { runVerifier, throwVerification } from "./shared.js";
+import { makeVerifiedDocumentLinkSetSnapshot } from "./types.js";
+function verifiedAccessManifestSnapshot(input) {
+    return makeVerifiedAccessManifestSnapshot({
+        ...input,
+        checkpoint: accessManifestCheckpointFromManifest(input),
+    });
+}
+export async function verifyAccessManifestSnapshot(input) {
+    return runVerifier(async () => {
+        const manifest = normalizeAccessManifest(input.manifest);
+        const manifestHash = await computeAccessManifestHash(manifest);
+        if (manifestHash !== input.expectedManifestHash) {
+            throwVerification("hash_mismatch", "access manifest snapshot hash does not match expected hash");
+        }
+        return verifiedAccessManifestSnapshot({ manifest, manifestHash });
+    });
+}
+export async function verifyDocumentLinkSetSnapshot(input) {
+    return runVerifier(async () => {
+        const state = normalizeDocumentLinkSetManifestState(input.state);
+        const derivedManifest = await deriveDocumentLinkSetManifest(state);
+        const derivedManifestHash = await computeAccessManifestHash(derivedManifest);
+        if (derivedManifestHash !== input.expectedManifestHash) {
+            throwVerification("hash_mismatch", "document link-set snapshot hash does not match derived state");
+        }
+        const verifiedManifest = await verifyAccessManifestSnapshot({
+            expectedManifestHash: input.expectedManifestHash,
+            manifest: input.manifest,
+        });
+        if (!verifiedManifest.ok) {
+            throw verifiedManifest.error;
+        }
+        verifyAccessManifestLocalCheckpoint({
+            checkpointPredecessors: input.checkpointPredecessors,
+            current: {
+                ...verifiedManifest.value.checkpoint,
+                previousManifestHash: verifiedManifest.value.manifest.previousManifestHash,
+            },
+            localCheckpoint: input.localCheckpoint,
+        });
+        return makeVerifiedDocumentLinkSetSnapshot({
+            ...verifiedManifest.value,
+            state,
+        });
+    });
+}
+//# sourceMappingURL=accessManifestSnapshot.js.map

package/internal/crypto/keying/accessManifestSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessManifestSnapshot.js","sourceRoot":"","sources":["accessManifestSnapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AAKvB,OAAO,EAAE,kCAAkC,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,EACL,oCAAoC,EACpC,mCAAmC,GACpC,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,6BAA6B,EAC7B,qCAAqC,GACtC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAO1D,OAAO,EAAE,mCAAmC,EAAE,MAAM,SAAS,CAAC;AAO9D,SAAS,8BAA8B,CAAC,KAGvC;IACC,OAAO,kCAAkC,CAAC;QACxC,GAAG,KAAK;QACR,UAAU,EAAE,oCAAoC,CAAC,KAAK,CAAC;KACxD,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAAC,KAGlD;IACC,OAAO,WAAW,CAAC,KAAK,IAAI,EAAE;QAC5B,MAAM,QAAQ,GAAG,uBAAuB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACzD,MAAM,YAAY,GAAG,MAAM,yBAAyB,CAAC,QAAQ,CAAC,CAAC;QAC/D,IAAI,YAAY,KAAK,KAAK,CAAC,oBAAoB,EAAE,CAAC;YAChD,iBAAiB,CACf,eAAe,EACf,4DAA4D,CAC7D,CAAC;QACJ,CAAC;QACD,OAAO,8BAA8B,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,6BAA6B,CAAC,KAQnD;IACC,OAAO,WAAW,CAAC,KAAK,IAAI,EAAE;QAC5B,MAAM,KAAK,GAAG,qCAAqC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACjE,MAAM,eAAe,GAAG,MAAM,6BAA6B,CAAC,KAAK,CAAC,CAAC;QACnE,MAAM,mBAAmB,GACvB,MAAM,yBAAyB,CAAC,eAAe,CAAC,CAAC;QACnD,IAAI,mBAAmB,KAAK,KAAK,CAAC,oBAAoB,EAAE,CAAC;YACvD,iBAAiB,CACf,eAAe,EACf,8DAA8D,CAC/D,CAAC;QACJ,CAAC;QACD,MAAM,gBAAgB,GAAG,MAAM,4BAA4B,CAAC;YAC1D,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;YAChD,QAAQ,EAAE,KAAK,CAAC,QAAQ;SACzB,CAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC;YACzB,MAAM,gBAAgB,CAAC,KAAK,CAAC;QAC/B,CAAC;QACD,mCAAmC,CAAC;YAClC,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;YACpD,OAAO,EAAE;gBACP,GAAG,gBAAgB,CAAC,KAAK,CAAC,UAAU;gBACpC,oBAAoB,EAClB,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,oBAAoB;aACvD;YACD,eAAe,EAAE,KAAK,CAAC,eAAe;SACvC,CAAC,CAAC;QACH,OAAO,mCAAmC,CAAC;YACzC,GAAG,gBAAgB,CAAC,KAAK;YACzB,KAAK;SACN,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  computeAccessManifestHash,\n  normalizeAccessManifest,\n} from \"./accessEvent\";\nimport type {\n  VerifiedAccessManifestCheckpointEvidence,\n  VerifiedAccessManifestSnapshot,\n} from \"./accessManifestSnapshotTypes\";\nimport { makeVerifiedAccessManifestSnapshot } from \"./accessManifestSnapshotTypes\";\nimport {\n  accessManifestCheckpointFromManifest,\n  verifyAccessManifestLocalCheckpoint,\n} from \"./checkpoints\";\nimport {\n  deriveDocumentLinkSetManifest,\n  normalizeDocumentLinkSetManifestState,\n} from \"./documentAccess\";\nimport { runVerifier, throwVerification } from \"./shared\";\nimport type {\n  AccessManifest,\n  AccessManifestCheckpoint,\n  KeyingVerificationResult,\n  VerifiedDocumentLinkSetSnapshot,\n} from \"./types\";\nimport { makeVerifiedDocumentLinkSetSnapshot } from \"./types\";\n\nexport type {\n  VerifiedAccessManifestCheckpointEvidence,\n  VerifiedAccessManifestSnapshot,\n} from \"./accessManifestSnapshotTypes\";\n\nfunction verifiedAccessManifestSnapshot(input: {\n  readonly manifest: AccessManifest;\n  readonly manifestHash: string;\n}): VerifiedAccessManifestSnapshot {\n  return makeVerifiedAccessManifestSnapshot({\n    ...input,\n    checkpoint: accessManifestCheckpointFromManifest(input),\n  });\n}\n\nexport async function verifyAccessManifestSnapshot(input: {\n  readonly expectedManifestHash: string;\n  readonly manifest: AccessManifest;\n}): Promise<KeyingVerificationResult<VerifiedAccessManifestSnapshot>> {\n  return runVerifier(async () => {\n    const manifest = normalizeAccessManifest(input.manifest);\n    const manifestHash = await computeAccessManifestHash(manifest);\n    if (manifestHash !== input.expectedManifestHash) {\n      throwVerification(\n        \"hash_mismatch\",\n        \"access manifest snapshot hash does not match expected hash\",\n      );\n    }\n    return verifiedAccessManifestSnapshot({ manifest, manifestHash });\n  });\n}\n\nexport async function verifyDocumentLinkSetSnapshot(input: {\n  readonly checkpointPredecessors?:\n    | readonly VerifiedAccessManifestCheckpointEvidence[]\n    | undefined;\n  readonly expectedManifestHash: string;\n  readonly localCheckpoint?: AccessManifestCheckpoint | null | undefined;\n  readonly manifest: AccessManifest;\n  readonly state: unknown;\n}): Promise<KeyingVerificationResult<VerifiedDocumentLinkSetSnapshot>> {\n  return runVerifier(async () => {\n    const state = normalizeDocumentLinkSetManifestState(input.state);\n    const derivedManifest = await deriveDocumentLinkSetManifest(state);\n    const derivedManifestHash =\n      await computeAccessManifestHash(derivedManifest);\n    if (derivedManifestHash !== input.expectedManifestHash) {\n      throwVerification(\n        \"hash_mismatch\",\n        \"document link-set snapshot hash does not match derived state\",\n      );\n    }\n    const verifiedManifest = await verifyAccessManifestSnapshot({\n      expectedManifestHash: input.expectedManifestHash,\n      manifest: input.manifest,\n    });\n    if (!verifiedManifest.ok) {\n      throw verifiedManifest.error;\n    }\n    verifyAccessManifestLocalCheckpoint({\n      checkpointPredecessors: input.checkpointPredecessors,\n      current: {\n        ...verifiedManifest.value.checkpoint,\n        previousManifestHash:\n          verifiedManifest.value.manifest.previousManifestHash,\n      },\n      localCheckpoint: input.localCheckpoint,\n    });\n    return makeVerifiedDocumentLinkSetSnapshot({\n      ...verifiedManifest.value,\n      state,\n    });\n  });\n}\n"]}

package/internal/crypto/keying/accessManifestSnapshotTypes.d.ts

@@ -0,0 +1,11 @@
+import type { AccessManifest, AccessManifestCheckpoint, VerifiedAccessManifest, VerifiedContainerAccessManifest, VerifiedDocumentLinkSetStateEvidence } from "./types.js";
+declare const verifiedAccessManifestSnapshotBrand: unique symbol;
+export interface VerifiedAccessManifestSnapshot {
+    readonly checkpoint: AccessManifestCheckpoint;
+    readonly manifest: AccessManifest;
+    readonly manifestHash: string;
+    readonly [verifiedAccessManifestSnapshotBrand]: true;
+}
+export type VerifiedAccessManifestCheckpointEvidence = VerifiedAccessManifest | VerifiedAccessManifestSnapshot | VerifiedContainerAccessManifest | VerifiedDocumentLinkSetStateEvidence;
+export declare function makeVerifiedAccessManifestSnapshot(value: Omit<VerifiedAccessManifestSnapshot, typeof verifiedAccessManifestSnapshotBrand>): VerifiedAccessManifestSnapshot;
+export {};

package/internal/crypto/keying/accessManifestSnapshotTypes.js

@@ -0,0 +1,8 @@
+const verifiedAccessManifestSnapshotBrand = Symbol("verifiedAccessManifestSnapshot");
+export function makeVerifiedAccessManifestSnapshot(value) {
+    return {
+        ...value,
+        [verifiedAccessManifestSnapshotBrand]: true,
+    };
+}
+//# sourceMappingURL=accessManifestSnapshotTypes.js.map

package/internal/crypto/keying/accessManifestSnapshotTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessManifestSnapshotTypes.js","sourceRoot":"","sources":["accessManifestSnapshotTypes.ts"],"names":[],"mappings":"AAQA,MAAM,mCAAmC,GAAkB,MAAM,CAC/D,gCAAgC,CACjC,CAAC;AAeF,MAAM,UAAU,kCAAkC,CAChD,KAGC;IAED,OAAO;QACL,GAAG,KAAK;QACR,CAAC,mCAAmC,CAAC,EAAE,IAAI;KAC5C,CAAC;AACJ,CAAC","sourcesContent":["import type {\n  AccessManifest,\n  AccessManifestCheckpoint,\n  VerifiedAccessManifest,\n  VerifiedContainerAccessManifest,\n  VerifiedDocumentLinkSetStateEvidence,\n} from \"./types\";\n\nconst verifiedAccessManifestSnapshotBrand: unique symbol = Symbol(\n  \"verifiedAccessManifestSnapshot\",\n);\n\nexport interface VerifiedAccessManifestSnapshot {\n  readonly checkpoint: AccessManifestCheckpoint;\n  readonly manifest: AccessManifest;\n  readonly manifestHash: string;\n  readonly [verifiedAccessManifestSnapshotBrand]: true;\n}\n\nexport type VerifiedAccessManifestCheckpointEvidence =\n  | VerifiedAccessManifest\n  | VerifiedAccessManifestSnapshot\n  | VerifiedContainerAccessManifest\n  | VerifiedDocumentLinkSetStateEvidence;\n\nexport function makeVerifiedAccessManifestSnapshot(\n  value: Omit<\n    VerifiedAccessManifestSnapshot,\n    typeof verifiedAccessManifestSnapshotBrand\n  >,\n): VerifiedAccessManifestSnapshot {\n  return {\n    ...value,\n    [verifiedAccessManifestSnapshotBrand]: true,\n  };\n}\n"]}

package/internal/crypto/keying/accessManifestVerificationRevision.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Revision of the access-manifest verification rules
+ * (`verifyContainerAccessManifest`, `verifyDocumentLinkSetManifest` and the
+ * checks they call). Bump it in the same change that makes either verifier
+ * accept less: servers key their persisted verification markers to it, so a
+ * bump makes every stored history re-verify under the tightened rules.
+ */
+export declare const ACCESS_MANIFEST_VERIFICATION_REVISION = 1;

package/internal/crypto/keying/accessManifestVerificationRevision.js

@@ -0,0 +1,9 @@
+/**
+ * Revision of the access-manifest verification rules
+ * (`verifyContainerAccessManifest`, `verifyDocumentLinkSetManifest` and the
+ * checks they call). Bump it in the same change that makes either verifier
+ * accept less: servers key their persisted verification markers to it, so a
+ * bump makes every stored history re-verify under the tightened rules.
+ */
+export const ACCESS_MANIFEST_VERIFICATION_REVISION = 1;
+//# sourceMappingURL=accessManifestVerificationRevision.js.map

package/internal/crypto/keying/accessManifestVerificationRevision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessManifestVerificationRevision.js","sourceRoot":"","sources":["accessManifestVerificationRevision.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,CAAC,CAAC","sourcesContent":["/**\n * Revision of the access-manifest verification rules\n * (`verifyContainerAccessManifest`, `verifyDocumentLinkSetManifest` and the\n * checks they call). Bump it in the same change that makes either verifier\n * accept less: servers key their persisted verification markers to it, so a\n * bump makes every stored history re-verify under the tightened rules.\n */\nexport const ACCESS_MANIFEST_VERIFICATION_REVISION = 1;\n"]}

package/internal/crypto/keying/canonical.d.ts

@@ -0,0 +1,12 @@
+import type { DocumentContentRecordMetadataInput, KeyingCanonicalJson, KeyingCanonicalPayload, KeyingHashDomain } from "./types.js";
+export declare function normalizeCanonicalJsonValue(value: unknown, label: string): KeyingCanonicalJson;
+export declare function encodeDomainPayload(domain: KeyingHashDomain, payload: KeyingCanonicalJson): Uint8Array;
+export declare function serializeKeyingCanonicalJson(value: KeyingCanonicalJson): string;
+export declare function computeKeyingDomainHash(domain: KeyingHashDomain, payload: KeyingCanonicalJson): Promise<string>;
+export declare function documentContentRecordMetadata(input: DocumentContentRecordMetadataInput): KeyingCanonicalPayload<DocumentContentRecordMetadataInput> & {
+    readonly recordKind: "loro_update";
+    readonly version: 1;
+};
+export declare function computeDocumentContentRecordMetadataHash(input: DocumentContentRecordMetadataInput): Promise<string>;
+export declare function computeDocumentContentRecordCiphertextHash(encryptedData: string): Promise<string>;
+export declare function computeDocumentContentRecordPlaintextHash(plaintext: Uint8Array, plaintextHashKey: CryptoKey): Promise<string>;

package/internal/crypto/keying/canonical.js

@@ -0,0 +1,126 @@
+import { isPlainObject } from "../../validators/isPlainObject.js";
+import { toFingerprint } from "../fingerprint.js";
+import { compareCanonicalStrings, throwVerification } from "./shared.js";
+const TEXT_ENCODER = new TextEncoder();
+const DOCUMENT_PLAINTEXT_HASH_DOMAIN = "tearleads.document.content-record-plaintext";
+export function normalizeCanonicalJsonValue(value, label) {
+    if (typeof value === "string" && !value.isWellFormed()) {
+        throwVerification("invalid_shape", `${label} must be well-formed Unicode`);
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throwVerification("invalid_shape", `${label} contains a non-finite number`);
+        }
+        if (Object.is(value, -0)) {
+            throwVerification("invalid_shape", `${label} contains negative zero`);
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => normalizeCanonicalJsonValue(item, `${label}[${index}]`));
+    }
+    if (!isPlainObject(value)) {
+        throwVerification("invalid_shape", `${label} must be canonical JSON`);
+    }
+    return Object.fromEntries(Object.keys(value)
+        .sort(compareCanonicalStrings)
+        .map((key) => {
+        if (!key.isWellFormed()) {
+            throwVerification("invalid_shape", `${label} property name must be well-formed Unicode`);
+        }
+        const item = value[key];
+        if (item === undefined) {
+            throwVerification("invalid_shape", `${label}.${key} is undefined`);
+        }
+        return [key, normalizeCanonicalJsonValue(item, `${label}.${key}`)];
+    }));
+}
+function stringifyNormalizedCanonicalJson(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stringifyNormalizedCanonicalJson(item)).join(",")}]`;
+    }
+    if (!isCanonicalJsonObject(value)) {
+        throwVerification("invalid_shape", "payload must be canonical JSON");
+    }
+    return `{${Object.keys(value)
+        .sort(compareCanonicalStrings)
+        .map((key) => {
+        const item = value[key];
+        if (item === undefined) {
+            throwVerification("invalid_shape", `payload.${key} is undefined`);
+        }
+        return `${JSON.stringify(key)}:${stringifyNormalizedCanonicalJson(item)}`;
+    })
+        .join(",")}}`;
+}
+function isCanonicalJsonObject(value) {
+    return isPlainObject(value);
+}
+function stringifyCanonicalJson(value) {
+    return stringifyNormalizedCanonicalJson(normalizeCanonicalJsonValue(value, "payload"));
+}
+export function encodeDomainPayload(domain, payload) {
+    return TEXT_ENCODER.encode(stringifyCanonicalJson({
+        domain,
+        payload,
+    }));
+}
+export function serializeKeyingCanonicalJson(value) {
+    return stringifyCanonicalJson(value);
+}
+export async function computeKeyingDomainHash(domain, payload) {
+    return toFingerprint(encodeDomainPayload(domain, payload));
+}
+export function documentContentRecordMetadata(input) {
+    return {
+        version: 1,
+        recordKind: "loro_update",
+        documentId: input.documentId,
+        updateId: input.updateId,
+        partialStartVersionVector: input.partialStartVersionVector,
+        partialEndVersionVector: input.partialEndVersionVector,
+        plaintextHash: input.plaintextHash,
+        ...(input.checkpointKind === undefined
+            ? {}
+            : { checkpointKind: input.checkpointKind }),
+        ...(input.checkpointPayloadKind === undefined
+            ? {}
+            : { checkpointPayloadKind: input.checkpointPayloadKind }),
+        ...(input.sourceVersionVector === undefined
+            ? {}
+            : { sourceVersionVector: input.sourceVersionVector }),
+    };
+}
+export async function computeDocumentContentRecordMetadataHash(input) {
+    return computeKeyingDomainHash("tearleads.document.content-record-metadata", documentContentRecordMetadata(input));
+}
+export async function computeDocumentContentRecordCiphertextHash(encryptedData) {
+    return computeKeyingDomainHash("tearleads.document.content-record-ciphertext", encryptedData);
+}
+export async function computeDocumentContentRecordPlaintextHash(plaintext, plaintextHashKey) {
+    const domain = TEXT_ENCODER.encode(DOCUMENT_PLAINTEXT_HASH_DOMAIN);
+    const input = new Uint8Array(4 + domain.byteLength + plaintext.byteLength);
+    new DataView(input.buffer).setUint32(0, domain.byteLength, false);
+    input.set(domain, 4);
+    input.set(plaintext, 4 + domain.byteLength);
+    const mac = new Uint8Array(await crypto.subtle.sign("HMAC", plaintextHashKey, input));
+    return Array.from(mac, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+//# sourceMappingURL=canonical.js.map

package/internal/crypto/keying/canonical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.js","sourceRoot":"","sources":["canonical.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from \"@tearleads/validators/isPlainObject\";\nimport { toFingerprint } from \"../fingerprint\";\nimport { compareCanonicalStrings, throwVerification } from \"./shared\";\nimport type {\n  DocumentContentRecordMetadataInput,\n  KeyingCanonicalJson,\n  KeyingCanonicalPayload,\n  KeyingHashDomain,\n} from \"./types\";\n\nconst TEXT_ENCODER = new TextEncoder();\nconst DOCUMENT_PLAINTEXT_HASH_DOMAIN =\n  \"tearleads.document.content-record-plaintext\";\n\nexport function normalizeCanonicalJsonValue(\n  value: unknown,\n  label: string,\n): KeyingCanonicalJson {\n  if (typeof value === \"string\" && !value.isWellFormed()) {\n    throwVerification(\"invalid_shape\", `${label} must be well-formed Unicode`);\n  }\n  if (\n    value === null ||\n    typeof value === \"string\" ||\n    typeof value === \"boolean\"\n  ) {\n    return value;\n  }\n\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value)) {\n      throwVerification(\n        \"invalid_shape\",\n        `${label} contains a non-finite number`,\n      );\n    }\n\n    if (Object.is(value, -0)) {\n      throwVerification(\"invalid_shape\", `${label} contains negative zero`);\n    }\n    return value;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item, index) =>\n      normalizeCanonicalJsonValue(item, `${label}[${index}]`),\n    );\n  }\n\n  if (!isPlainObject(value)) {\n    throwVerification(\"invalid_shape\", `${label} must be canonical JSON`);\n  }\n\n  return Object.fromEntries(\n    Object.keys(value)\n      .sort(compareCanonicalStrings)\n      .map((key) => {\n        if (!key.isWellFormed()) {\n          throwVerification(\n            \"invalid_shape\",\n            `${label} property name must be well-formed Unicode`,\n          );\n        }\n        const item = value[key];\n        if (item === undefined) {\n          throwVerification(\"invalid_shape\", `${label}.${key} is undefined`);\n        }\n        return [key, normalizeCanonicalJsonValue(item, `${label}.${key}`)];\n      }),\n  );\n}\n\nfunction stringifyNormalizedCanonicalJson(value: KeyingCanonicalJson): string {\n  if (value === null) {\n    return \"null\";\n  }\n\n  if (typeof value === \"string\") {\n    return JSON.stringify(value);\n  }\n\n  if (typeof value === \"number\") {\n    return JSON.stringify(value);\n  }\n\n  if (typeof value === \"boolean\") {\n    return value ? \"true\" : \"false\";\n  }\n\n  if (Array.isArray(value)) {\n    return `[${value.map((item) => stringifyNormalizedCanonicalJson(item)).join(\",\")}]`;\n  }\n\n  if (!isCanonicalJsonObject(value)) {\n    throwVerification(\"invalid_shape\", \"payload must be canonical JSON\");\n  }\n\n  return `{${Object.keys(value)\n    .sort(compareCanonicalStrings)\n    .map((key) => {\n      const item = value[key];\n      if (item === undefined) {\n        throwVerification(\"invalid_shape\", `payload.${key} is undefined`);\n      }\n      return `${JSON.stringify(key)}:${stringifyNormalizedCanonicalJson(item)}`;\n    })\n    .join(\",\")}}`;\n}\n\nfunction isCanonicalJsonObject(\n  value: KeyingCanonicalJson,\n): value is { readonly [key: string]: KeyingCanonicalJson } {\n  return isPlainObject(value);\n}\n\nfunction stringifyCanonicalJson(value: KeyingCanonicalJson): string {\n  return stringifyNormalizedCanonicalJson(\n    normalizeCanonicalJsonValue(value, \"payload\"),\n  );\n}\n\nexport function encodeDomainPayload(\n  domain: KeyingHashDomain,\n  payload: KeyingCanonicalJson,\n): Uint8Array {\n  return TEXT_ENCODER.encode(\n    stringifyCanonicalJson({\n      domain,\n      payload,\n    }),\n  );\n}\n\nexport function serializeKeyingCanonicalJson(\n  value: KeyingCanonicalJson,\n): string {\n  return stringifyCanonicalJson(value);\n}\n\nexport async function computeKeyingDomainHash(\n  domain: KeyingHashDomain,\n  payload: KeyingCanonicalJson,\n): Promise<string> {\n  return toFingerprint(encodeDomainPayload(domain, payload));\n}\n\nexport function documentContentRecordMetadata(\n  input: DocumentContentRecordMetadataInput,\n): KeyingCanonicalPayload<DocumentContentRecordMetadataInput> & {\n  readonly recordKind: \"loro_update\";\n  readonly version: 1;\n} {\n  return {\n    version: 1,\n    recordKind: \"loro_update\",\n    documentId: input.documentId,\n    updateId: input.updateId,\n    partialStartVersionVector: input.partialStartVersionVector,\n    partialEndVersionVector: input.partialEndVersionVector,\n    plaintextHash: input.plaintextHash,\n    ...(input.checkpointKind === undefined\n      ? {}\n      : { checkpointKind: input.checkpointKind }),\n    ...(input.checkpointPayloadKind === undefined\n      ? {}\n      : { checkpointPayloadKind: input.checkpointPayloadKind }),\n    ...(input.sourceVersionVector === undefined\n      ? {}\n      : { sourceVersionVector: input.sourceVersionVector }),\n  };\n}\n\nexport async function computeDocumentContentRecordMetadataHash(\n  input: DocumentContentRecordMetadataInput,\n): Promise<string> {\n  return computeKeyingDomainHash(\n    \"tearleads.document.content-record-metadata\",\n    documentContentRecordMetadata(input),\n  );\n}\n\nexport async function computeDocumentContentRecordCiphertextHash(\n  encryptedData: string,\n): Promise<string> {\n  return computeKeyingDomainHash(\n    \"tearleads.document.content-record-ciphertext\",\n    encryptedData,\n  );\n}\n\nexport async function computeDocumentContentRecordPlaintextHash(\n  plaintext: Uint8Array,\n  plaintextHashKey: CryptoKey,\n): Promise<string> {\n  const domain = TEXT_ENCODER.encode(DOCUMENT_PLAINTEXT_HASH_DOMAIN);\n  const input = new Uint8Array(4 + domain.byteLength + plaintext.byteLength);\n  new DataView(input.buffer).setUint32(0, domain.byteLength, false);\n  input.set(domain, 4);\n  input.set(plaintext, 4 + domain.byteLength);\n  const mac = new Uint8Array(\n    await crypto.subtle.sign(\"HMAC\", plaintextHashKey, input),\n  );\n  return Array.from(mac, (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n}\n"]}