@oxdeai/conformance 1.3.1 → 2.0.0

package/dist/src/fixtures/conformance-engine-secret.fixture.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fixed engine secret used to generate and validate conformance vectors.
+ * This is a test-only constant — never use in production.
+ */
+export declare const CONFORMANCE_ENGINE_SECRET = "test-secret-must-be-at-least-32-chars!!";

package/dist/src/fixtures/conformance-engine-secret.fixture.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Fixed engine secret used to generate and validate conformance vectors.
+ * This is a test-only constant — never use in production.
+ */
+export const CONFORMANCE_ENGINE_SECRET = "test-secret-must-be-at-least-32-chars!!";
+//# sourceMappingURL=conformance-engine-secret.fixture.js.map

package/dist/src/fixtures/conformance-engine-secret.fixture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance-engine-secret.fixture.js","sourceRoot":"","sources":["../../../src/fixtures/conformance-engine-secret.fixture.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,yCAAyC,CAAC"}

package/dist/src/fixtures/ed25519.test-only.fixture.d.ts

@@ -1,5 +1,5 @@
 /**
- * TEST ONLY — DO NOT USE IN PRODUCTION.
+ * TEST ONLY - DO NOT USE IN PRODUCTION.
  *
  * Deterministic Ed25519 fixture for conformance vectors/validation.
  * This keypair is intentionally public test material and not a deployable secret.

package/dist/src/fixtures/ed25519.test-only.fixture.js

@@ -1,5 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
 /**
- * TEST ONLY — DO NOT USE IN PRODUCTION.
+ * TEST ONLY - DO NOT USE IN PRODUCTION.
  *
  * Deterministic Ed25519 fixture for conformance vectors/validation.
  * This keypair is intentionally public test material and not a deployable secret.

package/dist/src/fixtures/ed25519.test-only.fixture.js.map

@@ -1 +1 @@
-{"version":3,"file":"ed25519.test-only.fixture.js","sourceRoot":"","sources":["../../../src/fixtures/ed25519.test-only.fixture.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,0DAA0D,GAAG;;0BAEhD,CAAC;AAE3B,MAAM,CAAC,MAAM,yDAAyD,GAAG;;yBAEhD,CAAC"}
+{"version":3,"file":"ed25519.test-only.fixture.js","sourceRoot":"","sources":["../../../src/fixtures/ed25519.test-only.fixture.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,0DAA0D,GAAG;;0BAEhD,CAAC;AAE3B,MAAM,CAAC,MAAM,yDAAyD,GAAG;;yBAEhD,CAAC"}

package/dist/src/fixtures/krl-ed25519.test-only.fixture.d.ts

@@ -0,0 +1,13 @@
+/**
+ * KRL SIGNING KEY — TEST ONLY — DO NOT USE IN PRODUCTION.
+ *
+ * Distinct Ed25519 fixture for SignedKRLV1 conformance vectors.
+ * Intentionally separate from the AuthorizationV1 / DelegationV1 signing key
+ * fixture (ed25519.test-only.fixture.ts) to exercise the trust-domain
+ * separation between KRL signing keys and authorization signing keys.
+ *
+ * kid: "krl-2026-01"
+ * issuer (in conformance vectors): "krl.issuer"
+ */
+export declare const KRL_TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION = "-----BEGIN PRIVATE KEY-----\nMC4CAQAwBQYDK2VwBCIEIKPuSm5iCBRfVLXFwMLVWzdRDAI882fQ1XeZqwvBDayT\n-----END PRIVATE KEY-----";
+export declare const KRL_TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAoNLRsm0uJ8Zb4z9BErD/xcPyN8kK1Y3zTrpdxDGiT2A=\n-----END PUBLIC KEY-----";

package/dist/src/fixtures/krl-ed25519.test-only.fixture.js

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * KRL SIGNING KEY — TEST ONLY — DO NOT USE IN PRODUCTION.
+ *
+ * Distinct Ed25519 fixture for SignedKRLV1 conformance vectors.
+ * Intentionally separate from the AuthorizationV1 / DelegationV1 signing key
+ * fixture (ed25519.test-only.fixture.ts) to exercise the trust-domain
+ * separation between KRL signing keys and authorization signing keys.
+ *
+ * kid: "krl-2026-01"
+ * issuer (in conformance vectors): "krl.issuer"
+ */
+export const KRL_TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION = `-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEIKPuSm5iCBRfVLXFwMLVWzdRDAI882fQ1XeZqwvBDayT
+-----END PRIVATE KEY-----`;
+export const KRL_TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAoNLRsm0uJ8Zb4z9BErD/xcPyN8kK1Y3zTrpdxDGiT2A=
+-----END PUBLIC KEY-----`;
+//# sourceMappingURL=krl-ed25519.test-only.fixture.js.map

package/dist/src/fixtures/krl-ed25519.test-only.fixture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"krl-ed25519.test-only.fixture.js","sourceRoot":"","sources":["../../../src/fixtures/krl-ed25519.test-only.fixture.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,8DAA8D,GAAG;;0BAEpD,CAAC;AAE3B,MAAM,CAAC,MAAM,6DAA6D,GAAG;;yBAEpD,CAAC"}

package/dist/src/trustedTimeConformance.d.ts

@@ -0,0 +1,32 @@
+import { evidenceScope } from "./evidenceScope.mjs";
+export declare const TRUSTED_TIME_SCHEMA_VERSION = "1.0.0";
+export declare const TRUSTED_TIME_CATEGORIES: readonly ["intent_freshness", "authorization_issuance", "replay", "velocity", "authorization_verification", "determinism", "malformed_configuration", "protocol_seconds_validation", "tool_window"];
+type Category = (typeof TRUSTED_TIME_CATEGORIES)[number];
+type RecordValue = Record<string, unknown>;
+export type TrustedTimeVector = {
+    id: string;
+    category: Category;
+    status: "active" | "pending";
+    description: string;
+    blocked_by?: string;
+    comparison_group?: string;
+    input: RecordValue;
+    expected: RecordValue;
+};
+export type TrustedTimeFile = {
+    schema_version: string;
+    description: string;
+    vectors: TrustedTimeVector[];
+};
+export type TrustedTimeSummary = {
+    active: number;
+    passed: number;
+    failed: number;
+    pending: number;
+    failures: string[];
+    evidenceScope: ReturnType<typeof evidenceScope>;
+};
+export declare function parseTrustedTimeFile(raw: unknown): TrustedTimeFile;
+export declare function runTrustedTimeConformance(raw: unknown, log?: (line: string) => void): TrustedTimeSummary;
+export declare function trustedTimeExitCode(summary: TrustedTimeSummary): 0 | 1;
+export {};

package/dist/src/trustedTimeConformance.js

@@ -0,0 +1,484 @@
+// SPDX-License-Identifier: Apache-2.0
+import { evidenceScope } from "./evidenceScope.mjs";
+import { PolicyEngine, signAuthorizationEd25519, verifyAuthorization, verifyTrustedTime, } from "@oxdeai/core";
+import { TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION, TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION, } from "./fixtures/ed25519.test-only.fixture.js";
+import { CONFORMANCE_ENGINE_SECRET } from "./fixtures/conformance-engine-secret.fixture.js";
+export const TRUSTED_TIME_SCHEMA_VERSION = "1.0.0";
+export const TRUSTED_TIME_CATEGORIES = [
+    "intent_freshness", "authorization_issuance", "replay", "velocity",
+    "authorization_verification", "determinism", "malformed_configuration",
+    "protocol_seconds_validation", "tool_window",
+];
+const CATEGORY_SET = new Set(TRUSTED_TIME_CATEGORIES);
+// The package root currently exposes ReasonCode as a public type rather than a
+// runtime value. `satisfies` keeps this registry compile-time checked against
+// that public union while providing strict runtime validation for vector data.
+const PUBLIC_REASON_CODES = [
+    "KILL_SWITCH", "ALLOWLIST_ACTION", "ALLOWLIST_ASSET", "ALLOWLIST_TARGET",
+    "POLICY_VERSION_MISMATCH", "STATE_INVALID", "INTENT_AMOUNT_INVALID", "BUDGET_EXCEEDED",
+    "PER_ACTION_CAP_EXCEEDED", "VELOCITY_EXCEEDED", "CONCURRENCY_LIMIT_EXCEEDED",
+    "RECURSION_DEPTH_EXCEEDED", "REPLAY_NONCE", "REPLAY_DETECTED", "AUTH_EXPIRED",
+    "AUTH_SIGNATURE_INVALID", "AUTH_INTENT_MISMATCH", "INTERNAL_ERROR",
+    "CONCURRENCY_RELEASE_INVALID", "TOOL_CALL_LIMIT_EXCEEDED",
+    "INTENT_FRESHNESS_FUTURE", "INTENT_STALE",
+];
+const ALL_PUBLIC_REASON_CODES_COVERED = true;
+void ALL_PUBLIC_REASON_CODES_COVERED;
+const REASON_CODES = new Set(PUBLIC_REASON_CODES);
+const VERIFICATION_CODES = new Set(["AUTH_EXPIRED", "AUTH_ISSUED_AT_IMPLAUSIBLE"]);
+const COMMON_KEYS = new Set(["id", "category", "status", "description", "blocked_by", "comparison_group", "input", "expected"]);
+const INPUT_KEYS = {
+    intent_freshness: new Set(["intent_timestamp", "evaluation_time", "max_clock_skew_seconds", "max_intent_age_seconds"]),
+    authorization_issuance: new Set(["intent_timestamp", "evaluation_time", "effective_ttl", "authorization_action"]),
+    replay: new Set(["replay_window_seconds", "max_nonces_per_agent", "initial_nonce_state", "steps"]),
+    velocity: new Set(["window_seconds", "max_actions", "initial_velocity", "steps"]),
+    authorization_verification: new Set(["authorization_issued_at", "authorization_expiry", "verifier_time", "max_future_issued_at_skew_seconds"]),
+    determinism: new Set(["kind", "repeat", "intent_timestamp", "evaluation_time", "effective_ttl", "window_seconds", "max_actions", "initial_velocity", "steps"]),
+    malformed_configuration: new Set(["configuration_field", "configuration_value"]),
+    protocol_seconds_validation: new Set(["case", "intent_timestamp", "evaluation_time", "effective_ttl"]),
+    tool_window: new Set(["window_seconds", "max_calls", "max_calls_by_tool", "initial_tool_calls", "steps"]),
+};
+const EXPECTED_KEYS = {
+    intent_freshness: new Set(["decision", "reasons"]),
+    authorization_issuance: new Set(["decision", "reasons", "authorization_issued_at", "authorization_expiry"]),
+    replay: new Set(["steps"]),
+    velocity: new Set(["steps"]),
+    authorization_verification: new Set(["status", "violation_codes"]),
+    determinism: new Set(["decision", "reasons", "authorization_issued_at", "authorization_expiry", "identical_output"]),
+    malformed_configuration: new Set(["throws", "error_includes"]),
+    protocol_seconds_validation: new Set(["decision", "reasons", "throws", "error_includes"]),
+    tool_window: new Set(["steps"]),
+};
+function object(value, where) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error(`${where}: expected object`);
+    return value;
+}
+function exactKeys(value, allowed, where) {
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            throw new Error(`${where}: unknown field ${key}`);
+}
+function text(value, where) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`${where}: expected non-empty string`);
+    return value;
+}
+function array(value, where) {
+    if (!Array.isArray(value))
+        throw new Error(`${where}: expected array`);
+    return value;
+}
+function safeSeconds(value, where, positive = false) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (positive ? 1 : 0)) {
+        throw new Error(`${where}: expected ${positive ? "positive" : "non-negative"} safe-integer protocol seconds`);
+    }
+    return value;
+}
+function nonNegativeCount(value, where) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+        throw new Error(`${where}: expected non-negative safe integer`);
+    return value;
+}
+function validateReasons(value, id, where) {
+    for (const [index, reason] of array(value, `${id} ${where}`).entries()) {
+        if (typeof reason !== "string" || !REASON_CODES.has(reason))
+            throw new Error(`${id} ${where}[${index}]: unsupported ReasonCode ${String(reason)}`);
+    }
+}
+function validateDecisionExpected(expected, id) {
+    if (expected.decision !== "ALLOW" && expected.decision !== "DENY")
+        throw new Error(`${id} expected.decision: expected ALLOW or DENY`);
+    validateReasons(expected.reasons, id, "expected.reasons");
+    if (expected.decision === "ALLOW" && expected.reasons.length !== 0)
+        throw new Error(`${id} expected.reasons: ALLOW must have no reasons`);
+}
+function validateNonceState(value, id, where) {
+    for (const [i, raw] of array(value, `${id} ${where}`).entries()) {
+        const item = object(raw, `${id} ${where}[${i}]`);
+        exactKeys(item, new Set(["nonce", "nonce_first_seen_time"]), `${id} ${where}[${i}]`);
+        text(item.nonce, `${id} ${where}[${i}].nonce`);
+        safeSeconds(item.nonce_first_seen_time, `${id} ${where}[${i}].nonce_first_seen_time`);
+    }
+}
+function validateToolCalls(value, id, where) {
+    for (const [i, raw] of array(value, `${id} ${where}`).entries()) {
+        const item = object(raw, `${id} ${where}[${i}]`);
+        exactKeys(item, new Set(["tool_call_time", "tool"]), `${id} ${where}[${i}]`);
+        if (typeof item.tool_call_time !== "number" || !Number.isSafeInteger(item.tool_call_time)) {
+            throw new Error(`${id} ${where}[${i}].tool_call_time: expected safe integer`);
+        }
+        text(item.tool, `${id} ${where}[${i}].tool`);
+    }
+}
+function validateSteps(vector) {
+    const steps = array(vector.input.steps, `${vector.id} input.steps`);
+    if (steps.length === 0)
+        throw new Error(`${vector.id} input.steps: must not be empty`);
+    for (const [i, raw] of steps.entries()) {
+        const step = object(raw, `${vector.id} input.steps[${i}]`);
+        exactKeys(step, new Set(["intent_timestamp", "evaluation_time", "nonce"]), `${vector.id} input.steps[${i}]`);
+        safeSeconds(step.intent_timestamp, `${vector.id} input.steps[${i}].intent_timestamp`);
+        safeSeconds(step.evaluation_time, `${vector.id} input.steps[${i}].evaluation_time`);
+        text(step.nonce, `${vector.id} input.steps[${i}].nonce`);
+    }
+    if (vector.category === "determinism")
+        return;
+    const expectedSteps = array(vector.expected.steps, `${vector.id} expected.steps`);
+    if (expectedSteps.length !== steps.length)
+        throw new Error(`${vector.id} expected.steps: expected ${steps.length} entries`);
+    for (const [i, raw] of expectedSteps.entries()) {
+        const step = object(raw, `${vector.id} expected.steps[${i}]`);
+        const allowed = vector.category === "replay"
+            ? new Set(["decision", "reasons", "nonce_state"])
+            : vector.category === "tool_window"
+                ? new Set(["decision", "reasons", "tool_calls"])
+                : new Set(["decision", "reasons", "velocity_window_start", "velocity_count"]);
+        exactKeys(step, allowed, `${vector.id} expected.steps[${i}]`);
+        validateDecisionExpected(step, `${vector.id} step ${i + 1}`);
+        if (vector.category === "replay")
+            validateNonceState(step.nonce_state, vector.id, `expected.steps[${i}].nonce_state`);
+        else if (vector.category === "tool_window")
+            validateToolCalls(step.tool_calls, vector.id, `expected.steps[${i}].tool_calls`);
+        else {
+            // Negative starts are permitted only as an expected preservation value for the malformed-state vector.
+            if (typeof step.velocity_window_start !== "number" || !Number.isSafeInteger(step.velocity_window_start))
+                throw new Error(`${vector.id} expected.steps[${i}].velocity_window_start: expected safe integer`);
+            nonNegativeCount(step.velocity_count, `${vector.id} expected.steps[${i}].velocity_count`);
+        }
+    }
+}
+export function parseTrustedTimeFile(raw) {
+    const file = object(raw, "trusted-time");
+    exactKeys(file, new Set(["schema_version", "description", "vectors"]), "trusted-time");
+    if (file.schema_version !== TRUSTED_TIME_SCHEMA_VERSION)
+        throw new Error(`trusted-time schema_version: expected ${TRUSTED_TIME_SCHEMA_VERSION}`);
+    text(file.description, "trusted-time description");
+    const seen = new Set();
+    const vectors = array(file.vectors, "trusted-time vectors");
+    for (const rawVector of vectors) {
+        const vector = object(rawVector, "trusted-time vector");
+        exactKeys(vector, COMMON_KEYS, `trusted-time vector ${String(vector.id ?? "(missing)")}`);
+        const id = text(vector.id, "trusted-time vector id");
+        if (seen.has(id))
+            throw new Error(`${id}: duplicate vector ID`);
+        seen.add(id);
+        if (!CATEGORY_SET.has(String(vector.category)))
+            throw new Error(`${id}: unknown category ${String(vector.category)}`);
+        if (vector.status !== "active" && vector.status !== "pending")
+            throw new Error(`${id}: malformed status ${String(vector.status)}`);
+        text(vector.description, `${id} description`);
+        if (vector.status === "pending")
+            text(vector.blocked_by, `${id} blocked_by`);
+        else if (vector.blocked_by !== undefined)
+            throw new Error(`${id}: active vector must not define blocked_by`);
+        if (vector.comparison_group !== undefined)
+            text(vector.comparison_group, `${id} comparison_group`);
+        const input = object(vector.input, `${id} input`);
+        const expected = object(vector.expected, `${id} expected`);
+        exactKeys(input, INPUT_KEYS[vector.category], `${id} input`);
+        exactKeys(expected, EXPECTED_KEYS[vector.category], `${id} expected`);
+        if (vector.category === "intent_freshness") {
+            safeSeconds(input.intent_timestamp, `${id} input.intent_timestamp`);
+            safeSeconds(input.evaluation_time, `${id} input.evaluation_time`);
+            safeSeconds(input.max_clock_skew_seconds, `${id} input.max_clock_skew_seconds`);
+            safeSeconds(input.max_intent_age_seconds, `${id} input.max_intent_age_seconds`);
+            validateDecisionExpected(expected, id);
+        }
+        else if (vector.category === "authorization_issuance") {
+            safeSeconds(input.intent_timestamp, `${id} input.intent_timestamp`);
+            safeSeconds(input.evaluation_time, `${id} input.evaluation_time`);
+            safeSeconds(input.effective_ttl, `${id} input.effective_ttl`, true);
+            if (input.authorization_action !== "EXECUTE" && input.authorization_action !== "RELEASE")
+                throw new Error(`${id} input.authorization_action: unknown action`);
+            validateDecisionExpected(expected, id);
+            safeSeconds(expected.authorization_issued_at, `${id} expected.authorization_issued_at`);
+            safeSeconds(expected.authorization_expiry, `${id} expected.authorization_expiry`);
+        }
+        else if (vector.category === "replay") {
+            safeSeconds(input.replay_window_seconds, `${id} input.replay_window_seconds`, true);
+            nonNegativeCount(input.max_nonces_per_agent, `${id} input.max_nonces_per_agent`);
+            if (input.initial_nonce_state !== undefined)
+                validateNonceState(input.initial_nonce_state, id, "input.initial_nonce_state");
+            validateSteps(vector);
+        }
+        else if (vector.category === "velocity") {
+            safeSeconds(input.window_seconds, `${id} input.window_seconds`, true);
+            nonNegativeCount(input.max_actions, `${id} input.max_actions`);
+            if (input.initial_velocity !== undefined)
+                validateInitialVelocity(input.initial_velocity, id);
+            validateSteps(vector);
+        }
+        else if (vector.category === "authorization_verification") {
+            safeSeconds(input.authorization_issued_at, `${id} input.authorization_issued_at`);
+            safeSeconds(input.authorization_expiry, `${id} input.authorization_expiry`);
+            safeSeconds(input.verifier_time, `${id} input.verifier_time`);
+            safeSeconds(input.max_future_issued_at_skew_seconds, `${id} input.max_future_issued_at_skew_seconds`);
+            if (expected.status !== "ok" && expected.status !== "invalid")
+                throw new Error(`${id} expected.status: unsupported verifier status`);
+            for (const code of array(expected.violation_codes, `${id} expected.violation_codes`))
+                if (typeof code !== "string" || !VERIFICATION_CODES.has(code))
+                    throw new Error(`${id} expected.violation_codes: unsupported verification code ${String(code)}`);
+        }
+        else if (vector.category === "determinism") {
+            nonNegativeCount(input.repeat, `${id} input.repeat`);
+            if (input.repeat < 2)
+                throw new Error(`${id} input.repeat: must be at least 2`);
+            if (input.kind === "velocity_sequence") {
+                safeSeconds(input.window_seconds, `${id} input.window_seconds`, true);
+                nonNegativeCount(input.max_actions, `${id} input.max_actions`);
+                if (input.initial_velocity !== undefined)
+                    validateInitialVelocity(input.initial_velocity, id);
+                validateSteps(vector);
+            }
+            else {
+                if (input.kind !== undefined)
+                    throw new Error(`${id} input.kind: unsupported determinism kind`);
+                safeSeconds(input.intent_timestamp, `${id} input.intent_timestamp`);
+                safeSeconds(input.evaluation_time, `${id} input.evaluation_time`);
+                safeSeconds(input.effective_ttl, `${id} input.effective_ttl`, true);
+                validateDecisionExpected(expected, id);
+            }
+            if (expected.identical_output !== true)
+                throw new Error(`${id} expected.identical_output: must be true`);
+        }
+        else if (vector.category === "malformed_configuration") {
+            text(input.configuration_field, `${id} input.configuration_field`);
+            if (expected.throws !== true)
+                throw new Error(`${id} expected.throws: must be true`);
+            text(expected.error_includes, `${id} expected.error_includes`);
+        }
+        else if (vector.category === "protocol_seconds_validation") {
+            text(input.case, `${id} input.case`);
+            if (expected.reasons !== undefined)
+                validateDecisionExpected(expected, id);
+            if (expected.throws !== undefined && expected.throws !== true)
+                throw new Error(`${id} expected.throws: must be true`);
+            if (expected.error_includes !== undefined)
+                text(expected.error_includes, `${id} expected.error_includes`);
+        }
+        else if (vector.category === "tool_window") {
+            safeSeconds(input.window_seconds, `${id} input.window_seconds`, true);
+            nonNegativeCount(input.max_calls, `${id} input.max_calls`);
+            if (input.max_calls_by_tool !== undefined)
+                nonNegativeCount(input.max_calls_by_tool, `${id} input.max_calls_by_tool`);
+            if (input.initial_tool_calls !== undefined)
+                validateToolCalls(input.initial_tool_calls, id, "input.initial_tool_calls");
+            validateSteps(vector);
+        }
+    }
+    return file;
+}
+function validateInitialVelocity(raw, id) {
+    const value = object(raw, `${id} input.initial_velocity`);
+    exactKeys(value, new Set(["velocity_window_start", "velocity_count"]), `${id} input.initial_velocity`);
+    if (typeof value.velocity_window_start !== "number" || !Number.isSafeInteger(value.velocity_window_start))
+        throw new Error(`${id} input.initial_velocity.velocity_window_start: expected safe integer`);
+    nonNegativeCount(value.velocity_count, `${id} input.initial_velocity.velocity_count`);
+}
+function makeState() {
+    return {
+        policy_version: "v1.0.0", period_id: "period-1",
+        kill_switch: { global: false, agents: {} }, allowlists: {},
+        budget: { budget_limit: { "agent-1": 5000000n }, spent_in_period: { "agent-1": 0n } },
+        max_amount_per_action: { "agent-1": 2000000n },
+        velocity: { config: { window_seconds: 60, max_actions: 10 }, counters: {} },
+        replay: { window_seconds: 600, max_nonces_per_agent: 256, nonces: {} },
+        concurrency: { max_concurrent: { "agent-1": 10 }, active: {}, active_auths: {} },
+        recursion: { max_depth: { "agent-1": 10 } },
+        tool_limits: { window_seconds: 600, max_calls: { "agent-1": 100 }, calls: {} },
+    };
+}
+function makeEngine(ttl = 60, skew = 300, age = 300) {
+    return new PolicyEngine({ policy_version: "v1.0.0", engine_secret: CONFORMANCE_ENGINE_SECRET, authorization_ttl_seconds: ttl, maxClockSkewSeconds: skew, maxIntentAgeSeconds: age, policyId: "a".repeat(64) });
+}
+function intent(id, timestamp, nonce, action = "EXECUTE") {
+    const nonceValue = /^\d+$/.test(nonce)
+        ? BigInt(nonce)
+        : BigInt([...nonce].reduce((n, c) => n + c.charCodeAt(0), 10_000));
+    return {
+        intent_id: `${id}-${nonce}`, agent_id: "agent-1", action_type: "PAYMENT", amount: 100n,
+        asset: "wallet", target: "merchant-1", timestamp, metadata_hash: "0".repeat(64),
+        nonce: nonceValue, signature: "sig", depth: 0,
+        ...(action === "RELEASE" ? { type: "RELEASE", authorization_id: "release-id" } : { type: "EXECUTE" }),
+    };
+}
+function normalize(value) {
+    return JSON.parse(JSON.stringify(value, (_key, item) => typeof item === "bigint" ? `${item}n` : item));
+}
+function equal(actual, expected) { return JSON.stringify(normalize(actual)) === JSON.stringify(normalize(expected)); }
+function runSequence(vector, category) {
+    const input = vector.input;
+    let state = makeState();
+    if (category === "replay") {
+        state.replay.window_seconds = input.replay_window_seconds;
+        state.replay.max_nonces_per_agent = input.max_nonces_per_agent;
+        state.replay.nonces["agent-1"] = (input.initial_nonce_state ?? []).map(x => ({ nonce: x.nonce, ts: x.nonce_first_seen_time }));
+    }
+    else if (category === "velocity") {
+        state.velocity.config = { window_seconds: input.window_seconds, max_actions: input.max_actions };
+        if (input.initial_velocity) {
+            const initial = input.initial_velocity;
+            state.velocity.counters["agent-1"] = { window_start: initial.velocity_window_start, count: initial.velocity_count };
+        }
+    }
+    else {
+        state.tool_limits.window_seconds = input.window_seconds;
+        state.tool_limits.max_calls["agent-1"] = input.max_calls;
+        if (input.max_calls_by_tool !== undefined) {
+            state.tool_limits.max_calls_by_tool = { "agent-1": { search: input.max_calls_by_tool } };
+        }
+        state.tool_limits.calls["agent-1"] = (input.initial_tool_calls ?? []).map(x => ({ ts: x.tool_call_time, tool: x.tool }));
+    }
+    const observations = [];
+    for (const [index, rawStep] of input.steps.entries()) {
+        const before = structuredClone(state);
+        const stepIntent = {
+            ...intent(vector.id, rawStep.intent_timestamp, rawStep.nonce),
+            ...(category === "tool_window" ? { tool: "search", tool_call: true } : {}),
+        };
+        const out = makeEngine().evaluatePure(stepIntent, state, rawStep.evaluation_time);
+        if (out.decision === "ALLOW")
+            state = out.nextState;
+        else
+            state = before;
+        const base = { decision: out.decision, reasons: [...out.reasons] };
+        observations.push(category === "replay"
+            ? { ...base, nonce_state: (state.replay.nonces["agent-1"] ?? []).map(x => ({ nonce: x.nonce, nonce_first_seen_time: x.ts })) }
+            : category === "velocity"
+                ? { ...base, velocity_window_start: state.velocity.counters["agent-1"]?.window_start, velocity_count: state.velocity.counters["agent-1"]?.count }
+                : { ...base, tool_calls: (state.tool_limits.calls["agent-1"] ?? []).map(x => ({ tool_call_time: x.ts, tool: x.tool })) });
+        void index;
+    }
+    return observations;
+}
+const KEYSET = { issuer: "issuer", version: "1", keys: [{ kid: "k1", alg: "Ed25519", public_key: TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION }] };
+function runVector(vector) {
+    const input = vector.input;
+    if (vector.category === "intent_freshness") {
+        return verifyTrustedTime({ intentTimestamp: input.intent_timestamp, evaluationTime: input.evaluation_time, maxClockSkewSeconds: input.max_clock_skew_seconds, maxIntentAgeSeconds: input.max_intent_age_seconds });
+    }
+    if (vector.category === "authorization_issuance") {
+        const action = input.authorization_action;
+        const state = makeState();
+        if (action === "RELEASE") {
+            state.concurrency.active["agent-1"] = 1;
+            state.concurrency.active_auths["agent-1"] = { "release-id": { expires_at: input.evaluation_time + 600 } };
+        }
+        const out = makeEngine(input.effective_ttl).evaluatePure(intent(vector.id, input.intent_timestamp, "1", action), state, input.evaluation_time);
+        return out.decision === "ALLOW" ? { decision: out.decision, reasons: out.reasons, authorization_issued_at: out.authorization.issued_at, authorization_expiry: out.authorization.expiry } : { decision: out.decision, reasons: out.reasons };
+    }
+    if (vector.category === "replay" || vector.category === "velocity")
+        return { steps: runSequence(vector, vector.category) };
+    if (vector.category === "tool_window") {
+        const first = { steps: runSequence(vector, "tool_window") };
+        const second = { steps: runSequence(vector, "tool_window") };
+        if (!equal(first, second))
+            throw new Error(`${vector.id}: repeated tool-window execution was not deterministic`);
+        return first;
+    }
+    if (vector.category === "authorization_verification") {
+        const unsigned = { auth_id: vector.id, issuer: "issuer", audience: "aud", intent_hash: "1".repeat(64), state_hash: "2".repeat(64), policy_id: "3".repeat(64), decision: "ALLOW", issued_at: input.authorization_issued_at, expiry: input.authorization_expiry, kid: "k1" };
+        const auth = signAuthorizationEd25519(unsigned, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+        const result = verifyAuthorization(auth, { now: input.verifier_time, mode: "strict", expectedIssuer: "issuer", expectedAudience: "aud", trustedKeySets: KEYSET, maxFutureIssuedAtSkewSeconds: input.max_future_issued_at_skew_seconds });
+        return { status: result.status, violation_codes: result.violations.map(v => v.code) };
+    }
+    if (vector.category === "malformed_configuration") {
+        try {
+            if (input.configuration_field === "authorization_ttl_seconds")
+                makeEngine(input.configuration_value);
+            else
+                verifyAuthorization({}, { maxFutureIssuedAtSkewSeconds: input.configuration_value });
+            return { throws: false, error_includes: "" };
+        }
+        catch (error) {
+            return { throws: true, error_includes: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    if (vector.category === "protocol_seconds_validation") {
+        try {
+            if (input.case === "intent_timestamp") {
+                return verifyTrustedTime({ intentTimestamp: input.intent_timestamp, evaluationTime: input.evaluation_time, maxClockSkewSeconds: 300, maxIntentAgeSeconds: 300 });
+            }
+            const out = makeEngine(input.effective_ttl ?? 60).evaluatePure(intent(vector.id, input.intent_timestamp, "1"), makeState(), input.evaluation_time);
+            return { decision: out.decision, reasons: out.reasons };
+        }
+        catch (error) {
+            return { throws: true, error_includes: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    if (vector.category === "determinism") {
+        const outputs = [];
+        for (let i = 0; i < input.repeat; i++) {
+            if (input.kind === "velocity_sequence")
+                outputs.push({ steps: runSequence(vector, "velocity") });
+            else {
+                const out = makeEngine(input.effective_ttl).evaluatePure(intent(vector.id, input.intent_timestamp, "1"), makeState(), input.evaluation_time);
+                outputs.push(out.decision === "ALLOW" ? { decision: out.decision, reasons: out.reasons, authorization_issued_at: out.authorization.issued_at, authorization_expiry: out.authorization.expiry, full: normalize(out) } : normalize(out));
+            }
+        }
+        const first = outputs[0];
+        const identical = outputs.every(x => equal(x, first));
+        if (input.kind === "velocity_sequence")
+            return { identical_output: identical };
+        const base = first;
+        return { decision: base.decision, reasons: base.reasons, authorization_issued_at: base.authorization_issued_at, authorization_expiry: base.authorization_expiry, identical_output: identical };
+    }
+    throw new Error(`${vector.id}: active category ${vector.category} has no executor`);
+}
+function matches(actual, expected) {
+    if (expected.throws === true)
+        return actual.throws === true && String(actual.error_includes).includes(String(expected.error_includes));
+    return equal(actual, expected);
+}
+function mismatchDetail(vector, actual) {
+    if (vector.category !== "replay" && vector.category !== "velocity" && vector.category !== "tool_window")
+        return undefined;
+    const actualSteps = actual.steps;
+    const expectedSteps = vector.expected.steps;
+    const inputSteps = vector.input.steps;
+    for (let index = 0; index < expectedSteps.length; index++) {
+        if (!equal(actualSteps[index], expectedSteps[index])) {
+            const input = inputSteps[index];
+            return `step ${index + 1} intent_timestamp=${String(input.intent_timestamp)} evaluation_time=${String(input.evaluation_time)} expected=${JSON.stringify(expectedSteps[index])} actual=${JSON.stringify(actualSteps[index])}`;
+        }
+    }
+    return undefined;
+}
+export function runTrustedTimeConformance(raw, log = console.log) {
+    const file = parseTrustedTimeFile(raw);
+    const passedCaseIds = [];
+    const summary = { active: 0, passed: 0, failed: 0, pending: 0, failures: [] };
+    for (const vector of file.vectors) {
+        if (vector.status === "pending") {
+            summary.pending++;
+            log(`PENDING ${vector.id} blocked_by=${vector.blocked_by}`);
+            continue;
+        }
+        summary.active++;
+        try {
+            const actual = runVector(vector);
+            if (!matches(actual, vector.expected))
+                throw new Error(mismatchDetail(vector, actual) ?? `expected=${JSON.stringify(vector.expected)} actual=${JSON.stringify(actual)}`);
+            passedCaseIds.push(vector.id);
+            summary.passed++;
+            log(`PASS ${vector.id}`);
+        }
+        catch (error) {
+            summary.failed++;
+            const detail = error instanceof Error ? error.message : String(error);
+            const message = `${vector.id}: ${detail}`;
+            summary.failures.push(message);
+            log(`FAIL ${message}`);
+        }
+    }
+    return { ...summary, evidenceScope: evidenceScope({ consumer: "packages/conformance/src/trustedTimeConformance.ts", runtime: "TypeScript", selections: [{
+                    representation: "packages/conformance/vectors/trusted-time.json", data: raw,
+                    consumer: "packages/conformance/src/trustedTimeConformance.ts", runtime: "TypeScript",
+                    caseIds: file.vectors.filter(v => v.status === "active").map(v => v.id), passedCaseIds,
+                }] }) };
+}
+export function trustedTimeExitCode(summary) {
+    return summary.failed === 0 ? 0 : 1;
+}
+//# sourceMappingURL=trustedTimeConformance.js.map