@deepstrike/wasm 0.2.76 → 0.2.78

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

@@ -1,59 +0,0 @@
-/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
-export declare const VERIFIABLE_REPORT_SCHEMA: "verifiable-report/v2";
-export declare const VERIFIABLE_FORK_SCHEMA: "verifiable-fork/v2";
-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

@@ -1,64 +0,0 @@
-import { getKernel } from "./kernel.js";
-/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
-export const VERIFIABLE_REPORT_SCHEMA = "verifiable-report/v2";
-export const VERIFIABLE_FORK_SCHEMA = "verifiable-fork/v2";
-/** 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/dist/runtime/workflow-control-flow.d.ts

@@ -1,21 +0,0 @@
-/** Instruction appended to a loop iteration's goal. DW-3: the continuation verb is the
- *  kernel-adjudicated `pace` meta-tool (armed on every iteration run), not a text blob — one
- *  vocabulary shared with the round-level loop agent. Iterations share one session, so "the work
- *  so far" is simply the visible transcript. */
-export declare function loopInstruction(maxIters: number, iteration?: number): string;
-/** W-N2: dependency outputs appended to a dependent node's goal — a DAG edge carries data, not
- *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
- *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
- *  outputs are skipped. Returns "" when the node has no dependencies. */
-export declare function dependencyOutputsNote(inputAgentIds: string[] | undefined, outputs: Map<string, string> | undefined, maxPerDep?: number): string;
-/** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
-export declare function classifyInstruction(labels: string[]): string;
-/** Build a tournament judge's goal: the controller's criterion + the two candidates to compare. */
-export declare function judgeGoal(criterion: string, leftOutput: string, rightOutput: string): string;
-/** Extract the chosen branch label from a classifier's output. Prefers `{branch: "..."}`; falls back
- *  to a bare label string that exactly matches one of the valid labels. Returns `undefined` when no
- *  recognizable choice was made (the kernel then prunes every branch — a safe "none matched"). */
-export declare function extractClassifyBranch(text: string, labels: string[]): string | undefined;
-/** Extract a tournament judge's verdict ("left" or "right"). Defaults to "left" when the verdict is
- *  unparseable, so the bracket always advances to a champion rather than stalling with no winner. */
-export declare function extractJudgeWinner(text: string): "left" | "right";

package/dist/runtime/workflow-control-flow.js

@@ -1,83 +0,0 @@
-//! A#2: SDK-side execution of the kernel's control-flow workflow node kinds (Loop / Classify /
-//! Tournament). The kernel owns the scheduling — it re-arms loops, prunes classify branches, and
-//! runs the tournament bracket — and tells the SDK *which* kind a spawn is via the spawn descriptor
-//! (`loop_max_iters` / `classify_labels` / `judge_match`). This module is the SDK half of the "one
-//! agent per node + one additive result field" contract: it builds the prompt that solicits the
-//! decision from the node's agent and extracts the matching result signal (`loopContinue` /
-//! `classifyBranch` / `tournamentWinner`) the kernel reads back.
-import { extractJsonValue } from "./output-schema.js";
-/** Instruction appended to a loop iteration's goal. DW-3: the continuation verb is the
- *  kernel-adjudicated `pace` meta-tool (armed on every iteration run), not a text blob — one
- *  vocabulary shared with the round-level loop agent. Iterations share one session, so "the work
- *  so far" is simply the visible transcript. */
-export function loopInstruction(maxIters, iteration = 0) {
-    return (`This task runs as a LOOP — this is iteration ${iteration + 1} of up to ${maxIters}. Your prior ` +
-        `iterations' work (if any) is visible above; do the NEXT increment now. Then call the \`pace\` tool: ` +
-        `\`{"next": "continue"}\` to request another iteration, or \`{"next": "stop"}\` when the overall ` +
-        `task is complete. Ending without calling \`pace\` also completes the loop.`);
-}
-/** W-N2: dependency outputs appended to a dependent node's goal — a DAG edge carries data, not
- *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
- *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
- *  outputs are skipped. Returns "" when the node has no dependencies. */
-export function dependencyOutputsNote(inputAgentIds, outputs, maxPerDep = 8_000) {
-    if (!inputAgentIds?.length || !outputs)
-        return "";
-    const blocks = inputAgentIds
-        .map(id => {
-        const out = outputs.get(id) ?? "";
-        if (!out)
-            return "";
-        const clipped = out.length > maxPerDep ? `${out.slice(0, maxPerDep)}\n…[truncated]` : out;
-        return `[dependency ${id} output]\n${clipped}`;
-    })
-        .filter(Boolean);
-    return blocks.join("\n\n");
-}
-/** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
-export function classifyInstruction(labels) {
-    return (`Classify the input and choose EXACTLY ONE label from: ${labels.map(l => JSON.stringify(l)).join(", ")}. ` +
-        `Respond with ONLY a JSON object: {"branch": "<one of the labels>"}.`);
-}
-/** Build a tournament judge's goal: the controller's criterion + the two candidates to compare. */
-export function judgeGoal(criterion, leftOutput, rightOutput) {
-    return (`${criterion}\n\nCompare the two candidate outputs below and decide which one better satisfies the ` +
-        `criterion above.\n\n[CANDIDATE left]\n${leftOutput}\n\n[CANDIDATE right]\n${rightOutput}\n\n` +
-        `Respond with ONLY a JSON object: {"winner": "left"} or {"winner": "right"}.`);
-}
-/** Extract the chosen branch label from a classifier's output. Prefers `{branch: "..."}`; falls back
- *  to a bare label string that exactly matches one of the valid labels. Returns `undefined` when no
- *  recognizable choice was made (the kernel then prunes every branch — a safe "none matched"). */
-export function extractClassifyBranch(text, labels) {
-    const v = extractJsonValue(text);
-    if (v && typeof v === "object" && !Array.isArray(v)) {
-        const o = v;
-        if (typeof o.branch === "string")
-            return o.branch;
-        if (typeof o.label === "string")
-            return o.label;
-    }
-    if (typeof v === "string" && labels.includes(v))
-        return v;
-    const trimmed = (text ?? "").trim();
-    if (labels.includes(trimmed))
-        return trimmed;
-    return undefined;
-}
-/** Extract a tournament judge's verdict ("left" or "right"). Defaults to "left" when the verdict is
- *  unparseable, so the bracket always advances to a champion rather than stalling with no winner. */
-export function extractJudgeWinner(text) {
-    const v = extractJsonValue(text);
-    if (v && typeof v === "object" && !Array.isArray(v)) {
-        const w = v.winner;
-        if (w === "right")
-            return "right";
-        if (w === "left")
-            return "left";
-    }
-    const lowered = (text ?? "").toLowerCase();
-    // Last resort: a bare mention. Bias to "left" on ambiguity (both/neither mentioned).
-    if (lowered.includes("right") && !lowered.includes("left"))
-        return "right";
-    return "left";
-}