@nexart/ai-execution 0.2.0 → 0.4.0

package/dist/types-DF29BsH5.d.ts

@@ -0,0 +1,155 @@
+interface AiExecutionParameters {
+    temperature: number;
+    maxTokens: number;
+    topP: number | null;
+    seed: number | null;
+}
+interface AiExecutionSnapshotV1 {
+    type: 'ai.execution.v1';
+    protocolVersion: '1.2.0';
+    executionSurface: 'ai';
+    executionId: string;
+    timestamp: string;
+    provider: string;
+    model: string;
+    modelVersion: string | null;
+    prompt: string;
+    input: string | Record<string, unknown>;
+    inputHash: string;
+    parameters: AiExecutionParameters;
+    output: string | Record<string, unknown>;
+    outputHash: string;
+    sdkVersion: string | null;
+    appId: string | null;
+    runId?: string | null;
+    stepId?: string | null;
+    stepIndex?: number | null;
+    workflowId?: string | null;
+    conversationId?: string | null;
+    prevStepHash?: string | null;
+}
+interface CerMeta {
+    source?: string;
+    tags?: string[];
+    [key: string]: unknown;
+}
+interface CerAiExecutionBundle {
+    bundleType: 'cer.ai.execution.v1';
+    certificateHash: string;
+    createdAt: string;
+    version: '0.1';
+    snapshot: AiExecutionSnapshotV1;
+    meta?: CerMeta;
+}
+interface VerificationResult {
+    ok: boolean;
+    errors: string[];
+}
+interface CreateSnapshotParams {
+    executionId: string;
+    timestamp?: string;
+    provider: string;
+    model: string;
+    modelVersion?: string | null;
+    prompt: string;
+    input: string | Record<string, unknown>;
+    parameters: AiExecutionParameters;
+    output: string | Record<string, unknown>;
+    sdkVersion?: string | null;
+    appId?: string | null;
+    runId?: string | null;
+    stepId?: string | null;
+    stepIndex?: number | null;
+    workflowId?: string | null;
+    conversationId?: string | null;
+    prevStepHash?: string | null;
+}
+interface AttestationResult {
+    ok: boolean;
+    attestationId?: string;
+    nodeRuntimeHash?: string;
+    certificateHash?: string;
+    protocolVersion?: string;
+    errors?: string[];
+    raw?: unknown;
+}
+interface AttestOptions {
+    nodeUrl: string;
+    apiKey: string;
+    timeoutMs?: number;
+}
+interface CertifyDecisionParams {
+    executionId?: string;
+    timestamp?: string;
+    provider: string;
+    model: string;
+    modelVersion?: string | null;
+    prompt: string;
+    input: string | Record<string, unknown>;
+    parameters: AiExecutionParameters;
+    output: string | Record<string, unknown>;
+    sdkVersion?: string | null;
+    appId?: string | null;
+    meta?: CerMeta;
+    runId?: string | null;
+    stepId?: string | null;
+    stepIndex?: number | null;
+    workflowId?: string | null;
+    conversationId?: string | null;
+    prevStepHash?: string | null;
+}
+interface RunBuilderOptions {
+    runId?: string;
+    workflowId?: string | null;
+    conversationId?: string | null;
+    appId?: string | null;
+}
+interface StepParams {
+    stepId?: string;
+    provider: string;
+    model: string;
+    modelVersion?: string | null;
+    prompt: string;
+    input: string | Record<string, unknown>;
+    parameters: AiExecutionParameters;
+    output: string | Record<string, unknown>;
+    timestamp?: string;
+    meta?: CerMeta;
+}
+interface RunSummary {
+    runId: string;
+    workflowId: string | null;
+    conversationId: string | null;
+    stepCount: number;
+    steps: Array<{
+        stepIndex: number;
+        stepId: string;
+        executionId: string;
+        certificateHash: string;
+        prevStepHash: string | null;
+    }>;
+    finalStepHash: string | null;
+}
+interface ProviderConfig<TInput = unknown, TOutput = unknown> {
+    provider: string;
+    callFn: (input: TInput) => Promise<TOutput>;
+    extractOutput: (raw: TOutput) => string | Record<string, unknown>;
+    extractModelVersion?: (raw: TOutput) => string | null;
+}
+interface WrappedExecutionParams {
+    prompt: string;
+    input: string | Record<string, unknown>;
+    model: string;
+    parameters: AiExecutionParameters;
+    modelVersion?: string | null;
+    appId?: string | null;
+    meta?: CerMeta;
+    executionId?: string;
+}
+interface WrappedExecutionResult {
+    output: string | Record<string, unknown>;
+    snapshot: AiExecutionSnapshotV1;
+    bundle: CerAiExecutionBundle;
+}
+
+export type { AiExecutionSnapshotV1 as A, CreateSnapshotParams as C, ProviderConfig as P, RunBuilderOptions as R, StepParams as S, VerificationResult as V, WrappedExecutionParams as W, CerMeta as a, CerAiExecutionBundle as b, CertifyDecisionParams as c, RunSummary as d, AttestOptions as e, AttestationResult as f, AiExecutionParameters as g, WrappedExecutionResult as h };

package/package.json

@@ -1,31 +1,39 @@
 {
   "name": "@nexart/ai-execution",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "AI Execution Integrity — tamper-evident records and Certified Execution Records (CER) for AI operations",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     },
     "./providers/openai": {
       "types": "./dist/providers/openai.d.ts",
-      "import": "./dist/providers/openai.js"
+      "import": "./dist/providers/openai.mjs",
+      "require": "./dist/providers/openai.cjs"
     },
     "./providers/anthropic": {
       "types": "./dist/providers/anthropic.d.ts",
-      "import": "./dist/providers/anthropic.js"
+      "import": "./dist/providers/anthropic.mjs",
+      "require": "./dist/providers/anthropic.cjs"
     },
     "./providers/wrap": {
       "types": "./dist/providers/wrap.d.ts",
-      "import": "./dist/providers/wrap.js"
-    }
+      "import": "./dist/providers/wrap.mjs",
+      "require": "./dist/providers/wrap.cjs"
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "node --test dist/__tests__/vectors.test.js dist/__tests__/fixtures.test.js dist/__tests__/v020.test.js",
+    "build": "tsup",
+    "build:tsc": "tsc",
+    "test": "tsc && node --test dist-tsc/__tests__/vectors.test.js dist-tsc/__tests__/fixtures.test.js dist-tsc/__tests__/v020.test.js dist-tsc/__tests__/v030.test.js dist-tsc/__tests__/v040.test.js",
+    "release": "npm run build && npm run test && npm version patch && npm publish --access public",
     "prepublishOnly": "npm run build && npm run test"
   },
   "keywords": [
@@ -52,6 +60,7 @@
     "README.md"
   ],
   "devDependencies": {
+    "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   }
 }

package/dist/__tests__/fixtures.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fixtures.test.d.ts.map

package/dist/__tests__/fixtures.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixtures.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/fixtures.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/fixtures.test.js

@@ -1,37 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { verifySnapshot } from '../snapshot.js';
-import { sealCer, verifyCer } from '../cer.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const fixturesDir = join(__dirname, '..', '..', 'fixtures', 'vectors');
-function loadJson(filename) {
-    return JSON.parse(readFileSync(join(fixturesDir, filename), 'utf-8'));
-}
-describe('fixture: vector-001', () => {
-    const snapshot = loadJson('vector-001.snapshot.json');
-    const expected = loadJson('vector-001.expected.json');
-    it('snapshot inputHash matches expected', () => {
-        assert.equal(snapshot.inputHash, expected.inputHash);
-    });
-    it('snapshot outputHash matches expected', () => {
-        assert.equal(snapshot.outputHash, expected.outputHash);
-    });
-    it('snapshot passes verification', () => {
-        const result = verifySnapshot(snapshot);
-        assert.equal(result.ok, true, `verification errors: ${result.errors.join('; ')}`);
-    });
-    it('CER certificateHash matches expected', () => {
-        const bundle = sealCer(snapshot, { createdAt: expected.cerCreatedAt });
-        assert.equal(bundle.certificateHash, expected.certificateHash);
-    });
-    it('CER bundle passes verification', () => {
-        const bundle = sealCer(snapshot, { createdAt: expected.cerCreatedAt });
-        const result = verifyCer(bundle);
-        assert.equal(result.ok, true, `verification errors: ${result.errors.join('; ')}`);
-    });
-});
-//# sourceMappingURL=fixtures.test.js.map

package/dist/__tests__/fixtures.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixtures.test.js","sourceRoot":"","sources":["../../src/__tests__/fixtures.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG/C,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACtC,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;AAEvE,SAAS,QAAQ,CAAC,QAAgB;IAChC,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;AACxE,CAAC;AAED,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;IACnC,MAAM,QAAQ,GAAG,QAAQ,CAAC,0BAA0B,CAA0B,CAAC;IAC/E,MAAM,QAAQ,GAAG,QAAQ,CAAC,0BAA0B,CAKnD,CAAC;IAEF,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC7C,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACtC,MAAM,MAAM,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;QACxC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,wBAAwB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC;QACvE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,eAAe,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACxC,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC;QACvE,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;QACjC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,wBAAwB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/__tests__/v020.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=v020.test.d.ts.map

package/dist/__tests__/v020.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"v020.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/v020.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/v020.test.js

@@ -1,408 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { createSnapshot, verifySnapshot } from '../snapshot.js';
-import { sealCer, verifyCer } from '../cer.js';
-import { certifyDecision } from '../certify.js';
-import { RunBuilder } from '../run.js';
-import { exportCer, importCer } from '../archive.js';
-import { wrapProvider } from '../providers/wrap.js';
-import { CerVerificationError, CerAttestationError } from '../errors.js';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const fixturesDir = join(__dirname, '..', '..', 'fixtures');
-function loadJson(path) {
-    return JSON.parse(readFileSync(join(fixturesDir, path), 'utf-8'));
-}
-const FIXED_TS = '2026-03-01T00:00:00.000Z';
-const BASE_PARAMS = {
-    temperature: 0.7,
-    maxTokens: 1024,
-    topP: null,
-    seed: null,
-};
-describe('backward compatibility: v0.1.0 bundles verify with v0.2.0', () => {
-    it('golden-001 (text) verifies', () => {
-        const bundle = loadJson('golden/golden-001.json');
-        const result = verifyCer(bundle);
-        assert.equal(result.ok, true, `errors: ${result.errors.join('; ')}`);
-    });
-    it('golden-002 (JSON i/o) verifies', () => {
-        const bundle = loadJson('golden/golden-002.json');
-        const result = verifyCer(bundle);
-        assert.equal(result.ok, true, `errors: ${result.errors.join('; ')}`);
-    });
-    it('golden-003 (with meta) verifies', () => {
-        const bundle = loadJson('golden/golden-003.json');
-        const result = verifyCer(bundle);
-        assert.equal(result.ok, true, `errors: ${result.errors.join('; ')}`);
-    });
-    it('golden-004 (all optional fields null) verifies', () => {
-        const bundle = loadJson('golden/golden-004.json');
-        const result = verifyCer(bundle);
-        assert.equal(result.ok, true, `errors: ${result.errors.join('; ')}`);
-    });
-    it('golden-005 (seed+topP set) verifies', () => {
-        const bundle = loadJson('golden/golden-005.json');
-        const result = verifyCer(bundle);
-        assert.equal(result.ok, true, `errors: ${result.errors.join('; ')}`);
-    });
-});
-describe('certifyDecision', () => {
-    it('produces equivalent output to createSnapshot + sealCer', () => {
-        const params = {
-            executionId: 'cd-test-001',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'Test prompt.',
-            input: 'Test input.',
-            parameters: BASE_PARAMS,
-            output: 'Test output.',
-        };
-        const snapshot = createSnapshot(params);
-        const bundle = sealCer(snapshot);
-        const cdBundle = certifyDecision(params);
-        assert.equal(cdBundle.bundleType, bundle.bundleType);
-        assert.equal(cdBundle.version, bundle.version);
-        assert.equal(cdBundle.snapshot.inputHash, bundle.snapshot.inputHash);
-        assert.equal(cdBundle.snapshot.outputHash, bundle.snapshot.outputHash);
-        assert.equal(cdBundle.snapshot.executionId, bundle.snapshot.executionId);
-    });
-    it('auto-generates executionId when not provided', () => {
-        const bundle = certifyDecision({
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-        });
-        assert.ok(bundle.snapshot.executionId.length > 0);
-        assert.equal(bundle.bundleType, 'cer.ai.execution.v1');
-    });
-    it('passes meta through to bundle', () => {
-        const bundle = certifyDecision({
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-            meta: { source: 'test', tags: ['cd'] },
-        });
-        assert.deepStrictEqual(bundle.meta, { source: 'test', tags: ['cd'] });
-    });
-    it('includes workflow fields in snapshot', () => {
-        const bundle = certifyDecision({
-            executionId: 'cd-wf-001',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-            runId: 'run-abc',
-            stepId: 'step-0',
-            stepIndex: 0,
-            workflowId: 'wf-xyz',
-            conversationId: 'conv-123',
-            prevStepHash: null,
-        });
-        assert.equal(bundle.snapshot.runId, 'run-abc');
-        assert.equal(bundle.snapshot.stepId, 'step-0');
-        assert.equal(bundle.snapshot.stepIndex, 0);
-        assert.equal(bundle.snapshot.workflowId, 'wf-xyz');
-        assert.equal(bundle.snapshot.conversationId, 'conv-123');
-        assert.equal(bundle.snapshot.prevStepHash, null);
-    });
-});
-describe('RunBuilder', () => {
-    const stepBase = {
-        provider: 'openai',
-        model: 'gpt-4o',
-        prompt: 'Step prompt.',
-        parameters: BASE_PARAMS,
-    };
-    it('chains prevStepHash correctly across 3 steps', () => {
-        const run = new RunBuilder({ runId: 'run-chain-test', workflowId: 'wf-1' });
-        const b0 = run.step({ ...stepBase, input: 'Step 0 input', output: 'Step 0 output', timestamp: FIXED_TS });
-        const b1 = run.step({ ...stepBase, input: 'Step 1 input', output: 'Step 1 output', timestamp: FIXED_TS });
-        const b2 = run.step({ ...stepBase, input: 'Step 2 input', output: 'Step 2 output', timestamp: FIXED_TS });
-        assert.equal(b0.snapshot.prevStepHash, null);
-        assert.equal(b1.snapshot.prevStepHash, b0.certificateHash);
-        assert.equal(b2.snapshot.prevStepHash, b1.certificateHash);
-    });
-    it('auto-increments stepIndex', () => {
-        const run = new RunBuilder({ runId: 'run-idx-test' });
-        const b0 = run.step({ ...stepBase, input: 'a', output: 'b', timestamp: FIXED_TS });
-        const b1 = run.step({ ...stepBase, input: 'c', output: 'd', timestamp: FIXED_TS });
-        assert.equal(b0.snapshot.stepIndex, 0);
-        assert.equal(b1.snapshot.stepIndex, 1);
-    });
-    it('sets runId on all steps', () => {
-        const run = new RunBuilder({ runId: 'run-id-test' });
-        const b0 = run.step({ ...stepBase, input: 'x', output: 'y', timestamp: FIXED_TS });
-        assert.equal(b0.snapshot.runId, 'run-id-test');
-    });
-    it('finalize returns correct summary', () => {
-        const run = new RunBuilder({ runId: 'run-fin', workflowId: 'wf-fin', conversationId: 'conv-fin' });
-        const b0 = run.step({ ...stepBase, input: 'a', output: 'b', timestamp: FIXED_TS });
-        const b1 = run.step({ ...stepBase, input: 'c', output: 'd', timestamp: FIXED_TS });
-        const summary = run.finalize();
-        assert.equal(summary.runId, 'run-fin');
-        assert.equal(summary.workflowId, 'wf-fin');
-        assert.equal(summary.conversationId, 'conv-fin');
-        assert.equal(summary.stepCount, 2);
-        assert.equal(summary.steps.length, 2);
-        assert.equal(summary.steps[0].stepIndex, 0);
-        assert.equal(summary.steps[0].prevStepHash, null);
-        assert.equal(summary.steps[1].stepIndex, 1);
-        assert.equal(summary.steps[1].prevStepHash, b0.certificateHash);
-        assert.equal(summary.finalStepHash, b1.certificateHash);
-    });
-    it('each step bundle verifies independently', () => {
-        const run = new RunBuilder({ runId: 'run-verify' });
-        const b0 = run.step({ ...stepBase, input: 'a', output: 'b', timestamp: FIXED_TS });
-        const b1 = run.step({ ...stepBase, input: 'c', output: 'd', timestamp: FIXED_TS });
-        assert.equal(verifyCer(b0).ok, true);
-        assert.equal(verifyCer(b1).ok, true);
-    });
-    it('generates executionId from runId + stepIndex', () => {
-        const run = new RunBuilder({ runId: 'run-eid' });
-        const b0 = run.step({ ...stepBase, input: 'a', output: 'b', timestamp: FIXED_TS });
-        assert.equal(b0.snapshot.executionId, 'run-eid-step-0');
-    });
-});
-describe('exportCer / importCer', () => {
-    it('round-trips a valid bundle', () => {
-        const snapshot = createSnapshot({
-            executionId: 'rt-001',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-        });
-        const bundle = sealCer(snapshot, { createdAt: FIXED_TS });
-        const exported = exportCer(bundle);
-        const imported = importCer(exported);
-        assert.equal(imported.certificateHash, bundle.certificateHash);
-        assert.equal(imported.snapshot.inputHash, bundle.snapshot.inputHash);
-        assert.equal(imported.snapshot.outputHash, bundle.snapshot.outputHash);
-    });
-    it('rejects tampered JSON', () => {
-        const snapshot = createSnapshot({
-            executionId: 'rt-tamper',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-        });
-        const bundle = sealCer(snapshot, { createdAt: FIXED_TS });
-        const exported = exportCer(bundle);
-        const tampered = exported.replace('"o"', '"tampered"');
-        assert.throws(() => importCer(tampered), CerVerificationError);
-    });
-    it('rejects invalid JSON', () => {
-        assert.throws(() => importCer('not json'), CerVerificationError);
-    });
-    it('rejects wrong bundleType', () => {
-        assert.throws(() => importCer('{"bundleType":"wrong"}'), CerVerificationError);
-    });
-});
-describe('wrapProvider', () => {
-    it('wraps a custom provider', async () => {
-        const mockOutput = { text: 'Hello from mock' };
-        const wrapped = wrapProvider({
-            provider: 'mock-provider',
-            callFn: async (_input) => mockOutput,
-            extractOutput: (raw) => raw.text,
-        });
-        const result = await wrapped.execute({
-            providerInput: { prompt: 'test' },
-            prompt: 'System prompt',
-            input: 'User input',
-            model: 'mock-v1',
-            parameters: BASE_PARAMS,
-        });
-        assert.equal(result.output, 'Hello from mock');
-        assert.equal(result.snapshot.provider, 'mock-provider');
-        assert.equal(result.snapshot.model, 'mock-v1');
-        assert.equal(result.bundle.bundleType, 'cer.ai.execution.v1');
-        assert.equal(verifyCer(result.bundle).ok, true);
-    });
-    it('uses extractModelVersion when provided', async () => {
-        const wrapped = wrapProvider({
-            provider: 'versioned',
-            callFn: async () => ({ text: 'ok', version: 'v2.1' }),
-            extractOutput: (raw) => raw.text,
-            extractModelVersion: (raw) => raw.version,
-        });
-        const result = await wrapped.execute({
-            providerInput: {},
-            prompt: 'p',
-            input: 'i',
-            model: 'm',
-            parameters: BASE_PARAMS,
-        });
-        assert.equal(result.snapshot.modelVersion, 'v2.1');
-    });
-});
-describe('typed errors', () => {
-    it('CerVerificationError has errors array', () => {
-        const err = new CerVerificationError(['e1', 'e2']);
-        assert.equal(err.name, 'CerVerificationError');
-        assert.deepStrictEqual(err.errors, ['e1', 'e2']);
-        assert.ok(err.message.includes('e1'));
-        assert.ok(err instanceof Error);
-    });
-    it('CerAttestationError has statusCode and responseBody', () => {
-        const err = new CerAttestationError('fail', 401, { error: 'unauthorized' });
-        assert.equal(err.name, 'CerAttestationError');
-        assert.equal(err.statusCode, 401);
-        assert.deepStrictEqual(err.responseBody, { error: 'unauthorized' });
-        assert.ok(err instanceof Error);
-    });
-});
-describe('snapshot workflow fields', () => {
-    it('creates snapshot without workflow fields (backward compat)', () => {
-        const snap = createSnapshot({
-            executionId: 'no-wf',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-        });
-        assert.equal(snap.runId, undefined);
-        assert.equal(snap.stepId, undefined);
-        assert.equal(snap.stepIndex, undefined);
-    });
-    it('creates snapshot with workflow fields', () => {
-        const snap = createSnapshot({
-            executionId: 'wf-test',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-            runId: 'run-1',
-            stepId: 'step-0',
-            stepIndex: 0,
-            workflowId: 'wf-1',
-            conversationId: 'conv-1',
-            prevStepHash: null,
-        });
-        assert.equal(snap.runId, 'run-1');
-        assert.equal(snap.stepId, 'step-0');
-        assert.equal(snap.stepIndex, 0);
-        assert.equal(snap.workflowId, 'wf-1');
-        assert.equal(snap.conversationId, 'conv-1');
-        assert.equal(snap.prevStepHash, null);
-    });
-    it('workflow fields included in certificate hash', () => {
-        const params = {
-            executionId: 'wf-hash-test',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-        };
-        const snap1 = createSnapshot(params);
-        const snap2 = createSnapshot({ ...params, runId: 'run-x', stepIndex: 0 });
-        const b1 = sealCer(snap1, { createdAt: FIXED_TS });
-        const b2 = sealCer(snap2, { createdAt: FIXED_TS });
-        assert.notEqual(b1.certificateHash, b2.certificateHash);
-    });
-    it('v0.2 snapshot verifies correctly', () => {
-        const snap = createSnapshot({
-            executionId: 'v02-verify',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-            runId: 'r',
-            stepIndex: 0,
-        });
-        assert.equal(verifySnapshot(snap).ok, true);
-    });
-});
-describe('fixture: vector-002 (3-step chain)', () => {
-    const chain = loadJson('vectors/vector-002.chain.json');
-    it('has 3 steps', () => {
-        assert.equal(chain.length, 3);
-    });
-    it('each step snapshot verifies', () => {
-        for (const entry of chain) {
-            const result = verifySnapshot(entry.snapshot);
-            assert.equal(result.ok, true, `step ${entry.snapshot.stepIndex} errors: ${result.errors.join('; ')}`);
-        }
-    });
-    it('each step CER hash matches expected', () => {
-        for (const entry of chain) {
-            const bundle = sealCer(entry.snapshot, { createdAt: entry.cerCreatedAt });
-            assert.equal(bundle.certificateHash, entry.expectedCertificateHash, `step ${entry.snapshot.stepIndex} hash mismatch`);
-        }
-    });
-    it('prevStepHash chain is correct', () => {
-        assert.equal(chain[0].snapshot.prevStepHash, null);
-        assert.equal(chain[1].snapshot.prevStepHash, chain[0].expectedCertificateHash);
-        assert.equal(chain[2].snapshot.prevStepHash, chain[1].expectedCertificateHash);
-    });
-    it('stepIndex is sequential', () => {
-        assert.equal(chain[0].snapshot.stepIndex, 0);
-        assert.equal(chain[1].snapshot.stepIndex, 1);
-        assert.equal(chain[2].snapshot.stepIndex, 2);
-    });
-});
-describe('sdkVersion updated to 0.2.0', () => {
-    it('new snapshots default to 0.2.0', () => {
-        const snap = createSnapshot({
-            executionId: 'ver-test',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-        });
-        assert.equal(snap.sdkVersion, '0.2.0');
-    });
-    it('explicit sdkVersion overrides default', () => {
-        const snap = createSnapshot({
-            executionId: 'ver-override',
-            timestamp: FIXED_TS,
-            provider: 'openai',
-            model: 'gpt-4o',
-            prompt: 'p',
-            input: 'i',
-            parameters: BASE_PARAMS,
-            output: 'o',
-            sdkVersion: '0.1.0',
-        });
-        assert.equal(snap.sdkVersion, '0.1.0');
-    });
-});
-//# sourceMappingURL=v020.test.js.map