witnora 0.9.3 → 0.10.2

package/dist/assurance-loop-demo.js

@@ -0,0 +1,245 @@
+import { createHash, generateKeyPairSync, randomBytes, randomUUID, sign } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { compileAssuranceContract, diffAssuranceContracts, exampleAssuranceContract, resourceMatchesScope } from "./assurance-contract.js";
+import { canonicalJson, sha256Canonical } from "./canonical.js";
+import { serverAttestedValue, sourceSignedValue, outcomeProbeSignedValue, preconditionProbeSignedValue, resourceScopeProofSignedValue, verifyEvidencePacket, } from "./offline-verifier.js";
+import { examplePrivacyManifest, transformForEgress } from "./privacy-manifest.js";
+import { evaluateOutcome } from "./outcome-evaluator.js";
+export async function runAssuranceLoopDemo(options) {
+    const now = options.now ?? new Date();
+    const attack = options.attack ?? "none";
+    const contract = exampleAssuranceContract();
+    const compiledContract = compileAssuranceContract(contract);
+    const privacyManifest = examplePrivacyManifest();
+    const privacyInput = {
+        actionType: "SUBMIT",
+        outcomeStatus: "SATISFIED",
+        policyDecision: "REQUIRE_APPROVAL",
+        resourceId: "sandbox/record-001",
+        actionParameters: { expectedRevision: 1, status: "SUBMITTED" },
+        prompt: "Confidential local task context",
+        credentials: "local-demo-write-credential",
+        rawResult: { id: "record-001", status: "SUBMITTED", revision: 2 },
+    };
+    const privacy = transformForEgress(privacyInput, privacyManifest, randomBytes(32));
+    const resourceScopeAllowed = resourceMatchesScope(contract.authority.resourceScope, privacyInput.resourceId);
+    const canonicalAction = {
+        tenantRef: "tenant:local-demo",
+        projectRef: "project:assurance-loop",
+        agentRef: "agent:example-workflow-agent",
+        agentVersion: "1.0.0",
+        environment: "sandbox",
+        capability: contract.capability.id,
+        action: contract.capability.action,
+        resourceCommitment: privacy.commitments.resourceId.digest,
+        parameterCommitment: privacy.commitments.actionParameters.digest,
+        outcomePredicateDigest: sha256Canonical(contract.effect),
+        contractDigest: compiledContract.sourceContractDigest,
+        policyRef: contract.authority.policyRef,
+        mandateRef: contract.authority.mandateRef,
+    };
+    const actionDigest = sha256Canonical(canonicalAction);
+    const target = new LocalReferenceTarget();
+    const before = target.read("record-001");
+    if (before.status !== "DRAFT")
+        throw new Error("Reference target precondition failed.");
+    const preconditionObservedAt = new Date(now.getTime() + 10).toISOString();
+    const policy = { decision: "REQUIRE_APPROVAL", actionDigest, policyRef: contract.authority.policyRef };
+    const approval = {
+        approved: true,
+        actionDigest,
+        tenantRef: String(canonicalAction.tenantRef),
+        agentRef: String(canonicalAction.agentRef),
+        environment: String(canonicalAction.environment),
+        contractDigest: compiledContract.sourceContractDigest,
+        policyRef: contract.authority.policyRef,
+        resourceCommitment: String(canonicalAction.resourceCommitment),
+        expiresAt: new Date(now.getTime() + 2 * 60_000).toISOString(),
+        approverRef: "reviewer:local-demo",
+    };
+    const grant = {
+        id: `grant_${randomUUID()}`,
+        tenantRef: String(canonicalAction.tenantRef),
+        agentRef: String(canonicalAction.agentRef),
+        environment: String(canonicalAction.environment),
+        actionDigest,
+        contractDigest: compiledContract.sourceContractDigest,
+        policyRef: contract.authority.policyRef,
+        mandateRef: contract.authority.mandateRef,
+        resourceCommitment: String(canonicalAction.resourceCommitment),
+        maxUses: 1,
+        consumedCount: 0,
+        issuedAt: now.toISOString(),
+        expiresAt: new Date(now.getTime() + 5 * 60_000).toISOString(),
+    };
+    const grants = new AtomicLocalGrantStore();
+    grants.issue(grant.id);
+    grants.consume(grant.id);
+    grant.consumedCount = 1;
+    // The only write credential exists inside this controlled adapter boundary.
+    target.controlledSubmit("record-001", { status: "SUBMITTED", expectedRevision: 1 }, actionDigest);
+    const observed = target.read("record-001");
+    const audit = target.auditSince(0);
+    const targetAuditReconciled = audit.length === 1 && audit[0].actionDigest === actionDigest && audit[0].revision === observed.revision;
+    const normalizedObservation = { status: observed.status, prohibitedSideEffect: false };
+    const outcomeEvaluation = evaluateOutcome(contract.effect, normalizedObservation, { targetAuditReconciled });
+    const outcomeSatisfied = outcomeEvaluation.status === "VERIFIED";
+    const eventPayloads = [
+        ["witnora.run.started", { collector: "local-reference-collector", actionDigest }],
+        ["witnora.precondition.observed", { status: "SATISFIED", rawObservationCommitment: sha256Canonical(before) }],
+        ["witnora.policy.evaluated", policy],
+        ["witnora.approval.recorded", approval],
+        ["witnora.grant.consumed", { grantId: grant.id, actionDigest }],
+        ["witnora.action.executed", { actionDigest, adapter: "local-reference-target" }],
+        ["witnora.outcome.observed", { status: outcomeEvaluation.status, rawObservationCommitment: sha256Canonical(observed) }],
+        ["witnora.run.completed", { droppedEvents: 0, targetAuditReconciled }],
+    ];
+    const events = eventPayloads.reduce((result, [type, payload], index) => {
+        const previousHash = result.at(-1)?.eventHash ?? null;
+        const base = { sequence: index + 1, type, occurredAt: new Date(now.getTime() + index * 10).toISOString(), previousHash, payloadDigest: sha256Canonical(payload) };
+        result.push({ ...base, eventHash: sha256Canonical(base) });
+        return result;
+    }, []);
+    const artifactContent = Buffer.from(JSON.stringify({ before, observed, targetAuditReconciled }, null, 2));
+    const artifactBase64 = artifactContent.toString("base64");
+    const sourceKeys = generateKeyPairSync("ed25519");
+    const serverKeys = generateKeyPairSync("ed25519");
+    const probeKeys = generateKeyPairSync("ed25519");
+    const scopeKeys = generateKeyPairSync("ed25519");
+    const packet = {
+        schemaVersion: "witnora.verifiable_evidence_packet.v0.1",
+        packetId: `packet_${randomUUID()}`,
+        issuedAt: now.toISOString(),
+        contract,
+        compiledContract,
+        privacy: { manifest: privacyManifest, transformed: privacy },
+        action: { canonical: canonicalAction, digest: actionDigest },
+        precondition: {
+            status: "SATISFIED",
+            normalizedObservation: { status: before.status },
+            rawObservationCommitment: sha256Canonical(before),
+            observedAt: preconditionObservedAt,
+            dataFreshnessMs: 0,
+            probeRef: contract.observation.probeRef,
+            probeVersion: "1.0.0",
+            probeDigest: sha256Canonical({ implementation: "local-reference-read-path", version: "1.0.0" }),
+            observationSource: "local-reference-target/read-only",
+            independentReadPath: true,
+            probeSignature: emptySignature(),
+        },
+        resourceScopeProof: {
+            decision: resourceScopeAllowed ? "ALLOW" : "DENY",
+            contractScopeDigest: sha256Canonical(contract.authority.resourceScope),
+            resourceCommitment: String(canonicalAction.resourceCommitment),
+            evaluatedAt: new Date(now.getTime() + 15).toISOString(),
+            evaluatorRef: "local-policy-gateway-v1",
+            signature: emptySignature(),
+        },
+        policy,
+        approval,
+        grant,
+        events,
+        outcome: {
+            status: outcomeEvaluation.status,
+            expectedDigest: sha256Canonical(contract.effect),
+            normalizedObservation,
+            rawObservationCommitment: sha256Canonical(observed),
+            observedAt: new Date(now.getTime() + 60).toISOString(),
+            firstSatisfiedAt: new Date(now.getTime() + 60).toISOString(),
+            dataFreshnessMs: 0,
+            probeRef: contract.observation.probeRef,
+            probeVersion: "1.0.0",
+            probeDigest: sha256Canonical({ implementation: "local-reference-read-path", version: "1.0.0" }),
+            observationSource: "local-reference-target/read-only",
+            independentReadPath: true,
+            targetAuditReconciled,
+            probeSignature: emptySignature(),
+        },
+        artifacts: [{
+                path: "outcome-observation.json",
+                kind: "outcome_observation",
+                size: artifactContent.byteLength,
+                sha256: createHash("sha256").update(artifactContent).digest("hex"),
+                contentBase64: artifactBase64,
+            }],
+        evidenceStrength: { reported: true, recorded: true, enforced: true, outcomeVerified: outcomeSatisfied && targetAuditReconciled, independentlyReviewed: false },
+        sourceSignature: emptySignature(),
+        serverAttestation: emptySignature(),
+    };
+    packet.resourceScopeProof.signature = signValue(resourceScopeProofSignedValue(packet), "local-scope-evaluator-v1", scopeKeys.privateKey, scopeKeys.publicKey.export({ type: "spki", format: "pem" }).toString());
+    packet.precondition.probeSignature = signValue(preconditionProbeSignedValue(packet), "local-outcome-probe-v1", probeKeys.privateKey, probeKeys.publicKey.export({ type: "spki", format: "pem" }).toString());
+    packet.outcome.probeSignature = signValue(outcomeProbeSignedValue(packet), "local-outcome-probe-v1", probeKeys.privateKey, probeKeys.publicKey.export({ type: "spki", format: "pem" }).toString());
+    packet.sourceSignature = signValue(sourceSignedValue(packet), "local-source-v1", sourceKeys.privateKey, sourceKeys.publicKey.export({ type: "spki", format: "pem" }).toString());
+    packet.serverAttestation = signValue(serverAttestedValue(packet), "local-reference-server-v1", serverKeys.privateKey, serverKeys.publicKey.export({ type: "spki", format: "pem" }).toString());
+    applyAttack(packet, attack);
+    const trustBundle = {
+        schemaVersion: "witnora.verification_trust_bundle.v0.1",
+        keys: {
+            "local-source-v1": trustKey(sourceKeys.publicKey.export({ type: "spki", format: "pem" }).toString(), "source"),
+            "local-reference-server-v1": trustKey(serverKeys.publicKey.export({ type: "spki", format: "pem" }).toString(), "server_attestor"),
+            "local-outcome-probe-v1": trustKey(probeKeys.publicKey.export({ type: "spki", format: "pem" }).toString(), "outcome_probe"),
+            "local-scope-evaluator-v1": trustKey(scopeKeys.publicKey.export({ type: "spki", format: "pem" }).toString(), "resource_scope_evaluator"),
+        },
+    };
+    const report = verifyEvidencePacket(packet, new Date(now.getTime() + 1_000), trustBundle);
+    const changed = structuredClone(contract);
+    changed.subject.agentId = `${contract.subject.agentId}-v2`;
+    const revalidation = diffAssuranceContracts(contract, changed);
+    const outDir = resolve(options.outDir);
+    await mkdir(outDir, { recursive: true });
+    const packetPath = resolve(outDir, "witnora-evidence-packet.json");
+    const reportPath = resolve(outDir, "witnora-offline-verification.json");
+    const revalidationPath = resolve(outDir, "witnora-revalidation-diff.json");
+    const trustBundlePath = resolve(outDir, "witnora-trust-bundle.json");
+    await Promise.all([
+        writeFile(packetPath, `${JSON.stringify(packet, null, 2)}\n`, "utf8"),
+        writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8"),
+        writeFile(revalidationPath, `${JSON.stringify(revalidation, null, 2)}\n`, "utf8"),
+        writeFile(trustBundlePath, `${JSON.stringify(trustBundle, null, 2)}\n`, "utf8"),
+    ]);
+    return { packet, report, packetPath, reportPath, revalidationPath, trustBundlePath };
+}
+class LocalReferenceTarget {
+    record = { id: "record-001", status: "DRAFT", revision: 1 };
+    audit = [];
+    read(id) {
+        if (id !== this.record.id)
+            throw new Error("Record not found.");
+        return structuredClone(this.record);
+    }
+    controlledSubmit(id, input, actionDigest) {
+        if (id !== this.record.id || input.status !== "SUBMITTED" || input.expectedRevision !== this.record.revision)
+            throw new Error("Controlled execution rejected.");
+        this.record = { ...this.record, status: input.status, revision: this.record.revision + 1 };
+        this.audit.push({ sequence: this.audit.length + 1, actionDigest, revision: this.record.revision });
+    }
+    auditSince(sequence) {
+        return structuredClone(this.audit.filter((entry) => entry.sequence > sequence));
+    }
+}
+class AtomicLocalGrantStore {
+    state = new Map();
+    issue(id) { if (this.state.has(id))
+        throw new Error("Grant already exists."); this.state.set(id, "ISSUED"); }
+    consume(id) { if (this.state.get(id) !== "ISSUED")
+        throw new Error("Grant replay rejected."); this.state.set(id, "CONSUMED"); }
+}
+function signValue(value, keyId, privateKey, publicKeyPem) {
+    return { keyId, algorithm: "Ed25519", publicKeyPem, valueDigest: sha256Canonical(value), signature: sign(null, Buffer.from(canonicalJson(value)), privateKey).toString("base64") };
+}
+function emptySignature() { return { keyId: "", algorithm: "Ed25519", publicKeyPem: "", valueDigest: "", signature: "" }; }
+function trustKey(publicKeyPem, usage) {
+    return { publicKeyPem, usage, tenantRef: "tenant:local-demo", projectRef: "project:assurance-loop", environment: "sandbox" };
+}
+function applyAttack(packet, attack) {
+    if (attack === "parameter-substitution")
+        packet.action.canonical.parameterCommitment = "0".repeat(64);
+    if (attack === "replay")
+        packet.grant.consumedCount = 2;
+    if (attack === "false-success") {
+        packet.outcome.normalizedObservation = { status: "DRAFT", prohibitedSideEffect: false };
+    }
+    if (attack === "event-tamper")
+        packet.events[2].payloadDigest = "f".repeat(64);
+}

package/dist/authorization-state-machine.js

@@ -0,0 +1,35 @@
+export function decideCoveredDispatch(grant, request) {
+    if (!grant)
+        return denied("GRANT_MISSING");
+    if (grant.status === "REVOKED")
+        return denied("GRANT_REVOKED");
+    if (grant.status === "CONSUMED")
+        return denied("GRANT_ALREADY_CONSUMED");
+    if (request.incidentSuspended)
+        return denied("INCIDENT_SUSPENDED");
+    const now = Date.parse(request.now);
+    const notBefore = Date.parse(grant.notBefore);
+    const expiresAt = Date.parse(grant.expiresAt);
+    if (![now, notBefore, expiresAt].every(Number.isFinite) || notBefore >= expiresAt)
+        return denied("INVALID_TIME");
+    if (now < notBefore)
+        return denied("GRANT_NOT_YET_VALID");
+    if (now >= expiresAt)
+        return denied("GRANT_EXPIRED");
+    if (request.tenantRef !== grant.tenantRef)
+        return denied("TENANT_MISMATCH");
+    if (request.agentRef !== grant.agentRef)
+        return denied("AGENT_MISMATCH");
+    if (request.environment !== grant.environment)
+        return denied("ENVIRONMENT_MISMATCH");
+    if (request.policyRef !== grant.policyRef)
+        return denied("POLICY_VERSION_MISMATCH");
+    if (request.contractDigest !== grant.contractDigest)
+        return denied("CONTRACT_VERSION_MISMATCH");
+    if (request.actionDigest !== grant.actionDigest)
+        return denied("ACTION_DIGEST_MISMATCH");
+    return { allowed: true };
+}
+function denied(code) {
+    return { allowed: false, code };
+}

package/dist/authorization-v02.js

@@ -0,0 +1,60 @@
+import { createPrivateKey, createPublicKey, randomBytes, randomUUID, sign, verify } from "node:crypto";
+import { canonicalBytesV02, sha256CanonicalV02 } from "./canonical-v02.js";
+import { assertNotRevoked, verifyKeyCertificate } from "./trust-v02.js";
+export function signApprovalV02(input, privateKeyPem) {
+    const unsigned = { ...input, approvalId: input.approvalId ?? randomUUID(), protocolVersion: "witnora.signed_action_approval.v0.2" };
+    return { ...unsigned, signature: sign(null, canonicalBytesV02(unsigned), createPrivateKey(privateKeyPem)).toString("base64") };
+}
+export function signExecutionGrantV02(input, privateKeyPem) {
+    const unsigned = { ...input, grantId: input.grantId ?? randomUUID(), nonce: input.nonce ?? randomBytes(24).toString("hex"), protocolVersion: "witnora.signed_execution_grant.v0.2" };
+    return { ...unsigned, signature: sign(null, canonicalBytesV02(unsigned), createPrivateKey(privateKeyPem)).toString("base64") };
+}
+export function approvalDigestV02(approval) { return sha256CanonicalV02(approval); }
+export function verifyAuthorizationV02(input) {
+    const { approval, grant, trust, expected } = input;
+    const at = input.at ?? new Date();
+    if (approval.protocolVersion !== "witnora.signed_action_approval.v0.2" || grant.protocolVersion !== "witnora.signed_execution_grant.v0.2")
+        throw new Error("Unsupported signed authorization protocol.");
+    verifyKeyCertificate(trust.approvalCertificate, trust.root, new Date(approval.approvedAt), { role: "reviewer", tenantRef: expected.tenantRef, projectRef: expected.projectRef, environment: expected.environment });
+    verifyKeyCertificate(trust.grantCertificate, trust.root, new Date(grant.issuedAt), { role: "resource_scope_evaluator", tenantRef: expected.tenantRef, projectRef: expected.projectRef, environment: expected.environment });
+    assertNotRevoked(trust.approvalCertificate, trust.revocationJournal, new Date(approval.approvedAt));
+    assertNotRevoked(trust.grantCertificate, trust.revocationJournal, new Date(grant.issuedAt));
+    verifySignedApproval(approval, trust.approvalCertificate);
+    verifySignedGrant(grant, trust.grantCertificate);
+    for (const value of [approval, grant]) {
+        if (value.tenantRef !== expected.tenantRef || value.projectRef !== expected.projectRef || value.environment !== expected.environment || value.actionDigest !== expected.actionDigest)
+            throw new Error("Signed authorization scope or exact-action binding mismatch.");
+    }
+    if (grant.approvalDigest !== approvalDigestV02(approval))
+        throw new Error("Execution Grant is not bound to the signed approval.");
+    if (grant.maxUses !== 1)
+        throw new Error("Execution Grant must be single-use.");
+    const now = at.getTime();
+    const notBefore = parseInstant(grant.notBefore, "grant notBefore");
+    const grantExpiry = parseInstant(grant.expiresAt, "grant expiresAt");
+    const approvalExpiry = parseInstant(approval.expiresAt, "approval expiresAt");
+    if (now < notBefore || now > grantExpiry || now > approvalExpiry)
+        throw new Error("Signed authorization is not currently valid.");
+}
+function verifySignedApproval(value, certificate) {
+    if (value.signerKeyId !== certificate.subjectKeyId)
+        throw new Error("Signed approval key ID does not match its certificate.");
+    const { signature, ...unsigned } = value;
+    if (!verify(null, canonicalBytesV02(unsigned), createPublicKey(certificate.publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Signed approval signature is invalid.");
+}
+function verifySignedGrant(value, certificate) {
+    if (value.issuerKeyId !== certificate.subjectKeyId)
+        throw new Error("Signed execution Grant key ID does not match its certificate.");
+    const { signature, ...unsigned } = value;
+    if (!verify(null, canonicalBytesV02(unsigned), createPublicKey(certificate.publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Signed execution Grant signature is invalid.");
+}
+function parseInstant(value, field) {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value))
+        throw new Error(`${field} must be an RFC 3339 UTC timestamp with at most millisecond precision.`);
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${field} is invalid.`);
+    return parsed;
+}

package/dist/bundle.js

@@ -75,8 +75,30 @@ function evidenceStrengthFor(results) {
         level: weakest.level,
         claims: [...new Set(values.flatMap((value) => value.claims))],
         limitations: [...new Set(values.flatMap((value) => value.limitations))],
+        ...(() => {
+            const vectors = values.flatMap((value) => value.trustVector ? [value.trustVector] : []);
+            return vectors.length === values.length && vectors.length ? { trustVector: weakestTrustVector(vectors) } : {};
+        })(),
     };
 }
+function weakestTrustVector(vectors) {
+    const capture = weakest(vectors.map((item) => item.capture), ["self_reported", "collector_recorded", "boundary_observed"]);
+    const mediation = weakest(vectors.map((item) => item.mediation), ["none", "advisory", "enforced"]);
+    const completeness = weakest(vectors.map((item) => item.completeness), ["unknown", "partial", "target_reconciled"]);
+    const attestation = weakest(vectors.map((item) => item.attestation), ["unsigned", "source_signed", "platform_signed", "externally_witnessed"]);
+    const review = weakest(vectors.map((item) => item.review), ["none", "internal", "independent_external"]);
+    const outcome = vectors.some((item) => item.outcome === "contradicted")
+        ? "contradicted"
+        : vectors.some((item) => item.outcome === "unverified") ? "unverified" : "verified";
+    return {
+        schemaVersion: "witnora.evidence_trust_vector.v0.1",
+        capture, mediation, outcome, completeness, attestation, review,
+        limitations: [...new Set(vectors.flatMap((item) => item.limitations))],
+    };
+}
+function weakest(values, order) {
+    return values.reduce((left, right) => order.indexOf(left) <= order.indexOf(right) ? left : right);
+}
 function levelForScore(score, passed) {
     if (!passed) {
         return "No assurance decision";

package/dist/canonical-v02.js

@@ -0,0 +1,197 @@
+import { createHash } from "node:crypto";
+export const WITNORA_CANONICALIZATION_V02 = "witnora.canonical_json.v0.2";
+const MAX_DEPTH = 64;
+/** Strict v0.2 profile: JSON only, safe integers only, no duplicate keys or negative zero. */
+export function canonicalJsonV02(value) {
+    return JSON.stringify(canonicalValueV02(value, "$", 0));
+}
+export function canonicalBytesV02(value) {
+    return Buffer.from(canonicalJsonV02(value), "utf8");
+}
+export function sha256CanonicalV02(value) {
+    return createHash("sha256").update(canonicalBytesV02(value)).digest("hex");
+}
+export function parseStrictJsonV02(input) {
+    const parser = new StrictJsonParser(input);
+    const value = parser.parseValue(0);
+    parser.skipWhitespace();
+    if (!parser.done())
+        throw new Error(`Unexpected token at offset ${parser.offset()}.`);
+    return canonicalValueV02(value, "$", 0);
+}
+function canonicalValueV02(value, path, depth) {
+    if (depth > MAX_DEPTH)
+        throw new Error(`${path} exceeds the v0.2 nesting limit of ${MAX_DEPTH}.`);
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        assertValidUnicode(value, path);
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} contains a non-finite number.`);
+        if (Object.is(value, -0))
+            throw new Error(`${path} contains negative zero.`);
+        if (!Number.isSafeInteger(value))
+            throw new Error(`${path} must be a safe integer; encode decimals as normalized strings.`);
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map((entry, index) => canonicalValueV02(entry, `${path}[${index}]`, depth + 1));
+    if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+        const source = value;
+        const output = {};
+        for (const key of Object.keys(source).sort()) {
+            assertValidUnicode(key, `${path} key`);
+            if (source[key] === undefined)
+                throw new Error(`${path}.${key} is undefined.`);
+            output[key] = canonicalValueV02(source[key], `${path}.${key}`, depth + 1);
+        }
+        return output;
+    }
+    throw new Error(`${path} contains unsupported ${typeof value}.`);
+}
+class StrictJsonParser {
+    source;
+    index = 0;
+    constructor(source) {
+        this.source = source;
+    }
+    offset() { return this.index; }
+    done() { return this.index >= this.source.length; }
+    skipWhitespace() { while (/\s/u.test(this.source[this.index] ?? ""))
+        this.index += 1; }
+    parseValue(depth) {
+        if (depth > MAX_DEPTH)
+            throw new Error(`JSON exceeds the v0.2 nesting limit of ${MAX_DEPTH}.`);
+        this.skipWhitespace();
+        const token = this.source[this.index];
+        if (token === "{")
+            return this.parseObject(depth + 1);
+        if (token === "[")
+            return this.parseArray(depth + 1);
+        if (token === '"')
+            return this.parseString();
+        if (token === "t" && this.consume("true"))
+            return true;
+        if (token === "f" && this.consume("false"))
+            return false;
+        if (token === "n" && this.consume("null"))
+            return null;
+        if (token === "-" || /[0-9]/u.test(token ?? ""))
+            return this.parseNumber();
+        throw new Error(`Invalid JSON value at offset ${this.index}.`);
+    }
+    parseObject(depth) {
+        this.expect("{");
+        this.skipWhitespace();
+        const output = {};
+        const seen = new Set();
+        if (this.peek("}")) {
+            this.index += 1;
+            return output;
+        }
+        while (true) {
+            this.skipWhitespace();
+            const key = this.parseString();
+            if (seen.has(key))
+                throw new Error(`Duplicate JSON object key ${JSON.stringify(key)}.`);
+            seen.add(key);
+            this.skipWhitespace();
+            this.expect(":");
+            output[key] = this.parseValue(depth);
+            this.skipWhitespace();
+            if (this.peek("}")) {
+                this.index += 1;
+                return output;
+            }
+            this.expect(",");
+        }
+    }
+    parseArray(depth) {
+        this.expect("[");
+        this.skipWhitespace();
+        const output = [];
+        if (this.peek("]")) {
+            this.index += 1;
+            return output;
+        }
+        while (true) {
+            output.push(this.parseValue(depth));
+            this.skipWhitespace();
+            if (this.peek("]")) {
+                this.index += 1;
+                return output;
+            }
+            this.expect(",");
+        }
+    }
+    parseString() {
+        const start = this.index;
+        this.expect('"');
+        let escaped = false;
+        while (!this.done()) {
+            const char = this.source[this.index++];
+            if (!escaped && char === '"') {
+                const token = this.source.slice(start, this.index);
+                try {
+                    const value = JSON.parse(token);
+                    assertValidUnicode(value, `JSON string at offset ${start}`);
+                    return value;
+                }
+                catch {
+                    throw new Error(`Invalid JSON string at offset ${start}.`);
+                }
+            }
+            if (!escaped && char === "\\")
+                escaped = true;
+            else
+                escaped = false;
+            if ((char?.charCodeAt(0) ?? 32) < 32)
+                throw new Error(`Unescaped control character at offset ${this.index - 1}.`);
+        }
+        throw new Error(`Unterminated JSON string at offset ${start}.`);
+    }
+    parseNumber() {
+        const rest = this.source.slice(this.index);
+        const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(rest);
+        if (!match)
+            throw new Error(`Invalid JSON number at offset ${this.index}.`);
+        this.index += match[0].length;
+        const value = Number(match[0]);
+        if (!Number.isFinite(value))
+            throw new Error("Non-finite JSON number is not supported.");
+        if (Object.is(value, -0))
+            throw new Error("Negative zero is not supported.");
+        if (!Number.isSafeInteger(value))
+            throw new Error("Only safe integer JSON numbers are supported; use normalized decimal strings.");
+        return value;
+    }
+    consume(value) {
+        if (!this.source.startsWith(value, this.index))
+            return false;
+        this.index += value.length;
+        return true;
+    }
+    peek(value) { return this.source[this.index] === value; }
+    expect(value) {
+        if (!this.peek(value))
+            throw new Error(`Expected ${JSON.stringify(value)} at offset ${this.index}.`);
+        this.index += 1;
+    }
+}
+function assertValidUnicode(value, path) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                throw new Error(`${path} contains an unpaired Unicode surrogate.`);
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            throw new Error(`${path} contains an unpaired Unicode surrogate.`);
+        }
+    }
+}

package/dist/canonical.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+export const WITNORA_CANONICALIZATION_VERSION = "witnora.canonical_json.v0.1";
+/** Stable JSON used by v0.1 digests. Arrays remain ordered; undefined is rejected. */
+export function canonicalJson(value) {
+    return JSON.stringify(canonicalValue(value, "$"));
+}
+export function sha256Canonical(value) {
+    return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+function canonicalValue(value, path) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} contains a non-finite number.`);
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (Array.isArray(value))
+        return value.map((item, index) => canonicalValue(item, `${path}[${index}]`));
+    if (value && typeof value === "object") {
+        const source = value;
+        const output = {};
+        for (const key of Object.keys(source).sort()) {
+            if (source[key] === undefined)
+                throw new Error(`${path}.${key} is undefined; canonical input must be explicit.`);
+            output[key] = canonicalValue(source[key], `${path}.${key}`);
+        }
+        return output;
+    }
+    throw new Error(`${path} contains unsupported ${typeof value}.`);
+}