@deepstrike/wasm-kernel 0.1.16 → 0.2.2

package/deepstrike_wasm.d.ts

@@ -1,30 +1,5 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Discriminated union for runtime observations:
- * - `\"compressed\"` → `action`, `rhoAfter`
- */
-export interface LoopObservation {
-    kind: string;
-    action?: string;
-    rhoAfter?: number;
-    sprint?: number;
-}
-
-/**
- * Discriminated union; inspect `kind`:
- * - `\"call_llm\"`      → `context`, `tools` (includes meta-tools when configured)
- * - `\"execute_tools\"` → `calls`
- * - `\"done\"`          → `result`
- */
-export interface LoopAction {
-    kind: string;
-    context?: RenderedContext;
-    tools?: ToolSchema[];
-    calls?: ToolCall[];
-    result?: LoopResult;
-}
-
 /**
  * Structured context for a provider call — emitted with `kind === \"call_llm\"`.
  */
@@ -155,6 +130,8 @@ export interface ToolResult {
     callId: string;
     output: string;
     isError?: boolean;
+    isFatal?: boolean;
+    errorKind?: string;
     tokenCount?: number;
 }
 
@@ -165,20 +142,6 @@ export interface ToolSchema {
 }
 
 
-export class ContextEngine {
-    free(): void;
-    [Symbol.dispose](): void;
-    addAssistantMessage(content: string, tokens: number): void;
-    addSystemMessage(content: string, tokens: number): void;
-    addUserMessage(content: string, tokens: number): void;
-    compress(): number;
-    constructor(max_tokens: number);
-    pressure(): number;
-    render(): RenderedContext;
-    setAvailableSkills(skills: SkillMetadata[]): void;
-    totalTokens(): number;
-}
-
 export class EvalPipeline {
     free(): void;
     [Symbol.dispose](): void;
@@ -192,46 +155,32 @@ export class EvalPipeline {
 export class Governance {
     free(): void;
     [Symbol.dispose](): void;
+    addPermissionRule(pattern: string, action: string): void;
+    allowParamValues(tool_name: string, param_path: string, allowed_values: string[]): void;
     blockTool(name: string): void;
     evaluate(tool_name: string, args_json: string): GovernanceVerdict;
-    constructor();
+    limitParamRange(tool_name: string, param_path: string, min?: number | null, max?: number | null): void;
+    constructor(default_action?: string | null);
+    requireParam(tool_name: string, param_path: string): void;
+    setIdentity(agent_id: string, session_id: string): void;
+    setRateLimit(tool_name: string, max_calls: number, window_ms: number): void;
     setTime(now_ms: number): void;
 }
 
-export class LoopStateMachine {
+export class KernelRuntime {
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Pre-populate the history partition with a prior transcript message.
-     * Must be called before `start`.
-     */
-    addHistoryMessage(message: Message, tokens: number): void;
-    /**
-     * Pre-populate the memory partition with a long-term memory snippet.
-     * Must be called before `start`. Use for seeding known context from past sessions.
-     * `tokens` is a caller-supplied estimate; pass at least 1.
-     */
-    addMemoryMessage(content: string, tokens: number): void;
-    /**
-     * Prepend a system-level instruction to the context. Must be called before `start`.
-     * `tokens` is a caller-supplied estimate (use `content.length / 4` if unsure).
-     * The renderer skips messages with `tokens == 0`, so always pass at least 1.
-     */
-    addSystemMessage(content: string, tokens: number): void;
-    feedLlmResponse(message: Message): LoopAction;
-    feedTimeout(): LoopAction;
-    feedToolResults(results: ToolResult[]): LoopAction;
+    drainNewMessages(): Message[];
     isTerminal(): boolean;
     constructor(policy: LoopPolicy);
-    pressure(): number;
+    preservedRefs(): string[];
+    recoveryContentBytes(): number;
     render(): RenderedContext;
-    setAvailableSkills(skills: SkillMetadata[]): void;
-    setKnowledgeEnabled(enabled: boolean): void;
-    setMemoryEnabled(enabled: boolean): void;
-    setTools(tools: ToolSchema[]): void;
-    start(task: RuntimeTask): LoopAction;
-    takeObservations(): LoopObservation[];
-    readonly turn: number;
+    /**
+     * Feed a JSON-encoded KernelInput and return a JSON-encoded KernelStep.
+     */
+    step(input_json: string): string;
+    turn(): number;
 }
 
 export class SignalRouter {

package/deepstrike_wasm.js

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

package/deepstrike_wasm_bg.js

@@ -1,89 +1,3 @@
-export class ContextEngine {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ContextEngineFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_contextengine_free(ptr, 0);
-    }
-    /**
-     * @param {string} content
-     * @param {number} tokens
-     */
-    addAssistantMessage(content, tokens) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.contextengine_addAssistantMessage(this.__wbg_ptr, ptr0, len0, tokens);
-    }
-    /**
-     * @param {string} content
-     * @param {number} tokens
-     */
-    addSystemMessage(content, tokens) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.contextengine_addSystemMessage(this.__wbg_ptr, ptr0, len0, tokens);
-    }
-    /**
-     * @param {string} content
-     * @param {number} tokens
-     */
-    addUserMessage(content, tokens) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.contextengine_addUserMessage(this.__wbg_ptr, ptr0, len0, tokens);
-    }
-    /**
-     * @returns {number}
-     */
-    compress() {
-        const ret = wasm.contextengine_compress(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @param {number} max_tokens
-     */
-    constructor(max_tokens) {
-        const ret = wasm.contextengine_new(max_tokens);
-        this.__wbg_ptr = ret;
-        ContextEngineFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {number}
-     */
-    pressure() {
-        const ret = wasm.contextengine_pressure(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {RenderedContext}
-     */
-    render() {
-        const ret = wasm.contextengine_render(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * @param {SkillMetadata[]} skills
-     */
-    setAvailableSkills(skills) {
-        const ptr0 = passArrayJsValueToWasm0(skills, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.contextengine_setAvailableSkills(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @returns {number}
-     */
-    totalTokens() {
-        const ret = wasm.contextengine_totalTokens(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) ContextEngine.prototype[Symbol.dispose] = ContextEngine.prototype.free;
-
 export class EvalPipeline {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -155,6 +69,31 @@ export class Governance {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_governance_free(ptr, 0);
     }
+    /**
+     * @param {string} pattern
+     * @param {string} action
+     */
+    addPermissionRule(pattern, action) {
+        const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(action, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.governance_addPermissionRule(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @param {string} tool_name
+     * @param {string} param_path
+     * @param {string[]} allowed_values
+     */
+    allowParamValues(tool_name, param_path, allowed_values) {
+        const ptr0 = passStringToWasm0(tool_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(param_path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayJsValueToWasm0(allowed_values, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.governance_allowParamValues(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
     /**
      * @param {string} name
      */
@@ -176,12 +115,62 @@ export class Governance {
         const ret = wasm.governance_evaluate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
-    constructor() {
-        const ret = wasm.governance_new();
+    /**
+     * @param {string} tool_name
+     * @param {string} param_path
+     * @param {number | null} [min]
+     * @param {number | null} [max]
+     */
+    limitParamRange(tool_name, param_path, min, max) {
+        const ptr0 = passStringToWasm0(tool_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(param_path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.governance_limitParamRange(this.__wbg_ptr, ptr0, len0, ptr1, len1, !isLikeNone(min), isLikeNone(min) ? 0 : min, !isLikeNone(max), isLikeNone(max) ? 0 : max);
+    }
+    /**
+     * @param {string | null} [default_action]
+     */
+    constructor(default_action) {
+        var ptr0 = isLikeNone(default_action) ? 0 : passStringToWasm0(default_action, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.governance_new(ptr0, len0);
         this.__wbg_ptr = ret;
         GovernanceFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @param {string} tool_name
+     * @param {string} param_path
+     */
+    requireParam(tool_name, param_path) {
+        const ptr0 = passStringToWasm0(tool_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(param_path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.governance_requireParam(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @param {string} agent_id
+     * @param {string} session_id
+     */
+    setIdentity(agent_id, session_id) {
+        const ptr0 = passStringToWasm0(agent_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(session_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.governance_setIdentity(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @param {string} tool_name
+     * @param {number} max_calls
+     * @param {number} window_ms
+     */
+    setRateLimit(tool_name, max_calls, window_ms) {
+        const ptr0 = passStringToWasm0(tool_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.governance_setRateLimit(this.__wbg_ptr, ptr0, len0, max_calls, window_ms);
+    }
     /**
      * @param {number} now_ms
      */
@@ -191,197 +180,119 @@ export class Governance {
 }
 if (Symbol.dispose) Governance.prototype[Symbol.dispose] = Governance.prototype.free;
 
-export class LoopStateMachine {
+export class KernelRuntime {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        LoopStateMachineFinalization.unregister(this);
+        KernelRuntimeFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_loopstatemachine_free(ptr, 0);
+        wasm.__wbg_kernelruntime_free(ptr, 0);
     }
     /**
-     * Pre-populate the history partition with a prior transcript message.
-     * Must be called before `start`.
-     * @param {Message} message
-     * @param {number} tokens
+     * @returns {Message[]}
      */
-    addHistoryMessage(message, tokens) {
+    drainNewMessages() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.loopstatemachine_addHistoryMessage(retptr, this.__wbg_ptr, addHeapObject(message), tokens);
+            wasm.kernelruntime_drainNewMessages(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Pre-populate the memory partition with a long-term memory snippet.
-     * Must be called before `start`. Use for seeding known context from past sessions.
-     * `tokens` is a caller-supplied estimate; pass at least 1.
-     * @param {string} content
-     * @param {number} tokens
+     * @returns {boolean}
      */
-    addMemoryMessage(content, tokens) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.loopstatemachine_addMemoryMessage(this.__wbg_ptr, ptr0, len0, tokens);
+    isTerminal() {
+        const ret = wasm.kernelruntime_isTerminal(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * Prepend a system-level instruction to the context. Must be called before `start`.
-     * `tokens` is a caller-supplied estimate (use `content.length / 4` if unsure).
-     * The renderer skips messages with `tokens == 0`, so always pass at least 1.
-     * @param {string} content
-     * @param {number} tokens
+     * @param {LoopPolicy} policy
      */
-    addSystemMessage(content, tokens) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.loopstatemachine_addSystemMessage(this.__wbg_ptr, ptr0, len0, tokens);
+    constructor(policy) {
+        const ret = wasm.kernelruntime_new(addHeapObject(policy));
+        this.__wbg_ptr = ret;
+        KernelRuntimeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * @param {Message} message
-     * @returns {LoopAction}
+     * @returns {string[]}
      */
-    feedLlmResponse(message) {
+    preservedRefs() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.loopstatemachine_feedLlmResponse(retptr, this.__wbg_ptr, addHeapObject(message));
+            wasm.kernelruntime_preservedRefs(retptr, this.__wbg_ptr);
             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);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * @returns {LoopAction}
-     */
-    feedTimeout() {
-        const ret = wasm.loopstatemachine_feedTimeout(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * @param {ToolResult[]} results
-     * @returns {LoopAction}
-     */
-    feedToolResults(results) {
-        const ptr0 = passArrayJsValueToWasm0(results, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.loopstatemachine_feedToolResults(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {boolean}
-     */
-    isTerminal() {
-        const ret = wasm.loopstatemachine_isTerminal(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @param {LoopPolicy} policy
-     */
-    constructor(policy) {
-        const ret = wasm.loopstatemachine_new(addHeapObject(policy));
-        this.__wbg_ptr = ret;
-        LoopStateMachineFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * @returns {number}
      */
-    pressure() {
-        const ret = wasm.loopstatemachine_pressure(this.__wbg_ptr);
-        return ret;
+    recoveryContentBytes() {
+        const ret = wasm.kernelruntime_recoveryContentBytes(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * @returns {RenderedContext}
      */
     render() {
-        const ret = wasm.loopstatemachine_render(this.__wbg_ptr);
+        const ret = wasm.kernelruntime_render(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * @param {SkillMetadata[]} skills
-     */
-    setAvailableSkills(skills) {
-        const ptr0 = passArrayJsValueToWasm0(skills, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.loopstatemachine_setAvailableSkills(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @param {boolean} enabled
-     */
-    setKnowledgeEnabled(enabled) {
-        wasm.loopstatemachine_setKnowledgeEnabled(this.__wbg_ptr, enabled);
-    }
-    /**
-     * @param {boolean} enabled
-     */
-    setMemoryEnabled(enabled) {
-        wasm.loopstatemachine_setMemoryEnabled(this.__wbg_ptr, enabled);
-    }
-    /**
-     * @param {ToolSchema[]} tools
+     * Feed a JSON-encoded KernelInput and return a JSON-encoded KernelStep.
+     * @param {string} input_json
+     * @returns {string}
      */
-    setTools(tools) {
+    step(input_json) {
+        let deferred3_0;
+        let deferred3_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayJsValueToWasm0(tools, wasm.__wbindgen_export);
+            const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.loopstatemachine_setTools(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.kernelruntime_step(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
             }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * @param {RuntimeTask} task
-     * @returns {LoopAction}
-     */
-    start(task) {
-        const ret = wasm.loopstatemachine_start(this.__wbg_ptr, addHeapObject(task));
-        return takeObject(ret);
-    }
-    /**
-     * @returns {LoopObservation[]}
-     */
-    takeObservations() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.loopstatemachine_takeObservations(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 4, 4);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
         }
     }
     /**
      * @returns {number}
      */
-    get turn() {
-        const ret = wasm.loopstatemachine_turn(this.__wbg_ptr);
+    turn() {
+        const ret = wasm.kernelruntime_turn(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) LoopStateMachine.prototype[Symbol.dispose] = LoopStateMachine.prototype.free;
+if (Symbol.dispose) KernelRuntime.prototype[Symbol.dispose] = KernelRuntime.prototype.free;
 
 export class SignalRouter {
     __destroy_into_raw() {
@@ -476,10 +387,6 @@ export function __wbg___wbindgen_in_07056af4f902c445(arg0, arg1) {
     const ret = getObject(arg0) in getObject(arg1);
     return ret;
 }
-export function __wbg___wbindgen_is_function_5cd60d5cf78b4eef(arg0) {
-    const ret = typeof(getObject(arg0)) === 'function';
-    return ret;
-}
 export function __wbg___wbindgen_is_object_b4593df85baada48(arg0) {
     const val = getObject(arg0);
     const ret = typeof(val) === 'object' && val !== null;
@@ -510,25 +417,9 @@ export function __wbg___wbindgen_string_get_d109740c0d18f4d7(arg0, arg1) {
 export function __wbg___wbindgen_throw_9c31b086c2b26051(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_call_13665d9f14390edc() { return handleError(function (arg0, arg1) {
-    const ret = getObject(arg0).call(getObject(arg1));
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_done_54b8da57023b7ed2(arg0) {
-    const ret = getObject(arg0).done;
-    return ret;
-}
 export function __wbg_getRandomValues_ef12552bf5acd2fe() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
-export function __wbg_get_3e9a707ab7d352eb() { return handleError(function (arg0, arg1) {
-    const ret = Reflect.get(getObject(arg0), getObject(arg1));
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_get_unchecked_1dfe6d05ad91d9b7(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
-    return addHeapObject(ret);
-}
 export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
     const ret = getObject(arg0)[getObject(arg1)];
     return addHeapObject(ret);
@@ -553,22 +444,10 @@ export function __wbg_instanceof_Uint8Array_abd07d4bd221d50b(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_isArray_94898ed3aad6947b(arg0) {
-    const ret = Array.isArray(getObject(arg0));
-    return ret;
-}
 export function __wbg_isSafeInteger_01e964d144ad3a55(arg0) {
     const ret = Number.isSafeInteger(getObject(arg0));
     return ret;
 }
-export function __wbg_iterator_1441b47f341dc34f() {
-    const ret = Symbol.iterator;
-    return addHeapObject(ret);
-}
-export function __wbg_length_2591a0f4f659a55c(arg0) {
-    const ret = getObject(arg0).length;
-    return ret;
-}
 export function __wbg_length_56fcd3e2b7e0299d(arg0) {
     const ret = getObject(arg0).length;
     return ret;
@@ -585,14 +464,6 @@ export function __wbg_new_7ddec6de44ff8f5d(arg0) {
     const ret = new Uint8Array(getObject(arg0));
     return addHeapObject(ret);
 }
-export function __wbg_next_2a4e19f4f5083b0f(arg0) {
-    const ret = getObject(arg0).next;
-    return addHeapObject(ret);
-}
-export function __wbg_next_6429a146bf756f93() { return handleError(function (arg0) {
-    const ret = getObject(arg0).next();
-    return addHeapObject(ret);
-}, arguments); }
 export function __wbg_prototypesetcall_5f9bdc8d75e07276(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 }
@@ -602,10 +473,6 @@ export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
 export function __wbg_set_78ea6a19f4818587(arg0, arg1, arg2) {
     getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
 }
-export function __wbg_value_9cc0518af87a489c(arg0) {
-    const ret = getObject(arg0).value;
-    return addHeapObject(ret);
-}
 export function __wbindgen_cast_0000000000000001(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
@@ -623,18 +490,15 @@ export function __wbindgen_object_clone_ref(arg0) {
 export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 }
-const ContextEngineFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_contextengine_free(ptr, 1));
 const EvalPipelineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_evalpipeline_free(ptr, 1));
 const GovernanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_governance_free(ptr, 1));
-const LoopStateMachineFinalization = (typeof FinalizationRegistry === 'undefined')
+const KernelRuntimeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_loopstatemachine_free(ptr, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_kernelruntime_free(ptr, 1));
 const SignalRouterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signalrouter_free(ptr, 1));

package/package.json

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