@zanii/certify 0.5.0 → 0.6.0

package/README.md

@@ -97,6 +97,38 @@ proof establishes commitment to supplied data; it does not establish content tru
 ACL permission or quality. The Node package also exposes Nitro verification, a runtime
 reporter and a reference gateway; those host integrations are not Python SDK equivalents.
 
+## Beacon reporting
+
+`startBeacon` sends immediately, then waits the configured interval after each completed
+operation. Intervals must be between 1,000 and 2,147,483,647 milliseconds. Each client allows
+one underlying operation; concurrent `send()` calls return a busy failure without queuing.
+The full operation has a ten second deadline, including fingerprint collection, signing and
+reading the response. Replies are capped at 32KiB; redirects and credentialed URLs are refused.
+
+`stop()` disables automatic reporting and aborts the active request. Manual `send()` remains
+available. An injected callback that ignores cancellation keeps its slot until it returns;
+late callbacks cannot submit a report. Result observer exceptions do not interrupt reporting.
+
+`startBeacon`, `createRuntimeReporter` and `createRuntimeGateway` accept optional
+`transportKey: process.env.CERTIFY_TRANSPORT_KEY`. Use an agent-bound `ctk_` admission
+credential issued by the owner/admin transport-key controls, never a management API key.
+It travels only in the authority's Authorization header, outside signed documents and
+hashes. The gateway never forwards it to a protected backend. Invalid prefixes and
+non-HTTPS beacon endpoints are refused before I/O, except literal loopback/localhost
+for local development. Runtime reporter/gateway authority URLs keep their existing
+HTTPS requirement. Anonymous signed clients still work; transport admission does not
+replace signatures, approved workload binding or replay checks. Redirects remain refused.
+Callback error messages and beacon response echoes redact the supplied credential.
+
+The reporter handles challenge/evidence and the gateway handles consume. Lease request
+builders produce signed documents; this package does not provide a general HTTP lease
+acquisition or management client. Injected transports must keep credentials private and
+honor the same redirect/deadline contract.
+
+The package root also exports `JsonFetchResult`, `logPositionOk`,
+`RUNTIME_NITRO_MAX_BYTES` and `RUNTIME_NITRO_MAX_SKEW_SECONDS` for callers validating
+issuer responses, status log positions and raw runtime attestations.
+
 ## Check changes
 
 Run from the repository root:

package/dist/beacon-client.d.ts

@@ -12,10 +12,12 @@ export interface BeaconOptions {
     signer: Signer;
     /** The fingerprint the agent runs now, or a function returning it (read at every report). */
     fingerprint: FingerprintValue | (() => FingerprintValue | Promise<FingerprintValue>);
-    /** Default 300 000 (five minutes); at least 1 000. */
+    /** Default 300 000 (five minutes); 1 000 to 2 147 483 647. */
     intervalMs?: number;
     fetch?: typeof fetch;
-    /** Called with every result, including failures; the timer never throws. */
+    /** Optional agent-bound admission credential; never use a management API key. */
+    transportKey?: string;
+    /** Called when a started report finishes, including failures; busy rejections are returned only. */
     onResult?: (result: BeaconResult) => void;
 }
 export interface BeaconResult {
@@ -29,7 +31,7 @@ export interface BeaconResult {
     error?: string;
 }
 export interface BeaconHandle {
-    /** Send one report now. */
+    /** Send one report now; a concurrent underlying report returns a busy failure. */
     send: () => Promise<BeaconResult>;
     stop: () => void;
 }

package/dist/beacon-client.js

@@ -4,49 +4,148 @@ import { randomBytes } from "node:crypto";
 import { credentialHash } from "@zanii/credentials";
 import { buildBeacon } from "./beacon.js";
 import { isSha } from "./shared.js";
+import { machineTransportHeaders, redactTransportText } from "./transport-key.js";
 export const BEACON_INTERVAL_MS = 300_000;
 const MIN_INTERVAL_MS = 1_000;
+const MAX_INTERVAL_MS = 2_147_483_647;
 const TIMEOUT_MS = 10_000;
+const MAX_RESPONSE_BYTES = 32 * 1024;
 /** Start reporting: one report now, then one every `intervalMs`. */
 export function startBeacon(opts) {
     const endpoint = new URL("/v1/beacon", opts.url);
-    if (endpoint.protocol !== "https:" && endpoint.protocol !== "http:")
-        throw new Error("url must be http(s)");
+    if ((endpoint.protocol !== "https:" && endpoint.protocol !== "http:") || endpoint.username || endpoint.password)
+        throw new Error("url must be http(s) without credentials");
+    const transportKey = opts.transportKey, transportHeaders = machineTransportHeaders(endpoint, transportKey);
     const certificate = typeof opts.certificate === "string" ? opts.certificate : credentialHash(opts.certificate);
     if (!isSha(certificate))
         throw new Error("certificate must be a certificate or its hash");
     const intervalMs = opts.intervalMs ?? BEACON_INTERVAL_MS;
-    if (!Number.isInteger(intervalMs) || intervalMs < MIN_INTERVAL_MS)
-        throw new Error(`intervalMs must be an integer of at least ${MIN_INTERVAL_MS}`);
+    if (!Number.isSafeInteger(intervalMs) || intervalMs < MIN_INTERVAL_MS || intervalMs > MAX_INTERVAL_MS)
+        throw new Error(`intervalMs must be an integer from ${MIN_INTERVAL_MS} to ${MAX_INTERVAL_MS}`);
     const doFetch = opts.fetch ?? fetch;
-    const send = async () => {
-        let result;
+    let running = false, automatic = true;
+    let timer = null, controller = null;
+    const failure = (error) => ({ ok: false, status: 0, body: null, error: redactTransportText(error instanceof Error ? error.message : String(error), transportKey) });
+    const notify = (result) => {
         try {
-            const fp = typeof opts.fingerprint === "function" ? await opts.fingerprint() : opts.fingerprint;
-            const report = await buildBeacon({
-                certificate,
-                fingerprint: typeof fp === "string" ? fp : fp.id,
-                ...(typeof fp === "string" ? {} : { fingerprintManifest: fp }),
-                observedAt: new Date().toISOString(),
-                nonce: randomBytes(18).toString("base64url"),
-            }, opts.signer);
-            const res = await doFetch(endpoint.href, {
-                method: "POST",
-                headers: { "content-type": "application/json; charset=utf-8" },
-                body: JSON.stringify(report),
-                signal: AbortSignal.timeout(TIMEOUT_MS),
-            });
-            const body = await res.json().catch(() => null);
-            result = { ok: res.status === 202, status: res.status, body };
-        }
-        catch (e) {
-            result = { ok: false, status: 0, body: null, error: e instanceof Error ? e.message : String(e) };
-        }
-        opts.onResult?.(result);
-        return result;
+            void Promise.resolve(opts.onResult?.(result)).catch(() => { });
+        }
+        catch { /* Observers cannot interrupt reporting. */ }
     };
+    const check = (signal) => { if (signal.aborted)
+        throw signal.reason; };
+    async function report(signal) {
+        check(signal);
+        const fp = typeof opts.fingerprint === "function" ? await opts.fingerprint() : opts.fingerprint;
+        check(signal);
+        const report = await buildBeacon({
+            certificate,
+            fingerprint: typeof fp === "string" ? fp : fp.id,
+            ...(typeof fp === "string" ? {} : { fingerprintManifest: fp }),
+            observedAt: new Date().toISOString(),
+            nonce: randomBytes(18).toString("base64url"),
+        }, opts.signer);
+        check(signal);
+        const res = await doFetch(endpoint.href, {
+            method: "POST",
+            redirect: "error", credentials: "omit",
+            headers: { "content-type": "application/json; charset=utf-8", ...transportHeaders },
+            body: JSON.stringify(report),
+            signal,
+        });
+        if (signal.aborted) {
+            void res.body?.cancel().catch(() => { });
+            check(signal);
+        }
+        if (res.redirected || (res.url && new URL(res.url).origin !== endpoint.origin)) {
+            void res.body?.cancel().catch(() => { });
+            throw new Error("beacon endpoint redirected the request");
+        }
+        const length = res.headers.get("content-length");
+        if (length && (!/^\d+$/.test(length) || Number(length) > MAX_RESPONSE_BYTES)) {
+            void res.body?.cancel().catch(() => { });
+            throw new Error("beacon response exceeds 32KiB");
+        }
+        const reader = res.body?.getReader(), bytes = new Uint8Array(MAX_RESPONSE_BYTES);
+        const cancelled = () => { void reader?.cancel().catch(() => { }); };
+        signal.addEventListener("abort", cancelled, { once: true });
+        let size = 0, reads = 0;
+        try {
+            if (reader)
+                for (;;) {
+                    const part = await reader.read();
+                    check(signal);
+                    if (part.done)
+                        break;
+                    if (size + part.value.byteLength > MAX_RESPONSE_BYTES)
+                        throw new Error("beacon response exceeds 32KiB");
+                    bytes.set(part.value, size);
+                    size += part.value.byteLength;
+                    if (++reads % 64 === 0)
+                        await new Promise((resolve) => setImmediate(resolve));
+                    check(signal);
+                }
+        }
+        catch (error) {
+            cancelled();
+            throw error;
+        }
+        finally {
+            signal.removeEventListener("abort", cancelled);
+            reader?.releaseLock();
+        }
+        let body = null;
+        try {
+            body = JSON.parse(redactTransportText(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size)), transportKey));
+        }
+        catch { /* Non-JSON replies retain their HTTP status. */ }
+        return { ok: res.status === 202, status: res.status, body };
+    }
+    function schedule() {
+        if (automatic && !running) {
+            timer = setTimeout(() => { timer = null; void send(); }, intervalMs);
+            timer.unref();
+        }
+    }
+    function send() {
+        if (running)
+            return Promise.resolve(failure("beacon report is busy"));
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        running = true;
+        const control = new AbortController();
+        controller = control;
+        let finish, settled = false;
+        const result = new Promise((resolve) => { finish = resolve; });
+        const settle = (value) => { if (!settled) {
+            settled = true;
+            finish(value);
+            notify(value);
+        } };
+        const abort = () => settle(failure(control.signal.reason));
+        control.signal.addEventListener("abort", abort, { once: true });
+        const deadline = setTimeout(() => control.abort(new Error("beacon report exceeded its 10000ms deadline")), TIMEOUT_MS);
+        control.signal.addEventListener("abort", () => clearTimeout(deadline), { once: true });
+        const cleanup = () => {
+            clearTimeout(deadline);
+            control.signal.removeEventListener("abort", abort);
+            controller = null;
+            running = false;
+            schedule();
+        };
+        // Keep the slot until callbacks actually settle, even when timeout already returned a failure.
+        void report(control.signal).then((value) => { cleanup(); settle(value); }, (error) => { cleanup(); settle(failure(error)); });
+        return result;
+    }
     void send();
-    const timer = setInterval(() => void send(), intervalMs);
-    timer.unref();
-    return { send, stop: () => clearInterval(timer) };
+    return { send, stop: () => {
+            automatic = false;
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            controller?.abort(new Error("beacon reporting stopped"));
+        } };
 }

package/dist/bundle.d.ts

@@ -43,6 +43,13 @@ export interface BundleInput {
     partial?: {
         covered_by: string;
     } | null;
+    /** Section 2a (scheme 0.4): the categories assessed as simulated multi-step workflows, and the agent interface tested. */
+    assessment?: Assessment | null;
+}
+/** What a 0.4 run assessed: `voice_text` is a voice agent tested through its text interface only, never its audio. */
+export interface Assessment {
+    trajectory_categories: string[];
+    interface: "text" | "voice_text";
 }
 export interface ResultBundle {
     execution?: ApplianceExecution;
@@ -69,6 +76,7 @@ export interface ResultBundle {
     partial?: {
         covered_by: string;
     };
+    assessment?: Assessment;
 }
 export interface ApplianceExportBundle extends Omit<ResultBundle, "v" | "staff" | "execution" | "partial"> {
     v: 2;

package/dist/bundle.js

@@ -70,6 +70,7 @@ function normalizedBundle(input, source) {
     const partial = input.partial ?? null;
     if (partial !== null && (Object.keys(partial).length !== 1 || !isSha(partial.covered_by)))
         throw new Error("partial must be {covered_by: <bundle hash>}");
+    const assessment = input.assessment == null ? null : assessmentOf(input.assessment, categories, scheme);
     const execution = input.execution == null ? undefined : applianceExecution(input.execution), machine = source?.appliance ?? execution?.appliance;
     if (machine && [...testers, reviewer, decider].includes(machine))
         throw new Error("an appliance cannot be recorded as human staff");
@@ -89,6 +90,7 @@ function normalizedBundle(input, source) {
         ended_at: input.ended_at,
         ...(partial ? { partial: { covered_by: partial.covered_by } } : {}),
         ...(execution ? { execution } : {}),
+        ...(assessment ? { assessment } : {}),
     };
     if (source) {
         const { partial: ignored, ...base } = bundle;
@@ -96,6 +98,17 @@ function normalizedBundle(input, source) {
     }
     return bundle;
 }
+function assessmentOf(a, categories, scheme) {
+    if (scheme !== "zanii-certify/0.4")
+        throw new Error("assessment needs scheme zanii-certify/0.4");
+    if (typeof a !== "object" || Object.keys(a).sort().join() !== "interface,trajectory_categories" || !Array.isArray(a.trajectory_categories)
+        || (a.interface !== "text" && a.interface !== "voice_text"))
+        throw new Error("assessment must be {trajectory_categories, interface}");
+    const workflow = sortedUnique(a.trajectory_categories);
+    if (workflow.length !== a.trajectory_categories.length || !workflow.every((c) => categories.includes(c)))
+        throw new Error("assessment.trajectory_categories must be distinct planned categories");
+    return { trajectory_categories: workflow, interface: a.interface };
+}
 /** Existing v1 output is unchanged unless explicit verified appliance provenance is supplied. */
 export function buildBundle(input) { return normalizedBundle(input); }
 /** An appliance supplies execution evidence; it never occupies a human reviewer or decider role. */

package/dist/certificate.d.ts

@@ -10,7 +10,7 @@ import { type StatusDocument, type StatusEntry, type StatusWitness } from "./sta
 import { type IssuerPolicy, type ReleaseVerificationPolicy } from "./verification-policy.ts";
 import { type AuditRenewalPolicy } from "./audit-renewal.ts";
 /** scheme.md section 8: every scheme version a certificate or bundle may name. */
-export declare const SCHEMES: readonly ["zanii-certify/0.1", "zanii-certify/0.2", "zanii-certify/0.3"];
+export declare const SCHEMES: readonly ["zanii-certify/0.1", "zanii-certify/0.2", "zanii-certify/0.3", "zanii-certify/0.4"];
 export type Scheme = (typeof SCHEMES)[number];
 /** The current scheme. */
 export declare const SCHEME: Scheme;

package/dist/certificate.js

@@ -16,15 +16,16 @@ import { verifyAuditRenewal } from "./audit-renewal.js";
 import { withinVerificationBudget } from "./verification-bounds.js";
 import { signingIdentityReasons } from "./signing-identity.js";
 /** scheme.md section 8: every scheme version a certificate or bundle may name. */
-export const SCHEMES = ["zanii-certify/0.1", "zanii-certify/0.2", "zanii-certify/0.3"];
+export const SCHEMES = ["zanii-certify/0.1", "zanii-certify/0.2", "zanii-certify/0.3", "zanii-certify/0.4"];
 /** The current scheme. */
-export const SCHEME = "zanii-certify/0.3";
+export const SCHEME = "zanii-certify/0.4";
 export const LEVELS = [1, 2, 3];
 /** scheme.md section 2: the levels each scheme version issues. */
 export const SCHEME_LEVELS = {
     "zanii-certify/0.1": [1, 2],
     "zanii-certify/0.2": [1, 2, 3],
     "zanii-certify/0.3": [1, 2, 3],
+    "zanii-certify/0.4": [1, 2, 3],
 };
 /**
  * scheme.md section 8: the scheme a certificate or bundle is issued under. Given, it must issue
@@ -39,8 +40,8 @@ export function pickScheme(scheme, level, needs02 = false, needs03 = false) {
         throw new Error(`level ${level} is not issued under ${s}`);
     if (needs02 && s === "zanii-certify/0.1")
         throw new Error("a post-quantum binding needs scheme zanii-certify/0.2");
-    if (needs03 && s !== "zanii-certify/0.3")
-        throw new Error("a licence needs scheme zanii-certify/0.3");
+    if (needs03 && s !== "zanii-certify/0.3" && s !== "zanii-certify/0.4")
+        throw new Error("a licence needs scheme zanii-certify/0.3 or later");
     return s;
 }
 export const CONFLICTS = [
@@ -168,10 +169,10 @@ export function claimReasons(cert) {
         out.push("claim fingerprint or bundle is not a hash");
     if (c.level === 3 ? !isSha(c.audit) : "audit" in c)
         out.push("claim audit is an audit attestation hash, required at level 3 and only there");
-    if ("pq_binding" in c && ((scheme !== "zanii-certify/0.2" && scheme !== "zanii-certify/0.3") || !isSha(c.pq_binding)))
+    if ("pq_binding" in c && (!scheme || scheme === "zanii-certify/0.1" || !isSha(c.pq_binding)))
         out.push("claim pq_binding needs scheme zanii-certify/0.2 and a binding hash");
-    if ("licence" in c && (scheme !== "zanii-certify/0.3" || !isSha(c.licence)))
-        out.push("claim licence needs scheme zanii-certify/0.3 and a licence hash");
+    if ("licence" in c && ((scheme !== "zanii-certify/0.3" && scheme !== "zanii-certify/0.4") || !isSha(c.licence)))
+        out.push("claim licence needs scheme zanii-certify/0.3 or later and a licence hash");
     return out;
 }
 /** `verifyCredential`'s revocation check, for a list signed by another DID of the issuer document. */

package/dist/governance.d.ts

@@ -52,6 +52,8 @@ export interface RiskProfileInput {
         at: string;
         incident: boolean;
     }[];
+    /** Complete retained-history counts, when a caller aggregates rather than loading history. */
+    historyFacts?: Pick<CertifyRiskFacts, "suspensions" | "incident_suspensions" | "retests_passed" | "retests_failed" | "incident_retests">;
     overdueRetests: number;
     underCommitteeReview: boolean;
     asOf: string;

package/dist/governance.js

@@ -25,6 +25,17 @@ export function certifyRiskProfile(input) {
     if (!Number.isInteger(input.overdueRetests) || input.overdueRetests < 0)
         throw new Error("overdueRetests must be a non-negative integer");
     const count = (xs, f) => xs.filter(f).length;
+    const totals = input.historyFacts ?? {
+        suspensions: count(input.history, h => h.action === "suspend"),
+        incident_suspensions: count(input.history, h => h.action === "suspend" && h.reason === "INCIDENT"),
+        retests_passed: count(input.retests, r => r.outcome === "grant"),
+        retests_failed: count(input.retests, r => r.outcome === "refuse"),
+        incident_retests: count(input.retests, r => r.incident),
+    };
+    if (Object.keys(totals).sort().join(",") !== "incident_retests,incident_suspensions,retests_failed,retests_passed,suspensions" ||
+        !Object.values(totals).every(n => Number.isSafeInteger(n) && n >= 0) ||
+        totals.incident_suspensions > totals.suspensions || totals.incident_retests > totals.retests_passed + totals.retests_failed)
+        throw new Error("historyFacts must contain consistent non-negative safe integer counts");
     const facts = {
         certificate: credentialHash(c),
         profile: claim.profile,
@@ -40,11 +51,7 @@ export function certifyRiskProfile(input) {
         categories: b.results.length,
         categories_passed: count(b.results, (r) => r.verdict === "pass"),
         min_margin_ppm: Math.min(...b.results.map((r) => r.low_ppm - r.threshold_ppm)),
-        suspensions: count(input.history, (h) => h.action === "suspend"),
-        incident_suspensions: count(input.history, (h) => h.action === "suspend" && h.reason === "INCIDENT"),
-        retests_passed: count(input.retests, (r) => r.outcome === "grant"),
-        retests_failed: count(input.retests, (r) => r.outcome === "refuse"),
-        incident_retests: count(input.retests, (r) => r.incident),
+        ...totals,
         overdue_retests: input.overdueRetests,
         conflicts: [...claim.conflicts],
         under_committee_review: input.underCommitteeReview === true,

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { FEED_SNAPSHOT_CHUNK_ENTRIES, MAX_FEED_SNAPSHOT_BYTES, MAX_FEED_SNAPSHOT
 export { buildFeedPage, type FederatedFeed, type FeedCheck, type FeedConflict, type FeedEntry, type FeedPage, type FeedPageInput, type FeedCursor, feedCheckpoint, MAX_FEED_ENTRIES, MAX_FEED_PAGE_BYTES, type MergedRegistry, mergeFeeds, verifyFeed, verifyFeedPage, } from "./federation.ts";
 export { buildLicence, buildLicenceStatus, buildRoyaltyStatement, certificateListHash, countersignRoyaltyStatement, LICENCE_ACTIONS, LICENCE_REASONS, type Licence, type LicenceAction, type LicenceCheck, type LicenceInput, type LicenceOptions, type LicenceReason, type LicenceScope, type LicenceState, type LicenceStatus, licenceCoverage, licenceReasons, licensedKey, licenceStateAt, MAX_ROYALTY_MINOR, MAX_STATEMENT_CERTIFICATES, type RoyaltyStatement, type RoyaltyStatementBody, type RoyaltyStatementInput, verifyLicence, verifyLicenceLog, verifyRoyaltyStatement, } from "./licence.ts";
 export { type AttestedBeaconCheck, type BeaconAttestation, type BeaconCheck, type BeaconReport, beaconChallenge, buildBeacon, MAX_SKEW_SECONDS, NONCE, verifyAttestedBeacon, verifyBeacon, } from "./beacon.ts";
-export { type BundleInput, type ApplianceExecution, type ApplianceExportIdentity, type ApplianceExportBundle, type ApplianceExportBundleInput, bundleHash, buildBundle, buildApplianceExportBundle, type CategoryCount, type CategoryResult, type Evidence, type ResultBundle, } from "./bundle.ts";
+export { type BundleInput, type ApplianceExecution, type ApplianceExportIdentity, type ApplianceExportBundle, type ApplianceExportBundleInput, bundleHash, buildBundle, buildApplianceExportBundle, type CategoryCount, type CategoryResult, type Evidence, type ResultBundle, type Assessment, } from "./bundle.ts";
 export { applianceExecution, applianceExportIdentity } from "./appliance-execution.ts";
 export { type CertificateCheck, type CertificateInput, type CertificateVerifyOptions, type CertifyClaim, type PqPolicy, CONFLICTS, type Conflict, certificateScope, claimReasons, issueCertificate, LEVELS, type Level, pickScheme, SCHEME, SCHEME_LEVELS, SCHEMES, type Scheme, SURVEILLANCE, VALIDITY_DAYS, verifyCertificate, } from "./certificate.ts";
 export { buildFingerprint, checkFingerprint, type Fingerprint, type FingerprintInput, promptSha256, sha256Bytes, toolsSha256, } from "./fingerprint.ts";
@@ -28,18 +28,18 @@ export { type CategoryScore, type Overall, overallVerdict, type ProfileCategoryR
 export { activeRotation, buildRotation, type Rotation, type RotationCheck, type RotationInput, type SuiteRef, verifyRotationLog, verifyRotationRecord, } from "./rotation.ts";
 export { type Check, type CheckContext, type CheckResult, casesOf, DEFAULT_FINDINGS, type Delegation, type DelegationLink, effectiveDelegation, judgementResult, normaliseText, type Rubric, runCheck, type Scenario, type ScenarioLibrary, scenarioCases, scenariosSchema, type Suite, type SubAgent, type SuiteCase, suiteSchema, type ToolCall, suiteSnapshot, validateScenarios, validateSuite, verifyCaseDelegation, } from "./suite.ts";
 export { keySigner, type Signer, signerDid, signWith } from "./signer.ts";
-export { applyStatus, buildStatus, type CertificateStatus, REASONS, REASONS_V2, STATUS_V2_SCHEMA, STATUS_V2_MAX_ENTRIES, type StatusVersion, type Reason, revocationListFromStatus, type StatusAction, type StatusCheck, type StatusDocument, type StatusEntries, type StatusEntry, type StatusVerifyOptions, type StatusWitness, verifyStatus, } from "./status.ts";
+export { applyStatus, buildStatus, type CertificateStatus, REASONS, REASONS_V2, STATUS_V2_SCHEMA, STATUS_V2_MAX_ENTRIES, type StatusVersion, type Reason, revocationListFromStatus, type StatusAction, type StatusCheck, type StatusDocument, type StatusEntries, type StatusEntry, type StatusVerifyOptions, type StatusWitness, verifyStatus, logPositionOk, } from "./status.ts";
 export { type CertificateVcCheck, certificateToVc, VC_STATUS_TYPE, VC_TYPE, verifyCertificateVc, } from "./vc.ts";
 export { statusCheckpoint, statusConsistencyProof, statusInclusionProof, verifyStatusLog, } from "./witness.ts";
 export { type AccreditationExport, buildAccreditationExport, buildFilingPack, buildGovernanceOutcome, buildSigningKeyApproval, CASE_KINDS, type CaseKind, type CertifyRiskFacts, type CertifyRiskProfile, certifyRiskProfile, type FilingPack, type FilingPackInput, type GovernanceCheck, type GovernanceOutcome, type GovernanceOutcomeInput, governanceOutcomeBody, OUTCOMES, RISK_NOTE, type RiskProfileInput, type SignedRiskProfile, type SigningKeyApproval, type SigningKeyApprovalInput, signingKeyApprovalBody, signRiskProfile, verifyRiskProfile, verifyAccreditationExport, verifyFilingPack, verifyGovernanceOutcome, verifySigningKeyApproval, } from "./governance.ts";
 export { AWS_NITRO_ROOT_PEM, AWS_NITRO_ROOT_SHA256, AWS_NITRO_GOV_ROOT_PEM, AWS_NITRO_GOV_ROOT_SHA256, checkNitroAttestation, NITRO_MAX_AGE_SECONDS, NITRO_MAX_SKEW_SECONDS, type NitroCheck, type NitroDocument, type NitroOptions, type NitroPartition, type NitroQuoteOptions, nitroMeasurement, nitroQuoteVerifier, nitroRootForPartition, parseNitroDocument, sigStructure, verifyNitroDocument } from "./nitro.ts";
 export { canonicalBytes, jcsHash } from "@zanii/core";
 export { buildRuntimeRelease, buildRuntimePolicy, buildRuntimeApproval, buildRuntimeProof, buildRuntimeChallengeRequest, buildRuntimeLease, buildRuntimeAction, buildRuntimeLeaseRequest, buildRuntimeMandate, verifyRuntimeRelease, verifyRuntimePolicy, verifyRuntimeApproval, verifyRuntimeProof, verifyRuntimeChallengeRequest, verifyRuntimeLease, verifyRuntimeAction, verifyRuntimeLeaseRequest, verifyRuntimeMandate, runtimeReleaseHash, runtimePolicyHash, runtimeRequestHash, type RuntimeRelease, type RuntimePolicy, type RuntimeApproval, type RuntimeProof, type RuntimeChallengeRequest, type RuntimeLease, type RuntimeAction, type RuntimeLeaseRequest, type RuntimeMandate, type RuntimeCheck, type RuntimeTrustOptions, type RuntimeReleaseOptions, type RuntimeApprovalOptions, type RuntimeProofOptions, type RuntimeChallengeOptions, type RuntimeLeaseOptions, type RuntimeActionOptions, type RuntimeLeaseRequestOptions, type RuntimeMandateOptions, } from "./runtime.ts";
-export { runtimeNitroBindingHash, verifyRuntimeNitroDocument, type RuntimeNitroBinding, type RuntimeNitroOptions, type RuntimeNitroCheck } from "./runtime-nitro.ts";
+export { runtimeNitroBindingHash, verifyRuntimeNitroDocument, RUNTIME_NITRO_MAX_BYTES, RUNTIME_NITRO_MAX_SKEW_SECONDS, type RuntimeNitroBinding, type RuntimeNitroOptions, type RuntimeNitroCheck } from "./runtime-nitro.ts";
 export { createRuntimeGateway, type RuntimeGatewayOptions } from "./runtime-gateway.ts";
 export { createRuntimeReporter, type RuntimeReporterOptions, type RuntimeAttestationBinding, type RuntimeReportResult } from "./runtime-client.ts";
 export { buildRuntimeKnowledgeSnapshot, runtimeKnowledgeProof, runtimeKnowledgeProofs, verifyRuntimeKnowledgeChunk, type RuntimeKnowledgeMetadata, type RuntimeKnowledgeSnapshot, type RuntimeKnowledgeProof, type RuntimeKnowledgeOptions, } from "./runtime-knowledge.ts";
-export { resolveIssuerDetailed, fetchJsonBounded, type IssuerResolution, type IssuerResolutionCode, type ResolutionOptions, type ResolutionFailure } from "./issuer-resolution.ts";
+export { resolveIssuerDetailed, fetchJsonBounded, type JsonFetchResult, type IssuerResolution, type IssuerResolutionCode, type ResolutionOptions, type ResolutionFailure } from "./issuer-resolution.ts";
 export { isIssuerPolicy, issuerPolicyCheck, releasePolicyReasons, type IssuerPolicy, type ReleaseVerificationPolicy } from "./verification-policy.ts";
 export { buildSandboxDelegationPolicy, verifySandboxDelegationPolicy, type SandboxDelegationPolicy, type SandboxDelegationContext } from "./sandbox-delegation.ts";
 export { teamReceiptTask, type TeamReceiptPolicy } from "./suite.ts";
@@ -56,3 +56,6 @@ export { signingIdentityReasons } from "./signing-identity.ts";
 export { normalizationPolicyReasons, runtimeNormalizationVersion, type NormalizationPolicy } from "./normalization.ts";
 export { schemaDialectErrors } from "./schema-dialect.ts";
 export { type Credential, credentialHash, type RevocationList } from "@zanii/credentials";
+export { TRANSCRIPT_TURNS_BYTES, transcriptTurnsHash, validateTranscriptProvenance, type TranscriptProvenance } from "./transcript-provenance.ts";
+export { validateSuiteDocument, type SuiteDocument } from "./suite.ts";
+export { TRAJECTORY_LIMITS, trajectorySchema, isTrajectoryCase, validateTrajectorySuite, validateTrajectoryTrace, validateTrajectoryArguments, parseTrajectoryArguments, trajectoryTools, resolveTrajectoryRef, trajectoryConditions, trajectoryStateHash, trajectoryCaseHash, trajectorySuiteHash, checkTrajectory, type TrajectoryScalar, type TrajectoryState, type TrajectoryRef, type TrajectoryCondition, type TrajectoryEffect, type TrajectoryArgument, type TrajectoryRule, type TrajectoryTool, type TrajectoryBudget, type TrajectoryCase, type TrajectorySuite, type TrajectoryCall, type TrajectoryEvent, type TrajectoryTrace, type TrajectoryCheck } from "./trajectory.ts";

package/dist/index.js

@@ -29,14 +29,14 @@ export { overallVerdict, scoreCategory, } from "./scoring.js";
 export { activeRotation, buildRotation, verifyRotationLog, verifyRotationRecord, } from "./rotation.js";
 export { casesOf, DEFAULT_FINDINGS, effectiveDelegation, judgementResult, normaliseText, runCheck, scenarioCases, scenariosSchema, suiteSchema, suiteSnapshot, validateScenarios, validateSuite, verifyCaseDelegation, } from "./suite.js";
 export { keySigner, signerDid, signWith } from "./signer.js";
-export { applyStatus, buildStatus, REASONS, REASONS_V2, STATUS_V2_SCHEMA, STATUS_V2_MAX_ENTRIES, revocationListFromStatus, verifyStatus, } from "./status.js";
+export { applyStatus, buildStatus, REASONS, REASONS_V2, STATUS_V2_SCHEMA, STATUS_V2_MAX_ENTRIES, revocationListFromStatus, verifyStatus, logPositionOk, } from "./status.js";
 export { certificateToVc, VC_STATUS_TYPE, VC_TYPE, verifyCertificateVc, } from "./vc.js";
 export { statusCheckpoint, statusConsistencyProof, statusInclusionProof, verifyStatusLog, } from "./witness.js";
 export { buildAccreditationExport, buildFilingPack, buildGovernanceOutcome, buildSigningKeyApproval, CASE_KINDS, certifyRiskProfile, governanceOutcomeBody, OUTCOMES, RISK_NOTE, signingKeyApprovalBody, signRiskProfile, verifyRiskProfile, verifyAccreditationExport, verifyFilingPack, verifyGovernanceOutcome, verifySigningKeyApproval, } from "./governance.js";
 export { AWS_NITRO_ROOT_PEM, AWS_NITRO_ROOT_SHA256, AWS_NITRO_GOV_ROOT_PEM, AWS_NITRO_GOV_ROOT_SHA256, checkNitroAttestation, NITRO_MAX_AGE_SECONDS, NITRO_MAX_SKEW_SECONDS, nitroMeasurement, nitroQuoteVerifier, nitroRootForPartition, parseNitroDocument, sigStructure, verifyNitroDocument } from "./nitro.js";
 export { canonicalBytes, jcsHash } from "@zanii/core";
 export { buildRuntimeRelease, buildRuntimePolicy, buildRuntimeApproval, buildRuntimeProof, buildRuntimeChallengeRequest, buildRuntimeLease, buildRuntimeAction, buildRuntimeLeaseRequest, buildRuntimeMandate, verifyRuntimeRelease, verifyRuntimePolicy, verifyRuntimeApproval, verifyRuntimeProof, verifyRuntimeChallengeRequest, verifyRuntimeLease, verifyRuntimeAction, verifyRuntimeLeaseRequest, verifyRuntimeMandate, runtimeReleaseHash, runtimePolicyHash, runtimeRequestHash, } from "./runtime.js";
-export { runtimeNitroBindingHash, verifyRuntimeNitroDocument } from "./runtime-nitro.js";
+export { runtimeNitroBindingHash, verifyRuntimeNitroDocument, RUNTIME_NITRO_MAX_BYTES, RUNTIME_NITRO_MAX_SKEW_SECONDS } from "./runtime-nitro.js";
 export { createRuntimeGateway } from "./runtime-gateway.js";
 export { createRuntimeReporter } from "./runtime-client.js";
 export { buildRuntimeKnowledgeSnapshot, runtimeKnowledgeProof, runtimeKnowledgeProofs, verifyRuntimeKnowledgeChunk, } from "./runtime-knowledge.js";
@@ -57,3 +57,7 @@ export { signingIdentityReasons } from "./signing-identity.js";
 export { normalizationPolicyReasons, runtimeNormalizationVersion } from "./normalization.js";
 export { schemaDialectErrors } from "./schema-dialect.js";
 export { credentialHash } from "@zanii/credentials";
+// Draft public-practice trajectory extension; existing v1 formats/certification scope are unchanged.
+export { TRANSCRIPT_TURNS_BYTES, transcriptTurnsHash, validateTranscriptProvenance } from "./transcript-provenance.js";
+export { validateSuiteDocument } from "./suite.js";
+export { TRAJECTORY_LIMITS, trajectorySchema, isTrajectoryCase, validateTrajectorySuite, validateTrajectoryTrace, validateTrajectoryArguments, parseTrajectoryArguments, trajectoryTools, resolveTrajectoryRef, trajectoryConditions, trajectoryStateHash, trajectoryCaseHash, trajectorySuiteHash, checkTrajectory } from "./trajectory.js";

package/dist/profile.d.ts

@@ -9,11 +9,6 @@ export interface ProfileCheck {
     ok: boolean;
     errors: string[];
 }
-/**
- * Section 2: a profile is valid when it matches the schema, its category ids are distinct, every
- * category's required levels are levels the profile offers, and (when `clauseMaps` are given)
- * every clause it cites exists in a clause map the profile lists.
- */
 export declare function validateProfile(profile: unknown, clauseMaps?: readonly unknown[]): ProfileCheck;
 /** Section 3: a clause map is valid when it matches the schema and its clause ids are distinct. */
 export declare function validateClauseMap(map: unknown): ProfileCheck;

package/dist/profile.js

@@ -116,6 +116,8 @@ export function schemaErrors(value, schema) {
  * category's required levels are levels the profile offers, and (when `clauseMaps` are given)
  * every clause it cites exists in a clause map the profile lists.
  */
+/** scheme.md section 2a: the scheme versions whose profiles may assess categories as multi-step workflows. */
+const TRAJECTORY_SCHEMES = ["zanii-certify/0.4"];
 export function validateProfile(profile, clauseMaps = []) {
     const errors = schemaErrors(profile, profileSchema);
     if (!errors.length) {
@@ -127,6 +129,8 @@ export function validateProfile(profile, clauseMaps = []) {
             if (seen.has(c.id))
                 errors.push(`$.categories: duplicate id ${c.id}`);
             seen.add(c.id);
+            if (c.execution === "trajectory" && !TRAJECTORY_SCHEMES.includes(p.scheme))
+                errors.push(`$.categories.${c.id}: trajectory execution needs scheme zanii-certify/0.4`);
             for (const l of c.required_levels)
                 if (!p.levels.includes(l))
                     errors.push(`$.categories.${c.id}: level ${l} not in levels`);

package/dist/runtime-client.d.ts

@@ -18,6 +18,8 @@ export interface RuntimeReporterOptions {
     signer: Signer;
     attest: (binding: RuntimeAttestationBinding) => Promise<Uint8Array>;
     fetch?: typeof fetch;
+    /** Optional agent-bound admission credential, separate from workload proof. */
+    transportKey?: string;
     clock?: () => number;
     intervalMs?: number;
     onResult?: (result: RuntimeReportResult | {

package/dist/runtime-client.js

@@ -6,6 +6,7 @@ import { RUNTIME_NITRO_MAX_BYTES, runtimeNitroBindingHash } from "./runtime-nitr
 import { buildRuntimeChallengeRequest, buildRuntimeProof, runtimePolicyHash, verifyRuntimeApproval } from "./runtime.js";
 import { isDid, isIso, isObj } from "./shared.js";
 import { signerDid } from "./signer.js";
+import { machineTransportHeaders, redactTransportText } from "./transport-key.js";
 const DEADLINE_MS = 10_000, MAX_RESPONSE_BYTES = 32 * 1024;
 const SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 /** One reporter has at most one underlying operation, including an uncancellable attester after timeout. */
@@ -21,6 +22,7 @@ export function createRuntimeReporter(options) {
     if (typeof authority !== "string" || authority.length > 2048 || !/^[\x21-\x7e]+$/.test(authority) || url.protocol !== "https:"
         || authority !== url.origin || url.username || url.password)
         throw new Error("runtime authority must be a canonical HTTPS origin");
+    const transportKey = options.transportKey, transportHeaders = machineTransportHeaders(url, transportKey);
     if (!Array.isArray(options.issuers) || !options.issuers.length || options.issuers.length > 100 || !options.issuers.every(isDid))
         throw new Error("explicit runtime issuer DIDs are required");
     const issuers = [...options.issuers], clock = options.clock ?? Date.now, call = options.fetch ?? fetch, attest = options.attest;
@@ -49,7 +51,7 @@ export function createRuntimeReporter(options) {
     async function post(path, body, signal) {
         abortCheck(signal);
         const response = await call(`${authority}/v1/runtime/deployments/${deployment}/${path}`, { method: "POST", redirect: "error",
-            credentials: "omit", headers: { "content-type": "application/json", accept: "application/json" }, body: JSON.stringify(body), signal });
+            credentials: "omit", headers: { "content-type": "application/json", accept: "application/json", ...transportHeaders }, body: JSON.stringify(body), signal });
         abortCheck(signal);
         if (response.redirected || (response.url && new URL(response.url).origin !== authority))
             throw new Error("runtime authority redirected the request");
@@ -144,11 +146,14 @@ export function createRuntimeReporter(options) {
             }
             catch { /* Observers cannot break reporting or create retry queues. */ }
         };
-        const fail = (error) => { if (!settled) {
-            settled = true;
-            reject(error);
-            notify({ accepted: false, error: error instanceof Error ? error : new Error("runtime report failed") });
-        } };
+        const fail = (error) => {
+            if (!settled) {
+                settled = true;
+                const safe = new Error(redactTransportText(error instanceof Error ? error.message : "runtime report failed", transportKey));
+                reject(safe);
+                notify({ accepted: false, error: safe });
+            }
+        };
         const abort = () => fail(control.signal.reason);
         control.signal.addEventListener("abort", abort, { once: true });
         const deadline = setTimeout(() => control.abort(new Error("runtime report exceeded its 10000ms deadline")), DEADLINE_MS);

package/dist/runtime-gateway.d.ts

@@ -14,6 +14,8 @@ export interface RuntimeGatewayOptions {
     timeoutMs?: number;
     clock?: () => number;
     fetch?: typeof fetch;
+    /** Admission credential sent only to the authority, never to a protected target. */
+    transportKey?: string;
 }
 export declare function createRuntimeGateway(options: RuntimeGatewayOptions): {
     handle: (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/dist/runtime-gateway.js

@@ -6,6 +6,7 @@ import { isDid, isIso, isObj } from "./shared.js";
 import { signatureOk } from "./signer.js";
 import { sha256Bytes } from "./fingerprint.js";
 import { verifyRuntimeKnowledgeChunk } from "./runtime-knowledge.js";
+import { machineTransportHeaders } from "./transport-key.js";
 class GatewayError extends Error {
     status;
     constructor(status, message) { super(message); this.status = status; }
@@ -26,6 +27,7 @@ export function createRuntimeGateway(options) {
     const authority = new URL(options.authority);
     if (authority.protocol !== "https:" || ![authority.origin, `${authority.origin}/`].includes(options.authority))
         throw new Error("authority must be a canonical HTTPS origin");
+    const transportHeaders = machineTransportHeaders(authority, options.transportKey);
     if (!options.issuers.length || options.issuers.length > 16 || options.issuers.some((did) => !isDid(did) || !publicKeyFromDid(did)))
         throw new Error("explicit trusted issuer DIDs are required");
     const issuers = [...options.issuers];
@@ -122,7 +124,7 @@ export function createRuntimeGateway(options) {
                 throw new GatewayError(403, "operation does not match its single-use runtime authority");
             // No protected effect starts before the live authority service atomically consumes the grant.
             const authorization = await call(new URL("/v1/runtime/consume", authority), { method: "POST", redirect: "error",
-                headers: { "content-type": "application/json" }, body: JSON.stringify({ lease, action }), signal: AbortSignal.timeout(timeout) });
+                credentials: "omit", headers: { "content-type": "application/json", ...transportHeaders }, body: JSON.stringify({ lease, action }), signal: AbortSignal.timeout(timeout) });
             const authorizationBytes = await bounded(authorization.body, 16384);
             if (!authorization.ok)
                 throw new GatewayError(403, "live runtime authority refused the operation");

package/dist/schemas/profile.schema.json

@@ -10,7 +10,7 @@
         "type": { "const": "certify.profile" },
         "slug": { "$ref": "#/$defs/slug" },
         "version": { "type": "integer", "minimum": 1 },
-        "scheme": { "enum": ["zanii-certify/0.1", "zanii-certify/0.2", "zanii-certify/0.3"] },
+        "scheme": { "enum": ["zanii-certify/0.1", "zanii-certify/0.2", "zanii-certify/0.3", "zanii-certify/0.4"] },
         "title": { "$ref": "#/$defs/text" },
         "description": { "$ref": "#/$defs/text" },
         "levels": {
@@ -69,6 +69,7 @@
                 "min_trials": { "type": "integer", "minimum": 1, "maximum": 1000000 },
                 "threshold_ppm": { "type": "integer", "minimum": 0, "maximum": 1000000 },
                 "ci_rule": { "const": "wilson95-low" },
+                "execution": { "enum": ["single_turn", "trajectory"] },
                 "clauses": {
                     "type": "array",
                     "uniqueItems": true,