entroly-wasm 1.0.78 → 1.0.80

package/pkg/entroly_wasm.js

@@ -1,5 +1,176 @@
 /* @ts-self-types="./entroly_wasm.d.ts" */
 
+class WasmCognitiveBus {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCognitiveBusFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcognitivebus_free(ptr, 0);
+    }
+    /**
+     * Full event shape: `id`, `source_agent`, `event_type`, `content`,
+     * `timestamp`, `emotional_tag`, `salience`, `is_spike`.
+     * @param {string} agent_id
+     * @param {number | null} [limit]
+     * @returns {string}
+     */
+    drainJSON(agent_id, limit) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmcognitivebus_drainJSON(this.__wbg_ptr, ptr0, len0, isLikeNone(limit) ? 0x100000001 : (limit) >>> 0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Hippocampus bridge shape: `content`, `source`, `salience`,
+     * `emotional_tag`, `event_type`. Deliberately narrower than `drainJSON`.
+     * @returns {string}
+     */
+    drainMemoryBridgeJSON() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmcognitivebus_drainMemoryBridgeJSON(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * `memorySalienceThreshold` matches the PyO3 default of 50.0.
+     * @param {number | null} [memory_salience_threshold]
+     */
+    constructor(memory_salience_threshold) {
+        const ret = wasm.wasmcognitivebus_new(!isLikeNone(memory_salience_threshold), isLikeNone(memory_salience_threshold) ? 0 : memory_salience_threshold);
+        this.__wbg_ptr = ret >>> 0;
+        WasmCognitiveBusFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the number of subscribers the event was routed to, exactly as
+     * the PyO3 `publish` does.
+     * @param {string} source_agent
+     * @param {string} event_type
+     * @param {string} content
+     * @param {number | null} [emotional_tag]
+     * @param {number | null} [salience]
+     * @returns {number}
+     */
+    publish(source_agent, event_type, content, emotional_tag, salience) {
+        const ptr0 = passStringToWasm0(source_agent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(event_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmcognitivebus_publish(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(emotional_tag) ? 0xFFFFFF : emotional_tag, !isLikeNone(salience), isLikeNone(salience) ? 0 : salience);
+        return ret >>> 0;
+    }
+    /**
+     * @param {string} agent_id
+     * @returns {number}
+     */
+    queueDepth(agent_id) {
+        const ptr0 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmcognitivebus_queueDepth(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @param {string} agent_id
+     * @param {string} task_text
+     */
+    setTaskContext(agent_id, task_text) {
+        const ptr0 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(task_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmcognitivebus_setTaskContext(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @param {number} tick
+     */
+    setTick(tick) {
+        wasm.wasmcognitivebus_setTick(this.__wbg_ptr, tick);
+    }
+    /**
+     * @returns {string}
+     */
+    statsJSON() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmcognitivebus_statsJSON(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * `eventTypesJSON` is a JSON array of event-type strings. Passing them as
+     * JSON rather than a `Box<[JsString]>` keeps one decoding path shared with
+     * every other binding here.
+     * @param {string} agent_id
+     * @param {string} event_types_json
+     */
+    subscribe(agent_id, event_types_json) {
+        const ptr0 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(event_types_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmcognitivebus_subscribe(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    tick() {
+        wasm.wasmcognitivebus_tick(this.__wbg_ptr);
+    }
+    /**
+     * @param {string} agent_id
+     */
+    unsubscribe(agent_id) {
+        const ptr0 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmcognitivebus_unsubscribe(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) WasmCognitiveBus.prototype[Symbol.dispose] = WasmCognitiveBus.prototype.free;
+exports.WasmCognitiveBus = WasmCognitiveBus;
+
 class WasmEntrolyEngine {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -436,6 +607,723 @@ class WasmEntrolyEngine {
 if (Symbol.dispose) WasmEntrolyEngine.prototype[Symbol.dispose] = WasmEntrolyEngine.prototype.free;
 exports.WasmEntrolyEngine = WasmEntrolyEngine;
 
+class WasmNkbeAllocator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmNkbeAllocatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmnkbeallocator_free(ptr, 0);
+    }
+    /**
+     * Returns false when the agent is unknown, matching PyO3.
+     * @param {string} agent_name
+     * @param {string} fragment_id
+     * @param {number} relevance
+     * @param {number} token_cost
+     * @returns {boolean}
+     */
+    addFragment(agent_name, fragment_id, relevance, token_cost) {
+        const ptr0 = passStringToWasm0(agent_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(fragment_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmnkbeallocator_addFragment(this.__wbg_ptr, ptr0, len0, ptr1, len1, relevance, token_cost);
+        return ret !== 0;
+    }
+    /**
+     * `{agent_name: {budget, weight, utility}}`, as the engine builds it.
+     * @returns {string}
+     */
+    allocateJSON() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmnkbeallocator_allocateJSON(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Defaults mirror the PyO3 constructor exactly: 128000 / 0.1 / 1e-4 / 30 /
+     * 5 / 0.01. Divergent defaults would be a parity break that no test on
+     * either side would notice.
+     * @param {number | null} [global_budget]
+     * @param {number | null} [tau]
+     * @param {number | null} [epsilon]
+     * @param {number | null} [max_iter]
+     * @param {number | null} [nash_iterations]
+     * @param {number | null} [learning_rate]
+     */
+    constructor(global_budget, tau, epsilon, max_iter, nash_iterations, learning_rate) {
+        const ret = wasm.wasmnkbeallocator_new(isLikeNone(global_budget) ? 0x100000001 : (global_budget) >>> 0, !isLikeNone(tau), isLikeNone(tau) ? 0 : tau, !isLikeNone(epsilon), isLikeNone(epsilon) ? 0 : epsilon, isLikeNone(max_iter) ? 0x100000001 : (max_iter) >>> 0, isLikeNone(nash_iterations) ? 0x100000001 : (nash_iterations) >>> 0, !isLikeNone(learning_rate), isLikeNone(learning_rate) ? 0 : learning_rate);
+        this.__wbg_ptr = ret >>> 0;
+        WasmNkbeAllocatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} name
+     * @param {number} weight
+     * @param {number} min_budget
+     */
+    registerAgent(name, weight, min_budget) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmnkbeallocator_registerAgent(this.__wbg_ptr, ptr0, len0, weight, min_budget);
+    }
+    /**
+     * @param {string} outcomes_json
+     * @returns {boolean}
+     */
+    reinforce(outcomes_json) {
+        const ptr0 = passStringToWasm0(outcomes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmnkbeallocator_reinforce(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    statsJSON() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmnkbeallocator_statsJSON(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmNkbeAllocator.prototype[Symbol.dispose] = WasmNkbeAllocator.prototype.free;
+exports.WasmNkbeAllocator = WasmNkbeAllocator;
+
+class WasmTrustEngine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmTrustEngineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtrustengine_free(ptr, 0);
+    }
+    /**
+     * @param {string} evidence
+     * @param {string} claim
+     * @returns {string}
+     */
+    assessClaimJSON(evidence, claim) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(evidence, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(claim, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmtrustengine_assessClaimJSON(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} path
+     * @returns {string}
+     */
+    fileCriticality(path) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmtrustengine_fileCriticality(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} content
+     * @returns {boolean}
+     */
+    hasSafetySignal(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtrustengine_hasSafetySignal(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} profile
+     */
+    constructor(profile) {
+        const ptr0 = passStringToWasm0(profile, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtrustengine_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmTrustEngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmTrustEngine.prototype[Symbol.dispose] = WasmTrustEngine.prototype.free;
+exports.WasmTrustEngine = WasmTrustEngine;
+
+class WasmWorkGraph {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmWorkGraph.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmWorkGraphFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmWorkGraphFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmworkgraph_free(ptr, 0);
+    }
+    /**
+     * @param {string} json_text
+     * @returns {string}
+     */
+    applyEventJSON(json_text) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(json_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_applyEventJSON(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string | null | undefined} workstream_id
+     * @param {number} max_evidence
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    contextScopeJSON(workstream_id, max_evidence, pretty) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(workstream_id) ? 0 : passStringToWasm0(workstream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_contextScopeJSON(this.__wbg_ptr, ptr0, len0, max_evidence, pretty);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} handoff_json
+     * @param {string} manifest_json
+     * @returns {string}
+     */
+    continuationProofJSON(handoff_json, manifest_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(handoff_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(manifest_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_continuationProofJSON(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {number} now_ms
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    coordinationJSON(now_ms, pretty) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmworkgraph_coordinationJSON(this.__wbg_ptr, now_ms, pretty);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get eventCount() {
+        const ret = wasm.wasmworkgraph_eventCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    exportJSON(pretty) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmworkgraph_exportJSON(this.__wbg_ptr, pretty);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} json_text
+     * @returns {WasmWorkGraph}
+     */
+    static fromJSON(json_text) {
+        const ptr0 = passStringToWasm0(json_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkgraph_fromJSON(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmWorkGraph.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get graphCommitment() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmworkgraph_graphCommitment(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} workstream_id
+     * @param {string} from_agent
+     * @param {string} to_agent
+     * @param {number} generated_at_ms
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    handoffJSON(workstream_id, from_agent, to_agent, generated_at_ms, pretty) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(workstream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(from_agent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(to_agent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_handoffJSON(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, generated_at_ms, pretty);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} json_text
+     * @returns {number}
+     */
+    mergeJSON(json_text) {
+        const ptr0 = passStringToWasm0(json_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkgraph_mergeJSON(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {string} repo_id
+     */
+    constructor(repo_id) {
+        const ptr0 = passStringToWasm0(repo_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkgraph_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmWorkGraphFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} json_text
+     * @returns {string}
+     */
+    observeRepositoryJSON(json_text) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(json_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_observeRepositoryJSON(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} workstream_id
+     * @param {string} to_agent
+     * @param {string} manifest_json
+     * @returns {string}
+     */
+    reconstructedContinuationProofJSON(workstream_id, to_agent, manifest_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(workstream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(to_agent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(manifest_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_reconstructedContinuationProofJSON(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} receipt_json
+     * @param {string} agent_id
+     * @param {string} session_id
+     * @returns {string}
+     */
+    recordContextReceiptJSON(receipt_json, agent_id, session_id) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(receipt_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_recordContextReceiptJSON(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} route_json
+     * @param {string} outcome_json
+     * @param {string} verification_json
+     * @param {string | null} [invalidated_commitments_json]
+     * @returns {string}
+     */
+    recordExecutionChainJSON(route_json, outcome_json, verification_json, invalidated_commitments_json) {
+        let deferred6_0;
+        let deferred6_1;
+        try {
+            const ptr0 = passStringToWasm0(route_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(verification_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(invalidated_commitments_json) ? 0 : passStringToWasm0(invalidated_commitments_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len3 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_recordExecutionChainJSON(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var ptr5 = ret[0];
+            var len5 = ret[1];
+            if (ret[3]) {
+                ptr5 = 0; len5 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred6_0 = ptr5;
+            deferred6_1 = len5;
+            return getStringFromWasm0(ptr5, len5);
+        } finally {
+            wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+        }
+    }
+    /**
+     * @param {string} memory_json
+     * @param {number} now_ms
+     * @param {string | null} [superseded_ids_json]
+     * @returns {string}
+     */
+    recordMemoryJSON(memory_json, now_ms, superseded_ids_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(memory_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(superseded_ids_json) ? 0 : passStringToWasm0(superseded_ids_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_recordMemoryJSON(this.__wbg_ptr, ptr0, len0, now_ms, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get repoId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmworkgraph_repoId(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string | null | undefined} workstream_id
+     * @param {number} max_evidence
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    resumeJSON(workstream_id, max_evidence, pretty) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(workstream_id) ? 0 : passStringToWasm0(workstream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkgraph_resumeJSON(this.__wbg_ptr, ptr0, len0, max_evidence, pretty);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @returns {bigint}
+     */
+    get revision() {
+        const ret = wasm.wasmworkgraph_revision(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    snapshotJSON(pretty) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmworkgraph_snapshotJSON(this.__wbg_ptr, pretty);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    summaryJSON() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmworkgraph_summaryJSON(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    unfinishedJSON(pretty) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmworkgraph_unfinishedJSON(this.__wbg_ptr, pretty);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} receipt_json
+     * @returns {boolean}
+     */
+    static verifyHandoffIntegrityJSON(receipt_json) {
+        const ptr0 = passStringToWasm0(receipt_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkgraph_verifyHandoffIntegrityJSON(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {string} receipt_json
+     * @returns {boolean}
+     */
+    verifyHandoffJSON(receipt_json) {
+        const ptr0 = passStringToWasm0(receipt_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkgraph_verifyHandoffJSON(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+}
+if (Symbol.dispose) WasmWorkGraph.prototype[Symbol.dispose] = WasmWorkGraph.prototype.free;
+exports.WasmWorkGraph = WasmWorkGraph;
+
 /**
  * @param {string} query
  * @returns {string}
@@ -474,8 +1362,369 @@ function classify_query_transition(prev_hash, current_query, elapsed_s, time_win
 exports.classify_query_transition = classify_query_transition;
 
 /**
- * @param {string} episodes_json
- * @returns {any}
+ * Build a canonical receipt envelope and return it as canonical JSON.
+ *
+ * Reference lists arrive as JSON arrays rather than `Box<[JsString]>` so there
+ * is one decoding path shared with the other bindings here, and so an empty
+ * list is expressed the same way in both runtimes.
+ * @param {string} repository_id
+ * @param {string} repository_commitment
+ * @param {string} graph_commitment
+ * @param {string} work_scope_id
+ * @param {string | null} [source_commitment]
+ * @param {string | null} [selected_refs_json]
+ * @param {string | null} [omitted_refs_json]
+ * @param {string | null} [pinned_refs_json]
+ * @param {string | null} [recoverable_refs_json]
+ * @param {string | null} [recovery_handles_json]
+ * @param {string | null} [evidence_ids_json]
+ * @param {number | null} [budget_tokens]
+ * @param {string | null} [selection_policy]
+ * @param {string | null} [execution_id]
+ * @param {number | null} [created_at_ms]
+ * @returns {string}
+ */
+function contextReceiptBuildJSON(repository_id, repository_commitment, graph_commitment, work_scope_id, source_commitment, selected_refs_json, omitted_refs_json, pinned_refs_json, recoverable_refs_json, recovery_handles_json, evidence_ids_json, budget_tokens, selection_policy, execution_id, created_at_ms) {
+    let deferred15_0;
+    let deferred15_1;
+    try {
+        const ptr0 = passStringToWasm0(repository_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(repository_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(graph_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(work_scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        var ptr4 = isLikeNone(source_commitment) ? 0 : passStringToWasm0(source_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = isLikeNone(selected_refs_json) ? 0 : passStringToWasm0(selected_refs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len5 = WASM_VECTOR_LEN;
+        var ptr6 = isLikeNone(omitted_refs_json) ? 0 : passStringToWasm0(omitted_refs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len6 = WASM_VECTOR_LEN;
+        var ptr7 = isLikeNone(pinned_refs_json) ? 0 : passStringToWasm0(pinned_refs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len7 = WASM_VECTOR_LEN;
+        var ptr8 = isLikeNone(recoverable_refs_json) ? 0 : passStringToWasm0(recoverable_refs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len8 = WASM_VECTOR_LEN;
+        var ptr9 = isLikeNone(recovery_handles_json) ? 0 : passStringToWasm0(recovery_handles_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len9 = WASM_VECTOR_LEN;
+        var ptr10 = isLikeNone(evidence_ids_json) ? 0 : passStringToWasm0(evidence_ids_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len10 = WASM_VECTOR_LEN;
+        var ptr11 = isLikeNone(selection_policy) ? 0 : passStringToWasm0(selection_policy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len11 = WASM_VECTOR_LEN;
+        var ptr12 = isLikeNone(execution_id) ? 0 : passStringToWasm0(execution_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len12 = WASM_VECTOR_LEN;
+        const ret = wasm.contextReceiptBuildJSON(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, isLikeNone(budget_tokens) ? 0x100000001 : (budget_tokens) >>> 0, ptr11, len11, ptr12, len12, !isLikeNone(created_at_ms), isLikeNone(created_at_ms) ? 0 : created_at_ms);
+        var ptr14 = ret[0];
+        var len14 = ret[1];
+        if (ret[3]) {
+            ptr14 = 0; len14 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred15_0 = ptr14;
+        deferred15_1 = len14;
+        return getStringFromWasm0(ptr14, len14);
+    } finally {
+        wasm.__wbindgen_free(deferred15_0, deferred15_1, 1);
+    }
+}
+exports.contextReceiptBuildJSON = contextReceiptBuildJSON;
+
+/**
+ * The commitment carried by a verified envelope.
+ * @param {string} receipt_json
+ * @returns {string}
+ */
+function contextReceiptCommitment(receipt_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(receipt_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.contextReceiptCommitment(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.contextReceiptCommitment = contextReceiptCommitment;
+
+/**
+ * Project a verified envelope into the Work Graph reference form, as JSON.
+ * @param {string} receipt_json
+ * @param {string} workstream_id
+ * @param {string} agent_id
+ * @param {string} session_id
+ * @returns {string}
+ */
+function contextReceiptGraphRefJSON(receipt_json, workstream_id, agent_id, session_id) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(receipt_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(workstream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.contextReceiptGraphRefJSON(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var ptr5 = ret[0];
+        var len5 = ret[1];
+        if (ret[3]) {
+            ptr5 = 0; len5 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
+    } finally {
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    }
+}
+exports.contextReceiptGraphRefJSON = contextReceiptGraphRefJSON;
+
+/**
+ * Schema version this build implements.
+ * @returns {number}
+ */
+function contextReceiptSchemaVersion() {
+    const ret = wasm.contextReceiptSchemaVersion();
+    return ret >>> 0;
+}
+exports.contextReceiptSchemaVersion = contextReceiptSchemaVersion;
+
+/**
+ * Parse and verify an envelope, returning its canonical JSON.
+ *
+ * Fails closed on a commitment that does not recompute and on an unrecognised
+ * schema version — a caller cannot obtain an unverified envelope here.
+ * @param {string} receipt_json
+ * @returns {string}
+ */
+function contextReceiptVerifyJSON(receipt_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(receipt_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.contextReceiptVerifyJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.contextReceiptVerifyJSON = contextReceiptVerifyJSON;
+
+/**
+ * May this memory be injected, and why.
+ *
+ * No score parameter, by design — section 10's "do not let similarity score
+ * imply truth" is enforced by the signature in both runtimes alike.
+ * @param {string} record_json
+ * @param {number} now_ms
+ * @param {string | null} [superseded_ids_json]
+ * @returns {string}
+ */
+function memoryRecordAdmissibility(record_json, now_ms, superseded_ids_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(record_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(superseded_ids_json) ? 0 : passStringToWasm0(superseded_ids_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.memoryRecordAdmissibility(ptr0, len0, now_ms, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.memoryRecordAdmissibility = memoryRecordAdmissibility;
+
+/**
+ * Build a memory record and return it as canonical JSON.
+ * @param {string} repository_id
+ * @param {string} content_reference
+ * @param {string} trust_state
+ * @param {string | null} [task_id]
+ * @param {string | null} [workstream_id]
+ * @param {string | null} [source_agent]
+ * @param {string | null} [source_session]
+ * @param {string | null} [source_execution]
+ * @param {string | null} [content_commitment]
+ * @param {string | null} [evidence_ids_json]
+ * @param {number | null} [created_at_ms]
+ * @param {number | null} [observed_at_ms]
+ * @param {number | null} [valid_until_ms]
+ * @param {string | null} [supersedes_json]
+ * @param {string | null} [contradicted_by_json]
+ * @param {string | null} [recovery_handle]
+ * @returns {string}
+ */
+function memoryRecordBuildJSON(repository_id, content_reference, trust_state, task_id, workstream_id, source_agent, source_session, source_execution, content_commitment, evidence_ids_json, created_at_ms, observed_at_ms, valid_until_ms, supersedes_json, contradicted_by_json, recovery_handle) {
+    let deferred15_0;
+    let deferred15_1;
+    try {
+        const ptr0 = passStringToWasm0(repository_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(content_reference, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(trust_state, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(task_id) ? 0 : passStringToWasm0(task_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = isLikeNone(workstream_id) ? 0 : passStringToWasm0(workstream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = isLikeNone(source_agent) ? 0 : passStringToWasm0(source_agent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len5 = WASM_VECTOR_LEN;
+        var ptr6 = isLikeNone(source_session) ? 0 : passStringToWasm0(source_session, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len6 = WASM_VECTOR_LEN;
+        var ptr7 = isLikeNone(source_execution) ? 0 : passStringToWasm0(source_execution, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len7 = WASM_VECTOR_LEN;
+        var ptr8 = isLikeNone(content_commitment) ? 0 : passStringToWasm0(content_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len8 = WASM_VECTOR_LEN;
+        var ptr9 = isLikeNone(evidence_ids_json) ? 0 : passStringToWasm0(evidence_ids_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len9 = WASM_VECTOR_LEN;
+        var ptr10 = isLikeNone(supersedes_json) ? 0 : passStringToWasm0(supersedes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len10 = WASM_VECTOR_LEN;
+        var ptr11 = isLikeNone(contradicted_by_json) ? 0 : passStringToWasm0(contradicted_by_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len11 = WASM_VECTOR_LEN;
+        var ptr12 = isLikeNone(recovery_handle) ? 0 : passStringToWasm0(recovery_handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len12 = WASM_VECTOR_LEN;
+        const ret = wasm.memoryRecordBuildJSON(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, !isLikeNone(created_at_ms), isLikeNone(created_at_ms) ? 0 : created_at_ms, !isLikeNone(observed_at_ms), isLikeNone(observed_at_ms) ? 0 : observed_at_ms, !isLikeNone(valid_until_ms), isLikeNone(valid_until_ms) ? 0 : valid_until_ms, ptr10, len10, ptr11, len11, ptr12, len12);
+        var ptr14 = ret[0];
+        var len14 = ret[1];
+        if (ret[3]) {
+            ptr14 = 0; len14 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred15_0 = ptr14;
+        deferred15_1 = len14;
+        return getStringFromWasm0(ptr14, len14);
+    } finally {
+        wasm.__wbindgen_free(deferred15_0, deferred15_1, 1);
+    }
+}
+exports.memoryRecordBuildJSON = memoryRecordBuildJSON;
+
+/**
+ * Schema version this build implements for memory records.
+ * @returns {number}
+ */
+function memoryRecordSchemaVersion() {
+    const ret = wasm.memoryRecordSchemaVersion();
+    return ret >>> 0;
+}
+exports.memoryRecordSchemaVersion = memoryRecordSchemaVersion;
+
+/**
+ * Parse and check a memory record, returning its canonical JSON.
+ * @param {string} record_json
+ * @returns {string}
+ */
+function memoryRecordVerifyJSON(record_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(record_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.memoryRecordVerifyJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.memoryRecordVerifyJSON = memoryRecordVerifyJSON;
+
+/**
+ * @param {string} input_json
+ * @returns {string}
+ */
+function modelExecutionOutcomeBuildJSON(input_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.modelExecutionOutcomeBuildJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.modelExecutionOutcomeBuildJSON = modelExecutionOutcomeBuildJSON;
+
+/**
+ * @param {string} value_json
+ * @returns {string}
+ */
+function modelExecutionOutcomeVerifyJSON(value_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(value_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.modelExecutionOutcomeVerifyJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.modelExecutionOutcomeVerifyJSON = modelExecutionOutcomeVerifyJSON;
+
+/**
+ * @param {string} episodes_json
+ * @returns {any}
  */
 function optimize_task_profiles(episodes_json) {
     const ptr0 = passStringToWasm0(episodes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -567,6 +1816,128 @@ function qccr_select(fragments_json, token_budget, query, overrides_json, prefer
 }
 exports.qccr_select = qccr_select;
 
+/**
+ * Build a recovery handle and return it as canonical JSON.
+ *
+ * Throws when a disposition promises recovery without the means to honour it.
+ * @param {string} repository_id
+ * @param {string} receipt_id
+ * @param {string} disposition
+ * @param {string | null} [source_ref]
+ * @param {string | null} [source_commitment]
+ * @param {string | null} [fragment_commitment]
+ * @param {number | null} [byte_start]
+ * @param {number | null} [byte_end]
+ * @param {string | null} [version]
+ * @param {string | null} [storage_locator]
+ * @param {number | null} [observed_at_ms]
+ * @returns {string}
+ */
+function recoveryHandleBuildJSON(repository_id, receipt_id, disposition, source_ref, source_commitment, fragment_commitment, byte_start, byte_end, version, storage_locator, observed_at_ms) {
+    let deferred10_0;
+    let deferred10_1;
+    try {
+        const ptr0 = passStringToWasm0(repository_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(receipt_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(disposition, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(source_ref) ? 0 : passStringToWasm0(source_ref, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = isLikeNone(source_commitment) ? 0 : passStringToWasm0(source_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = isLikeNone(fragment_commitment) ? 0 : passStringToWasm0(fragment_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len5 = WASM_VECTOR_LEN;
+        var ptr6 = isLikeNone(version) ? 0 : passStringToWasm0(version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len6 = WASM_VECTOR_LEN;
+        var ptr7 = isLikeNone(storage_locator) ? 0 : passStringToWasm0(storage_locator, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len7 = WASM_VECTOR_LEN;
+        const ret = wasm.recoveryHandleBuildJSON(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, !isLikeNone(byte_start), isLikeNone(byte_start) ? 0 : byte_start, !isLikeNone(byte_end), isLikeNone(byte_end) ? 0 : byte_end, ptr6, len6, ptr7, len7, !isLikeNone(observed_at_ms), isLikeNone(observed_at_ms) ? 0 : observed_at_ms);
+        var ptr9 = ret[0];
+        var len9 = ret[1];
+        if (ret[3]) {
+            ptr9 = 0; len9 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred10_0 = ptr9;
+        deferred10_1 = len9;
+        return getStringFromWasm0(ptr9, len9);
+    } finally {
+        wasm.__wbindgen_free(deferred10_0, deferred10_1, 1);
+    }
+}
+exports.recoveryHandleBuildJSON = recoveryHandleBuildJSON;
+
+/**
+ * Schema version this build implements for recovery handles.
+ * @returns {number}
+ */
+function recoveryHandleSchemaVersion() {
+    const ret = wasm.recoveryHandleSchemaVersion();
+    return ret >>> 0;
+}
+exports.recoveryHandleSchemaVersion = recoveryHandleSchemaVersion;
+
+/**
+ * Check recovered bytes against the handle's commitment.
+ *
+ * Returns `verified`, `commitment_mismatch` or `not_recoverable`.
+ * @param {string} handle_json
+ * @param {Uint8Array} payload
+ * @returns {string}
+ */
+function recoveryHandleVerifyBytes(handle_json, payload) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(handle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.recoveryHandleVerifyBytes(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.recoveryHandleVerifyBytes = recoveryHandleVerifyBytes;
+
+/**
+ * Parse and check a handle, returning its canonical JSON.
+ * @param {string} handle_json
+ * @returns {string}
+ */
+function recoveryHandleVerifyJSON(handle_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(handle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.recoveryHandleVerifyJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.recoveryHandleVerifyJSON = recoveryHandleVerifyJSON;
+
 /**
  * @param {string} episodes_json
  * @param {string} current_weights_json
@@ -585,6 +1956,324 @@ function reward_weighted_optimize(episodes_json, current_weights_json) {
 }
 exports.reward_weighted_optimize = reward_weighted_optimize;
 
+/**
+ * @param {string} input_json
+ * @returns {string}
+ */
+function routingDecisionBuildJSON(input_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.routingDecisionBuildJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.routingDecisionBuildJSON = routingDecisionBuildJSON;
+
+/**
+ * @param {string} value_json
+ * @returns {string}
+ */
+function routingDecisionVerifyJSON(value_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(value_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.routingDecisionVerifyJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.routingDecisionVerifyJSON = routingDecisionVerifyJSON;
+
+/**
+ * @param {string} input_json
+ * @returns {string}
+ */
+function verificationRecordBuildJSON(input_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.verificationRecordBuildJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.verificationRecordBuildJSON = verificationRecordBuildJSON;
+
+/**
+ * @param {string} value_json
+ * @param {string} current_repository_commitment
+ * @param {number} now_ms
+ * @param {string | null} [invalidated_commitments_json]
+ * @returns {string}
+ */
+function verificationRecordFreshness(value_json, current_repository_commitment, now_ms, invalidated_commitments_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(value_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(current_repository_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(invalidated_commitments_json) ? 0 : passStringToWasm0(invalidated_commitments_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.verificationRecordFreshness(ptr0, len0, ptr1, len1, now_ms, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+exports.verificationRecordFreshness = verificationRecordFreshness;
+
+/**
+ * @param {string} value_json
+ * @returns {string}
+ */
+function verificationRecordVerifyJSON(value_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(value_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.verificationRecordVerifyJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.verificationRecordVerifyJSON = verificationRecordVerifyJSON;
+
+/**
+ * @param {Uint8Array} payload
+ * @param {string} expected_commitment
+ * @returns {string}
+ */
+function verifiedContextSnapshotVerifyBytes(payload, expected_commitment) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(expected_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.verifiedContextSnapshotVerifyBytes(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.verifiedContextSnapshotVerifyBytes = verifiedContextSnapshotVerifyBytes;
+
+/**
+ * @param {string} input_json
+ * @returns {string}
+ */
+function workContinuationProofBuildJSON(input_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workContinuationProofBuildJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.workContinuationProofBuildJSON = workContinuationProofBuildJSON;
+
+/**
+ * @param {string} value_json
+ * @param {string} repository_id
+ * @param {number} graph_revision
+ * @param {string} graph_commitment
+ * @returns {string}
+ */
+function workContinuationProofState(value_json, repository_id, graph_revision, graph_commitment) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(value_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(repository_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(graph_commitment, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.workContinuationProofState(ptr0, len0, ptr1, len1, graph_revision, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+exports.workContinuationProofState = workContinuationProofState;
+
+/**
+ * @param {string} value_json
+ * @returns {string}
+ */
+function workContinuationProofVerifyJSON(value_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(value_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workContinuationProofVerifyJSON(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.workContinuationProofVerifyJSON = workContinuationProofVerifyJSON;
+
+/**
+ * Canonical edge identity. See `workGraphNodeId`.
+ * @param {string} from
+ * @param {string} kind
+ * @param {string} to
+ * @returns {string}
+ */
+function workGraphEdgeId(from, kind, to) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(to, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.workGraphEdgeId(ptr0, len0, ptr1, len1, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+exports.workGraphEdgeId = workGraphEdgeId;
+
+/**
+ * Canonical node identity, so Node addresses artifacts exactly as Python and
+ * the graph itself do. Same engine function behind all three.
+ * @param {string} kind
+ * @param {string} repo_id
+ * @param {string} key
+ * @returns {string}
+ */
+function workGraphNodeId(kind, repo_id, key) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(repo_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.workGraphNodeId(ptr0, len0, ptr1, len1, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+exports.workGraphNodeId = workGraphNodeId;
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -624,9 +2313,21 @@ function __wbg_get_imports() {
     };
 }
 
+const WasmCognitiveBusFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcognitivebus_free(ptr >>> 0, 1));
 const WasmEntrolyEngineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmentrolyengine_free(ptr >>> 0, 1));
+const WasmNkbeAllocatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnkbeallocator_free(ptr >>> 0, 1));
+const WasmTrustEngineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtrustengine_free(ptr >>> 0, 1));
+const WasmWorkGraphFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmworkgraph_free(ptr >>> 0, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -668,6 +2369,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {