@deepstrike/wasm-kernel 0.2.6 → 0.2.8

package/deepstrike_wasm.d.ts

@@ -1,5 +1,46 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * A single loop stop predicate. `kind` is `\"noNewFindings\"` | `\"noErrors\"` | `\"maxRounds\"`;
+ * `maxRounds` is required only when `kind === \"maxRounds\"`.
+ */
+export interface StopConditionSpec {
+    kind: string;
+    maxRounds?: number;
+}
+
+/**
+ * Discriminated action returned by `LoopUntilDone`. Inspect `kind`:
+ * `\"spawn\"` → `round`; `\"done\"` → `roundsUsed`, `reason`.
+ */
+export interface LoopAction {
+    kind: string;
+    round?: number;
+    roundsUsed?: number;
+    reason?: string;
+}
+
+/**
+ * Discriminated action returned by `Tournament`. Inspect `kind`:
+ * `\"judgeRound\"` → `round`, `matches`; `\"done\"` → `winner`, `roundsUsed`.
+ */
+export interface TournamentAction {
+    kind: string;
+    round?: number;
+    matches?: TournamentMatch[];
+    winner?: string;
+    roundsUsed?: number;
+}
+
+/**
+ * One pairwise match-up in a tournament round.
+ */
+export interface TournamentMatch {
+    id: number;
+    left: string;
+    right: string;
+}
+
 /**
  * Structured context for a provider call — emitted with `kind === \"call_llm\"`.
  */
@@ -10,6 +51,14 @@ export interface RenderedContext {
     turns: Message[];
 }
 
+/**
+ * What the SDK reports after running a loop round\'s worker.
+ */
+export interface RoundReport {
+    newFindings: number;
+    errors: number;
+}
+
 export interface ContentPartObj {
     type: string;
     text?: string;
@@ -185,6 +234,18 @@ export class KernelRuntime {
     turn(): number;
 }
 
+/**
+ * Loop-until-done state machine; a `maxRounds` backstop is injected if none is given.
+ */
+export class LoopUntilDone {
+    free(): void;
+    [Symbol.dispose](): void;
+    feed(report: RoundReport): LoopAction;
+    isDone(): boolean;
+    constructor(conditions: StopConditionSpec[]);
+    start(): LoopAction;
+}
+
 export class SignalRouter {
     free(): void;
     [Symbol.dispose](): void;
@@ -200,3 +261,15 @@ export class SignalRouter {
      */
     next(): RuntimeSignal | undefined;
 }
+
+/**
+ * Single-elimination tournament with pairwise comparative judging.
+ */
+export class Tournament {
+    free(): void;
+    [Symbol.dispose](): void;
+    feedRound(winners: string[]): TournamentAction;
+    isDone(): boolean;
+    constructor(entrants: string[]);
+    start(): TournamentAction;
+}

package/deepstrike_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./deepstrike_wasm_bg.js";
 __wbg_set_wasm(wasm);
 
 export {
-    EvalPipeline, Governance, KernelRuntime, SignalRouter
+    EvalPipeline, Governance, KernelRuntime, LoopUntilDone, SignalRouter, Tournament
 } from "./deepstrike_wasm_bg.js";

package/deepstrike_wasm_bg.js

@@ -294,6 +294,67 @@ export class KernelRuntime {
 }
 if (Symbol.dispose) KernelRuntime.prototype[Symbol.dispose] = KernelRuntime.prototype.free;
 
+/**
+ * Loop-until-done state machine; a `maxRounds` backstop is injected if none is given.
+ */
+export class LoopUntilDone {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LoopUntilDoneFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_loopuntildone_free(ptr, 0);
+    }
+    /**
+     * @param {RoundReport} report
+     * @returns {LoopAction}
+     */
+    feed(report) {
+        const ret = wasm.loopuntildone_feed(this.__wbg_ptr, addHeapObject(report));
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isDone() {
+        const ret = wasm.loopuntildone_isDone(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {StopConditionSpec[]} conditions
+     */
+    constructor(conditions) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(conditions, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.loopuntildone_new(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            LoopUntilDoneFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {LoopAction}
+     */
+    start() {
+        const ret = wasm.loopuntildone_start(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) LoopUntilDone.prototype[Symbol.dispose] = LoopUntilDone.prototype.free;
+
 export class SignalRouter {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -356,6 +417,80 @@ export class SignalRouter {
     }
 }
 if (Symbol.dispose) SignalRouter.prototype[Symbol.dispose] = SignalRouter.prototype.free;
+
+/**
+ * Single-elimination tournament with pairwise comparative judging.
+ */
+export class Tournament {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TournamentFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tournament_free(ptr, 0);
+    }
+    /**
+     * @param {string[]} winners
+     * @returns {TournamentAction}
+     */
+    feedRound(winners) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(winners, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.tournament_feedRound(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isDone() {
+        const ret = wasm.tournament_isDone(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {string[]} entrants
+     */
+    constructor(entrants) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(entrants, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.tournament_new(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            TournamentFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {TournamentAction}
+     */
+    start() {
+        const ret = wasm.tournament_start(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) Tournament.prototype[Symbol.dispose] = Tournament.prototype.free;
 export function __wbg_Error_bce6d499ff0a4aff(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
@@ -499,9 +634,15 @@ const GovernanceFinalization = (typeof FinalizationRegistry === 'undefined')
 const KernelRuntimeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kernelruntime_free(ptr, 1));
+const LoopUntilDoneFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_loopuntildone_free(ptr, 1));
 const SignalRouterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signalrouter_free(ptr, 1));
+const TournamentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tournament_free(ptr, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@deepstrike/wasm-kernel",
   "type": "module",
   "description": "WebAssembly bindings for DeepStrike runtime kernel",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "license": "MIT",
   "files": [
     "deepstrike_wasm_bg.wasm",