@deepstrike/wasm 0.2.68 → 0.2.69

package/dist/index.d.ts

@@ -5,6 +5,8 @@ export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCano
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
 export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionEventKind, SessionLog, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
+export type { VerifiableCommand, CheckVerdict, VerifiableForkManifest, ForkPlan, VerifiableEvidence, VerifyOptions, ReplayOptions, VerifiableRuntimeAdapter, VerifiableReport, VerifiableOperationJson, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, Jour
 // ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
 export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";

package/dist/runtime/verifiable-report.d.ts

@@ -0,0 +1,59 @@
+/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
+export declare const VERIFIABLE_REPORT_SCHEMA: "verifiable-report/v1";
+export declare const VERIFIABLE_FORK_SCHEMA: "verifiable-fork/v1";
+export type VerifiableCommand = "inspect" | "verify" | "replay" | "fork";
+export type CheckVerdict = "pass" | "degraded" | "fail" | "unavailable";
+export type ReplayVerdict = "pass" | "fail" | "unavailable";
+export type VerifiableReport = {
+    readonly schema: typeof VERIFIABLE_REPORT_SCHEMA;
+    readonly command: VerifiableCommand;
+    readonly operation_id: string;
+    readonly [key: string]: unknown;
+};
+export interface VerifiableEvidence {
+    readonly journal: ReadonlyArray<Uint8Array>;
+    readonly sessionLogs?: ReadonlyArray<ReadonlyArray<Uint8Array>>;
+    readonly checkpoints?: ReadonlyArray<Uint8Array>;
+}
+export interface VerifyOptions {
+    readonly strict?: boolean;
+    readonly requireComplete?: boolean;
+}
+export interface ReplayOptions {
+    readonly strict?: boolean;
+    readonly atStep?: number;
+}
+export interface VerifiableForkManifest {
+    schema: typeof VERIFIABLE_FORK_SCHEMA;
+    operation_id: string;
+    at_step: string;
+    parent_record_digest: string;
+    parent_input_id: string;
+    source_records: number;
+}
+export type ForkPlan = VerifiableForkManifest;
+export interface VerifiableRuntimeAdapter {
+    inspect(operationId: string, evidence: VerifiableEvidence, strict: boolean): VerifiableReport;
+    verify(operationId: string, evidence: VerifiableEvidence, options: VerifyOptions): VerifiableReport;
+    replay(operationId: string, evidence: VerifiableEvidence, options: ReplayOptions): VerifiableReport;
+    prepareFork(operationId: string, evidence: VerifiableEvidence, atStep: number, strict: boolean): ForkPlan;
+}
+export type VerifiableOperationJson = (request: string) => string;
+/** Create the SDK adapter backed by the Rust core JSON bridge. */
+export declare function createVerifiableRuntimeAdapter(operationJson: VerifiableOperationJson): VerifiableRuntimeAdapter;
+/** Create the adapter from the lazily loaded WASM binding. */
+export declare function createNativeVerifiableRuntimeAdapter(): Promise<VerifiableRuntimeAdapter>;
+/** Storage-neutral framework handle. Store access remains in the host adapter. */
+export declare class VerifiableOperation {
+    readonly operationId: string;
+    readonly evidence: VerifiableEvidence;
+    private readonly adapter;
+    constructor(operationId: string, evidence: VerifiableEvidence, adapter: VerifiableRuntimeAdapter);
+    inspect(strict?: boolean): VerifiableReport;
+    verify(options?: VerifyOptions): VerifiableReport;
+    replay(options?: ReplayOptions): VerifiableReport;
+    prepareFork(atStep: number, strict?: boolean): ForkPlan;
+}
+export declare function assertVerifiableReportSchema(value: {
+    schema?: unknown;
+}): void;

package/dist/runtime/verifiable-report.js

@@ -0,0 +1,64 @@
+import { getKernel } from "./kernel.js";
+/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
+export const VERIFIABLE_REPORT_SCHEMA = "verifiable-report/v1";
+export const VERIFIABLE_FORK_SCHEMA = "verifiable-fork/v1";
+/** Create the SDK adapter backed by the Rust core JSON bridge. */
+export function createVerifiableRuntimeAdapter(operationJson) {
+    const call = (operationId, evidence, command, options = {}) => {
+        const result = JSON.parse(operationJson(JSON.stringify({
+            operation_id: operationId,
+            command,
+            evidence: {
+                journal: evidence.journal.map((bytes) => Array.from(bytes)),
+                session_logs: (evidence.sessionLogs ?? []).map((stream) => stream.map((bytes) => Array.from(bytes))),
+                checkpoints: (evidence.checkpoints ?? []).map((bytes) => Array.from(bytes)),
+            },
+            strict: options.strict ?? false,
+            require_complete: "requireComplete" in options ? options.requireComplete ?? false : false,
+            at_step: "atStep" in options ? options.atStep : undefined,
+        })));
+        if (command === "fork")
+            return result;
+        assertVerifiableReportSchema(result);
+        return result;
+    };
+    return {
+        inspect: (operationId, evidence, strict) => call(operationId, evidence, "inspect", { strict }),
+        verify: (operationId, evidence, options) => call(operationId, evidence, "verify", options),
+        replay: (operationId, evidence, options) => call(operationId, evidence, "replay", options),
+        prepareFork: (operationId, evidence, atStep, strict) => call(operationId, evidence, "fork", { atStep, strict }),
+    };
+}
+/** Create the adapter from the lazily loaded WASM binding. */
+export async function createNativeVerifiableRuntimeAdapter() {
+    const kernel = await getKernel();
+    return createVerifiableRuntimeAdapter(kernel.verifiableOperationJson);
+}
+/** Storage-neutral framework handle. Store access remains in the host adapter. */
+export class VerifiableOperation {
+    operationId;
+    evidence;
+    adapter;
+    constructor(operationId, evidence, adapter) {
+        this.operationId = operationId;
+        this.evidence = evidence;
+        this.adapter = adapter;
+    }
+    inspect(strict = false) {
+        return this.adapter.inspect(this.operationId, this.evidence, strict);
+    }
+    verify(options = {}) {
+        return this.adapter.verify(this.operationId, this.evidence, options);
+    }
+    replay(options = {}) {
+        return this.adapter.replay(this.operationId, this.evidence, options);
+    }
+    prepareFork(atStep, strict = false) {
+        return this.adapter.prepareFork(this.operationId, this.evidence, atStep, strict);
+    }
+}
+export function assertVerifiableReportSchema(value) {
+    if (value.schema !== VERIFIABLE_REPORT_SCHEMA) {
+        throw new Error(`unsupported verifiable report schema: ${String(value.schema)}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.68",
+  "version": "0.2.69",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -17,7 +17,7 @@
     "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.68"
+    "@deepstrike/wasm-kernel": "0.2.69"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",