witnora 0.10.0 → 0.10.3

package/dist/outcome-evaluator.js

@@ -0,0 +1,51 @@
+export function evaluateOutcome(effect, observation, options = {}) {
+    const empty = { must: effect.must.map((predicate) => ({ predicate, satisfied: false })), mustNot: effect.mustNot.map((predicate) => ({ predicate, violated: false })) };
+    if (options.observationFailed)
+        return { status: "OBSERVATION_FAILED", ...empty };
+    if (options.timedOut)
+        return { status: "TIMED_OUT", ...empty };
+    if (options.stale)
+        return { status: "STALE_OBSERVATION", ...empty };
+    if (options.targetAuditConflict)
+        return { status: "CONFLICT", ...empty };
+    if (!observation || typeof observation !== "object")
+        return { status: "INDETERMINATE", ...empty };
+    const must = effect.must.map((predicate) => ({ predicate, satisfied: predicateMatches(observation, predicate) }));
+    const mustNot = effect.mustNot.map((predicate) => ({ predicate, violated: predicateMatches(observation, predicate) }));
+    const positive = must.filter((item) => item.satisfied).length;
+    const prohibited = mustNot.some((item) => item.violated);
+    if (positive === must.length && !prohibited && options.targetAuditReconciled === true)
+        return { status: "VERIFIED", must, mustNot };
+    if (positive > 0 && positive < must.length && !prohibited)
+        return { status: "PARTIAL", must, mustNot };
+    return { status: "NOT_VERIFIED", must, mustNot };
+}
+export function predicateMatches(value, predicate) {
+    const resolved = resolvePath(value, predicate.path);
+    if (predicate.operator === "exists")
+        return resolved.exists;
+    if (predicate.operator === "not_exists")
+        return !resolved.exists;
+    if (!resolved.exists)
+        return false;
+    if (predicate.operator === "equals")
+        return Object.is(resolved.value, predicate.value);
+    if (predicate.operator === "not_equals")
+        return !Object.is(resolved.value, predicate.value);
+    if (predicate.operator === "contains")
+        return typeof resolved.value === "string"
+            ? resolved.value.includes(String(predicate.value))
+            : Array.isArray(resolved.value) && resolved.value.some((item) => Object.is(item, predicate.value));
+    if (predicate.operator === "count")
+        return (Array.isArray(resolved.value) || typeof resolved.value === "string") && resolved.value.length === predicate.value;
+    return false;
+}
+function resolvePath(value, path) {
+    let current = value;
+    for (const part of path.split(".")) {
+        if (!current || typeof current !== "object" || Array.isArray(current) || !Object.prototype.hasOwnProperty.call(current, part))
+            return { exists: false };
+        current = current[part];
+    }
+    return { exists: true, value: current };
+}

package/dist/privacy-manifest.js

@@ -0,0 +1,273 @@
+import { createHmac } from "node:crypto";
+import { canonicalJson, sha256Canonical } from "./canonical.js";
+export const PRIVACY_MANIFEST_VERSION = "witnora.privacy_manifest.v0.1";
+const SENSITIVE_NAME = /(authorization|api.?key|credential|cookie|password|private.?key|prompt|raw.?arg|raw.?result|secret|source.?code|token)/i;
+const SENSITIVE_VALUE = /(-----BEGIN [A-Z ]*PRIVATE KEY-----|\bBearer\s+[A-Za-z0-9._~+\/-]+=*|\bsk_(?:live|test|proj)_[A-Za-z0-9_-]{8,}|\brk_(?:live|test)_[A-Za-z0-9_-]{8,}|\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,})/;
+export function validatePrivacyManifest(input) {
+    const errors = [];
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("Privacy Manifest must be an object.");
+    const value = input;
+    const allowed = ["schemaVersion", "policyVersion", "tenantKeyId", "defaultDisposition", "fields", "cloudEndpoint", "artifacts", "encryption", "retentionDays", "debugMode", "keyOwnership"];
+    for (const key of Object.keys(value))
+        if (!allowed.includes(key))
+            errors.push(`$.${key} is not allowed.`);
+    for (const key of allowed)
+        if (!(key in value))
+            errors.push(`$.${key} is required.`);
+    if (value.schemaVersion !== PRIVACY_MANIFEST_VERSION)
+        errors.push(`$.schemaVersion must equal ${PRIVACY_MANIFEST_VERSION}.`);
+    if (typeof value.policyVersion !== "string" || !value.policyVersion)
+        errors.push("$.policyVersion must be a non-empty string.");
+    if (typeof value.tenantKeyId !== "string" || !value.tenantKeyId)
+        errors.push("$.tenantKeyId must be a non-empty string.");
+    if (value.defaultDisposition !== "deny")
+        errors.push("$.defaultDisposition must equal deny.");
+    if (!value.fields || typeof value.fields !== "object" || Array.isArray(value.fields))
+        errors.push("$.fields must be an object.");
+    else
+        for (const [path, disposition] of Object.entries(value.fields)) {
+            if (!path || path.startsWith(".") || path.endsWith("."))
+                errors.push(`Invalid field path ${JSON.stringify(path)}.`);
+            if (!["local_only", "disclose", "commit_only"].includes(disposition))
+                errors.push(`$.fields.${path} has an invalid disposition.`);
+        }
+    exactObject(value.cloudEndpoint, ["url", "transport"], "$.cloudEndpoint", errors);
+    const endpoint = value.cloudEndpoint;
+    if (typeof endpoint?.url !== "string" || !endpoint.url.startsWith("https://"))
+        errors.push("$.cloudEndpoint.url must use https.");
+    if (endpoint?.transport !== "https")
+        errors.push("$.cloudEndpoint.transport must equal https.");
+    exactObject(value.artifacts, ["rawUploadAllowed", "localStore", "pointerVisibility"], "$.artifacts", errors);
+    const artifacts = value.artifacts;
+    if (artifacts?.rawUploadAllowed !== false)
+        errors.push("$.artifacts.rawUploadAllowed must be false in v0.1.");
+    if (typeof artifacts?.localStore !== "string" || !artifacts.localStore)
+        errors.push("$.artifacts.localStore must be a non-empty string.");
+    if (artifacts?.pointerVisibility !== "opaque_private")
+        errors.push("$.artifacts.pointerVisibility must equal opaque_private.");
+    exactObject(value.encryption, ["inTransit", "atRest"], "$.encryption", errors);
+    const encryption = value.encryption;
+    if (encryption?.inTransit !== "TLS")
+        errors.push("$.encryption.inTransit must equal TLS.");
+    if (!["provider_managed", "customer_managed"].includes(String(encryption?.atRest)))
+        errors.push("$.encryption.atRest is invalid.");
+    if (!Number.isSafeInteger(value.retentionDays) || Number(value.retentionDays) < 1)
+        errors.push("$.retentionDays must be a positive safe integer.");
+    if (value.debugMode !== false)
+        errors.push("$.debugMode must be false.");
+    exactObject(value.keyOwnership, ["commitmentKey", "hostedDecryptionCapability"], "$.keyOwnership", errors);
+    const keys = value.keyOwnership;
+    if (keys?.commitmentKey !== "customer")
+        errors.push("$.keyOwnership.commitmentKey must equal customer.");
+    if (keys?.hostedDecryptionCapability !== "none")
+        errors.push("$.keyOwnership.hostedDecryptionCapability must equal none.");
+    if (errors.length)
+        throw new Error(`Invalid Privacy Manifest:\n${errors.map((error) => `- ${error}`).join("\n")}`);
+    return structuredClone(input);
+}
+export function transformForEgress(input, manifestInput, tenantKey) {
+    if (!tenantKey.byteLength)
+        throw new Error("A non-empty tenant privacy key is required.");
+    const manifest = validatePrivacyManifest(manifestInput);
+    const flat = flatten(input, "", manifest.fields);
+    const disclosed = {};
+    const commitments = {};
+    const omitted = [];
+    const unknown = Object.keys(flat).filter((path) => !(path in manifest.fields));
+    if (unknown.length)
+        throw new Error(`Privacy egress denied: undeclared fields ${unknown.sort().join(", ")}.`);
+    for (const path of Object.keys(flat).sort()) {
+        const value = flat[path];
+        const disposition = manifest.fields[path];
+        if (disposition === "local_only") {
+            omitted.push(path);
+            continue;
+        }
+        if (disposition === "disclose") {
+            if (value && typeof value === "object")
+                throw new Error(`Privacy egress denied: ${path} is an object; disclose explicit leaf paths instead.`);
+            if (SENSITIVE_NAME.test(path) || containsSecret(value))
+                throw new Error(`Privacy egress denied: ${path} appears sensitive and cannot be disclosed.`);
+            setPath(disclosed, path, value);
+            continue;
+        }
+        commitments[path] = {
+            algorithm: "HMAC-SHA256",
+            keyId: manifest.tenantKeyId,
+            digest: purposeHmac(tenantKey, manifest.tenantKeyId, path, value),
+        };
+    }
+    return {
+        schemaVersion: "witnora.minimal_disclosure.v0.1",
+        privacyManifestDigest: sha256Canonical(manifest),
+        disclosed,
+        commitments,
+        omitted,
+    };
+}
+export function validatePrivacyTransformAgainstManifest(manifestInput, transform) {
+    const manifest = validatePrivacyManifest(manifestInput);
+    const errors = [];
+    if (!transform || typeof transform !== "object" || Array.isArray(transform))
+        return ["Privacy transform must be an object."];
+    const value = transform;
+    exactObject(value, ["schemaVersion", "privacyManifestDigest", "disclosed", "commitments", "omitted"], "$", errors);
+    if (value.schemaVersion !== "witnora.minimal_disclosure.v0.1")
+        errors.push("Privacy transform schema version is unsupported.");
+    if (value.privacyManifestDigest !== sha256Canonical(manifest))
+        errors.push("Privacy transform references a different manifest digest.");
+    if (!isRecord(value.disclosed))
+        errors.push("Privacy transform disclosed output must be an object.");
+    if (!isRecord(value.commitments))
+        errors.push("Privacy transform commitments must be an object.");
+    if (!Array.isArray(value.omitted) || value.omitted.some((path) => typeof path !== "string"))
+        errors.push("Privacy transform omitted paths must be a string array.");
+    if (errors.length)
+        return errors;
+    const disclosed = flattenLeaves(value.disclosed);
+    const commitments = value.commitments;
+    const omitted = value.omitted;
+    const expectedDisclosed = pathsFor(manifest, "disclose");
+    const expectedCommitted = pathsFor(manifest, "commit_only");
+    const expectedOmitted = pathsFor(manifest, "local_only");
+    compareExactPaths(Object.keys(disclosed), expectedDisclosed, "disclosed", errors);
+    compareExactPaths(Object.keys(commitments), expectedCommitted, "committed", errors);
+    compareExactPaths(omitted, expectedOmitted, "omitted", errors);
+    for (const [path, disclosedValue] of Object.entries(disclosed)) {
+        if (SENSITIVE_NAME.test(path) || containsSecret(disclosedValue))
+            errors.push(`Disclosed path ${path} appears sensitive.`);
+    }
+    for (const [path, entry] of Object.entries(commitments)) {
+        exactObject(entry, ["algorithm", "keyId", "digest"], `$.commitments.${path}`, errors);
+        if (!isRecord(entry)
+            || entry.algorithm !== "HMAC-SHA256"
+            || entry.keyId !== manifest.tenantKeyId
+            || typeof entry.digest !== "string"
+            || !/^[a-f0-9]{64}$/.test(entry.digest))
+            errors.push(`Commitment ${path} is malformed or uses the wrong tenant key.`);
+    }
+    if (new Set(omitted).size !== omitted.length)
+        errors.push("Privacy transform contains duplicate omitted paths.");
+    return errors;
+}
+export function purposeHmac(key, keyId, purpose, value) {
+    return createHmac("sha256", key)
+        .update("witnora.tenant_commitment.v0.1\0")
+        .update(keyId)
+        .update("\0")
+        .update(purpose)
+        .update("\0")
+        .update(canonicalJson(value))
+        .digest("hex");
+}
+export function inspectPrivacy(manifestInput) {
+    const manifest = validatePrivacyManifest(manifestInput);
+    const groups = { local_only: [], disclose: [], commit_only: [] };
+    for (const [path, disposition] of Object.entries(manifest.fields))
+        groups[disposition].push(path);
+    return [
+        `Privacy manifest valid: ${manifest.policyVersion}`,
+        `Default egress: ${manifest.defaultDisposition}`,
+        `Cloud endpoint: ${manifest.cloudEndpoint.url} (${manifest.cloudEndpoint.transport})`,
+        `Disclosed: ${groups.disclose.sort().join(", ") || "none"}`,
+        `Committed with tenant HMAC: ${groups.commit_only.sort().join(", ") || "none"}`,
+        `Local only: ${groups.local_only.sort().join(", ") || "none"}`,
+        `Raw artifacts: remain in ${manifest.artifacts.localStore}; upload allowed: no`,
+        `Keys: commitment key held by ${manifest.keyOwnership.commitmentKey}; Hosted decryption: ${manifest.keyOwnership.hostedDecryptionCapability}`,
+        `Retention: ${manifest.retentionDays} days; debug mode: disabled`,
+        "Unknown egress path: none declared; undeclared fields fail closed.",
+    ].join("\n") + "\n";
+}
+export function examplePrivacyManifest() {
+    return {
+        schemaVersion: PRIVACY_MANIFEST_VERSION,
+        policyVersion: "privacy:metadata-only:v1",
+        tenantKeyId: "local-demo-key-v1",
+        defaultDisposition: "deny",
+        fields: {
+            actionType: "disclose",
+            outcomeStatus: "disclose",
+            policyDecision: "disclose",
+            resourceId: "commit_only",
+            actionParameters: "commit_only",
+            prompt: "local_only",
+            credentials: "local_only",
+            rawResult: "local_only",
+        },
+        cloudEndpoint: { url: "https://witnora.com/v1/evidence/minimal-claims", transport: "https" },
+        artifacts: { rawUploadAllowed: false, localStore: ".witnora/local-evidence", pointerVisibility: "opaque_private" },
+        encryption: { inTransit: "TLS", atRest: "provider_managed" },
+        retentionDays: 90,
+        debugMode: false,
+        keyOwnership: { commitmentKey: "customer", hostedDecryptionCapability: "none" },
+    };
+}
+function exactObject(value, allowed, path, errors) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        errors.push(`${path} must be an object.`);
+        return;
+    }
+    const objectValue = value;
+    for (const key of Object.keys(objectValue))
+        if (!allowed.includes(key))
+            errors.push(`${path}.${key} is not allowed.`);
+    for (const key of allowed)
+        if (!(key in objectValue))
+            errors.push(`${path}.${key} is required.`);
+}
+function flatten(value, prefix = "", declared = {}) {
+    const output = {};
+    for (const [key, item] of Object.entries(value)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (path in declared)
+            output[path] = item;
+        else if (item && typeof item === "object" && !Array.isArray(item))
+            Object.assign(output, flatten(item, path, declared));
+        else
+            output[path] = item;
+    }
+    return output;
+}
+function setPath(target, path, value) {
+    const parts = path.split(".");
+    let cursor = target;
+    for (const part of parts.slice(0, -1)) {
+        const next = cursor[part];
+        if (!next || typeof next !== "object" || Array.isArray(next))
+            cursor[part] = {};
+        cursor = cursor[part];
+    }
+    cursor[parts.at(-1)] = value;
+}
+function flattenLeaves(value, prefix = "") {
+    const output = {};
+    for (const [key, item] of Object.entries(value)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (item && typeof item === "object" && !Array.isArray(item))
+            Object.assign(output, flattenLeaves(item, path));
+        else
+            output[path] = item;
+    }
+    return output;
+}
+function pathsFor(manifest, disposition) {
+    return Object.entries(manifest.fields).filter(([, value]) => value === disposition).map(([path]) => path).sort();
+}
+function compareExactPaths(actualInput, expected, label, errors) {
+    const actual = [...actualInput].sort();
+    const missing = expected.filter((path) => !actual.includes(path));
+    const unexpected = actual.filter((path) => !expected.includes(path));
+    if (missing.length)
+        errors.push(`Privacy transform is missing ${label} paths: ${missing.join(", ")}.`);
+    if (unexpected.length)
+        errors.push(`Privacy transform contains undeclared ${label} paths: ${unexpected.join(", ")}.`);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function containsSecret(value) {
+    if (typeof value === "string")
+        return SENSITIVE_VALUE.test(value);
+    return SENSITIVE_VALUE.test(canonicalJson(value));
+}

package/dist/probe-protocol-v02.js

@@ -0,0 +1,101 @@
+import { createPrivateKey, createPublicKey, randomUUID, sign, verify } from "node:crypto";
+import { canonicalBytesV02, sha256CanonicalV02 } from "./canonical-v02.js";
+import { assertNotRevoked, verifyKeyCertificate, verifyRevocationJournal } from "./trust-v02.js";
+export function signProbeRequest(input, privateKeyPem) {
+    const core = { protocolVersion: "witnora.probe_observation_request.v0.2", requestId: input.requestId ?? randomUUID(), ...input };
+    return { ...core, signature: sign(null, canonicalBytesV02(core), createPrivateKey(privateKeyPem)).toString("base64") };
+}
+export function verifyProbeRequest(request, publicKeyPem, expected) {
+    const { signature, ...core } = request;
+    assertRequestShape(request);
+    if (!verify(null, canonicalBytesV02(core), createPublicKey(publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Probe observation request signature is invalid.");
+    assertBinding(request, { ...expected, at: expected.now });
+    const now = parseInstant(expected.now, "Probe verification time");
+    const notBefore = parseInstant(request.notBefore, "Probe request notBefore");
+    const expiresAt = parseInstant(request.expiresAt, "Probe request expiresAt");
+    const requestedAt = parseInstant(request.requestedAt, "Probe request requestedAt");
+    if (expiresAt <= notBefore || requestedAt < notBefore || requestedAt > expiresAt)
+        throw new Error("Probe observation request time window is invalid.");
+    if (now < notBefore || now > expiresAt)
+        throw new Error("Probe observation request is outside its validity interval.");
+}
+export function signProbeAttestation(input, privateKeyPem) {
+    const core = { protocolVersion: "witnora.probe_observation_attestation.v0.2", attestationId: input.attestationId ?? randomUUID(), ...input };
+    return { ...core, signature: sign(null, canonicalBytesV02(core), createPrivateKey(privateKeyPem)).toString("base64") };
+}
+export function verifyProbeAttestation(attestation, request, trust, expected) {
+    verifyRevocationJournal(trust.revocationJournal, trust.root);
+    assertAttestationShape(attestation);
+    const observedAtMs = parseInstant(attestation.observedAt, "Probe attestation observedAt");
+    const observedAt = new Date(observedAtMs);
+    const now = parseInstant(expected.now, "Probe attestation verification time");
+    const notBefore = parseInstant(request.notBefore, "Probe request notBefore");
+    const expiresAt = parseInstant(request.expiresAt, "Probe request expiresAt");
+    if (observedAtMs < notBefore || observedAtMs > expiresAt)
+        throw new Error("Probe observation falls outside the request window.");
+    if (observedAtMs > now + 30_000)
+        throw new Error("Probe observation is future-dated beyond clock skew.");
+    verifyKeyCertificate(trust.certificate, trust.root, observedAt, { role: "outcome_probe", tenantRef: expected.tenantRef, projectRef: expected.projectRef, environment: expected.environment });
+    assertNotRevoked(trust.certificate, trust.revocationJournal, observedAt);
+    const { signature, ...core } = attestation;
+    if (attestation.keyCertificateId !== trust.certificate.certificateId)
+        throw new Error("Probe attestation certificate ID mismatch.");
+    if (!verify(null, canonicalBytesV02(core), createPublicKey(trust.certificate.publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Probe observation attestation signature is invalid.");
+    if (attestation.requestId !== request.requestId || attestation.requestDigest !== sha256CanonicalV02(request) || attestation.nonce !== request.nonce)
+        throw new Error("Probe attestation is not bound to the observation request.");
+    assertBinding(attestation, { ...expected, at: observedAt });
+    if (!Number.isFinite(expected.maxFreshnessMs) || expected.maxFreshnessMs < 0)
+        throw new Error("Probe freshness limit is invalid.");
+    if (!Number.isInteger(attestation.dataFreshnessMs) || attestation.dataFreshnessMs < 0 || attestation.dataFreshnessMs > expected.maxFreshnessMs || now - observedAtMs > expected.maxFreshnessMs)
+        throw new Error("Probe observation is stale.");
+}
+export class ReplayLedger {
+    requests = new Set();
+    attestations = new Set();
+    acceptRequest(request) {
+        if (this.requests.has(request.nonce))
+            throw new Error("Probe request nonce was already used.");
+        this.requests.add(request.nonce);
+    }
+    acceptAttestation(attestation) {
+        if (this.attestations.has(attestation.attestationId))
+            throw new Error("Probe attestation ID was already used.");
+        this.attestations.add(attestation.attestationId);
+    }
+}
+function assertBinding(value, expected) {
+    for (const field of ["tenantRef", "projectRef", "environment", "actionDigest", "contractDigest", "resourceCommitment", "predicateDigest", "probeId"]) {
+        if (value[field] !== expected[field])
+            throw new Error(`Probe ${field} binding mismatch.`);
+    }
+}
+function assertRequestShape(request) {
+    if (request.protocolVersion !== "witnora.probe_observation_request.v0.2")
+        throw new Error("Unsupported Probe request version.");
+    for (const field of ["requestId", "nonce", "actionDigest", "contractDigest", "resourceCommitment", "predicateDigest", "probeId", "requestSignerKeyId", "signature"]) {
+        if (!request[field])
+            throw new Error(`Probe request ${field} is required.`);
+    }
+}
+function assertAttestationShape(attestation) {
+    if (attestation.protocolVersion !== "witnora.probe_observation_attestation.v0.2")
+        throw new Error("Unsupported Probe attestation version.");
+    for (const field of ["attestationId", "requestId", "requestDigest", "nonce", "probeId", "probeVersion", "observationSource", "rawObservationCommitment", "targetVersion", "keyCertificateId", "signature"]) {
+        if (!attestation[field])
+            throw new Error(`Probe attestation ${field} is required.`);
+    }
+    if (!Array.isArray(attestation.limitations))
+        throw new Error("Probe attestation limitations must be an array.");
+    if (!["VERIFIED", "NOT_VERIFIED", "INDETERMINATE"].includes(attestation.outcomeStatus))
+        throw new Error("Probe attestation outcome status is invalid.");
+}
+function parseInstant(value, field) {
+    if (typeof value === "string" && !/^\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.`);
+    const parsed = value instanceof Date ? value.getTime() : Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${field} must be a valid timestamp.`);
+    return parsed;
+}

package/dist/sandbox.js

@@ -191,7 +191,7 @@ Runs the deterministic sandbox adapter conformance suite locally.
   witnora sandbox push --adapter ./my-sandbox-adapter.js
 
 Runs conformance checks, writes the local report, and uploads it through the saved Witnora connection.
-Use \`agentcert connect\` first, or pass --server, --project, and --api-key.
+Use \`witnora onboard --project <project-id>\` first, or pass --server, --project, and --api-key.
 `;
     if (action === "stripe-readonly")
         return `Usage:

package/dist/trust-v02.js

@@ -0,0 +1,111 @@
+import { createHash, createPrivateKey, createPublicKey, sign, verify } from "node:crypto";
+import { canonicalBytesV02, sha256CanonicalV02 } from "./canonical-v02.js";
+export function createTrustRoot(input) {
+    const core = { ...input, protocolVersion: "witnora.trust_root.v0.2" };
+    return { ...core, rootFingerprint: createHash("sha256").update(createPublicKey(input.publicKeyPem).export({ format: "der", type: "spki" })).digest("hex") };
+}
+export function issueKeyCertificate(input, issuerPrivateKeyPem) {
+    const core = { ...input, protocolVersion: "witnora.key_certificate.v0.2" };
+    const certificateDigest = sha256CanonicalV02(core);
+    return { ...core, certificateDigest, signature: sign(null, canonicalBytesV02({ ...core, certificateDigest }), createPrivateKey(issuerPrivateKeyPem)).toString("base64") };
+}
+export function verifyKeyCertificate(certificate, root, at, expected) {
+    if (certificate.protocolVersion !== "witnora.key_certificate.v0.2")
+        throw new Error("Unsupported key certificate version.");
+    verifyPinnedRootShape(root);
+    const eventAt = parseInstant(at, "certificate verification time");
+    const rootNotBefore = parseInstant(root.notBefore, "trust root notBefore");
+    const rootNotAfter = parseInstant(root.notAfter, "trust root notAfter");
+    if (rootNotAfter <= rootNotBefore)
+        throw new Error("Pinned trust-root validity interval is invalid.");
+    if (eventAt < rootNotBefore || eventAt > rootNotAfter)
+        throw new Error("Pinned trust root is outside its validity interval.");
+    if (certificate.issuerRootId !== root.rootId)
+        throw new Error("Certificate issuer is not the pinned root.");
+    if (certificate.role !== expected.role || !root.allowedRoles.includes(certificate.role))
+        throw new Error("Certificate role is not authorized by the pinned root.");
+    if (certificate.tenantRef !== expected.tenantRef || certificate.projectRef !== expected.projectRef || certificate.environment !== expected.environment)
+        throw new Error("Certificate trust scope mismatch.");
+    const certificateNotBefore = parseInstant(certificate.notBefore, "certificate notBefore");
+    const certificateNotAfter = parseInstant(certificate.notAfter, "certificate notAfter");
+    if (certificateNotAfter <= certificateNotBefore)
+        throw new Error("Certificate validity interval is invalid.");
+    if (eventAt < certificateNotBefore || eventAt > certificateNotAfter)
+        throw new Error("Certificate is outside its validity interval.");
+    const { signature, certificateDigest, ...core } = certificate;
+    if (sha256CanonicalV02(core) !== certificateDigest)
+        throw new Error("Certificate digest mismatch.");
+    if (!verify(null, canonicalBytesV02({ ...core, certificateDigest }), createPublicKey(root.publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Certificate signature is invalid.");
+}
+export function appendRevocation(journal, input, rootPrivateKeyPem) {
+    const statements = journal?.statements ?? [];
+    const core = {
+        sequence: statements.length + 1,
+        previousJournalDigest: journal?.checkpointDigest ?? null,
+        ...input,
+        protocolVersion: "witnora.key_revocation_statement.v0.2",
+    };
+    const statementDigest = sha256CanonicalV02(core);
+    const statement = { ...core, statementDigest, signature: sign(null, canonicalBytesV02({ ...core, statementDigest }), createPrivateKey(rootPrivateKeyPem)).toString("base64") };
+    const next = [...statements, statement];
+    return { protocolVersion: "witnora.revocation_journal.v0.2", rootId: input.issuerRootId, statements: next, checkpointDigest: sha256CanonicalV02(next) };
+}
+export function verifyRevocationJournal(journal, root) {
+    if (journal.protocolVersion !== "witnora.revocation_journal.v0.2")
+        throw new Error("Unsupported revocation journal version.");
+    verifyPinnedRootShape(root);
+    let previous = null;
+    for (const [index, statement] of journal.statements.entries()) {
+        if (statement.protocolVersion !== "witnora.key_revocation_statement.v0.2")
+            throw new Error("Unsupported revocation statement version.");
+        if (statement.sequence !== index + 1 || statement.previousJournalDigest !== previous || statement.issuerRootId !== root.rootId)
+            throw new Error("Revocation journal continuity is invalid.");
+        parseInstant(statement.effectiveAt, "revocation effectiveAt");
+        const { signature, statementDigest, ...core } = statement;
+        if (sha256CanonicalV02(core) !== statementDigest)
+            throw new Error("Revocation statement digest mismatch.");
+        if (!verify(null, canonicalBytesV02({ ...core, statementDigest }), createPublicKey(root.publicKeyPem), Buffer.from(signature, "base64")))
+            throw new Error("Revocation statement signature is invalid.");
+        previous = sha256CanonicalV02(journal.statements.slice(0, index + 1));
+    }
+    if (journal.rootId !== root.rootId || journal.checkpointDigest !== (previous ?? sha256CanonicalV02([])))
+        throw new Error("Revocation journal checkpoint mismatch.");
+}
+export function assertNotRevoked(certificate, journal, eventAt) {
+    const eventTime = parseInstant(eventAt, "revocation event time");
+    for (const revocation of journal.statements) {
+        if (revocation.revokedId !== certificate.certificateId && revocation.revokedId !== certificate.subjectKeyId)
+            continue;
+        const effectiveAt = parseInstant(revocation.effectiveAt, "revocation effectiveAt");
+        if (revocation.retroactive || eventTime >= effectiveAt)
+            throw new Error("Certificate was revoked for the event time.");
+    }
+}
+export function assertRevocationJournalExtends(packetJournal, latestJournal) {
+    if (packetJournal.rootId !== latestJournal.rootId || packetJournal.statements.length > latestJournal.statements.length)
+        throw new Error("Revocation rollback detected: packet journal is not a prefix of the latest trusted journal.");
+    for (const [index, statement] of packetJournal.statements.entries()) {
+        if (statement.statementDigest !== latestJournal.statements[index]?.statementDigest)
+            throw new Error("Revocation rollback detected: packet journal diverges from the latest trusted journal.");
+    }
+}
+function parseInstant(value, field) {
+    if (typeof value === "string" && !/^\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.`);
+    const parsed = value instanceof Date ? value.getTime() : Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${field} must be a valid timestamp.`);
+    return parsed;
+}
+function verifyPinnedRootShape(root) {
+    if (root.protocolVersion !== "witnora.trust_root.v0.2" || root.algorithm !== "Ed25519")
+        throw new Error("Unsupported pinned trust root.");
+    const actualFingerprint = createHash("sha256").update(createPublicKey(root.publicKeyPem).export({ format: "der", type: "spki" })).digest("hex");
+    if (root.rootFingerprint !== actualFingerprint)
+        throw new Error("Pinned trust-root fingerprint mismatch.");
+    const notBefore = parseInstant(root.notBefore, "trust root notBefore");
+    const notAfter = parseInstant(root.notAfter, "trust root notAfter");
+    if (notAfter <= notBefore)
+        throw new Error("Pinned trust-root validity interval is invalid.");
+}

package/dist/try.js

@@ -92,7 +92,7 @@ export async function writeTryEvidence(options) {
                 kind: "synthetic_onboarding",
                 severity: "info",
                 message: `Deterministic ${options.template} sample passed. Replace it with evidence from the real agent boundary before making a release decision.`,
-                source: "agentcert try",
+                source: "witnora try",
                 artifactPath,
                 metadata: { synthetic: true, template: options.template, purpose: "onboarding_only" },
             }],