dag-ml-wasm 0.2.7 → 0.3.0

package/README.md

@@ -2,9 +2,9 @@
 
 Browser-friendly bindings for DAG-ML JSON contracts.
 
-The WASM package exposes validation, DSL compilation and execution-plan
-construction over UTF-8 JSON strings. It intentionally excludes host controller
-execution, artifacts and data-buffer ownership.
+The WASM package exposes validation, DSL compilation, execution-plan
+construction and synchronous host-controller execution over UTF-8 JSON strings.
+Artifacts and data-buffer ownership remain outside the binding.
 
 `contract_manifest_json()` returns a stable JSON manifest with the package
 version, supported contract ids, exported Python/WASM function names and shared
@@ -27,7 +27,9 @@ node scripts/smoke_wasm_web_bindings.mjs "$web_out_dir"
 
 ```js
 import init, {
+  LocalImplementationRegistry,
   contract_manifest_json,
+  loss_execution_attestation_json,
   validate_pipeline_dsl_json,
   compile_pipeline_dsl_artifact_json,
 } from "./pkg/dag_ml_wasm.js";
@@ -38,6 +40,84 @@ validate_pipeline_dsl_json(JSON.stringify(dsl));
 const artifact = JSON.parse(compile_pipeline_dsl_artifact_json(JSON.stringify(dsl)));
 ```
 
+Local JavaScript losses and metrics are retained by a WASM registry and never
+serialized into DAG-ML contracts:
+
+```js
+const implementations = new LocalImplementationRegistry();
+implementations.register_loss(JSON.stringify(lossReference), weightedLoss);
+
+const loss = implementations.resolve_training_loss(
+  JSON.stringify(trainingLossRole),
+  "FIT_CV",
+);
+const value = loss(target, prediction);
+const attestation = JSON.parse(
+  loss_execution_attestation_json(JSON.stringify(trainingLossRole), "FIT_CV"),
+);
+```
+
+Controllers should bind from the native `NodeTask` rather than resolving a
+role and constructing lineage independently:
+
+```js
+const binding = implementations.bind_training_loss(
+  JSON.stringify(nodeTask),
+  0,
+);
+const loss = binding.invoke;
+const value = loss(target, prediction);
+const requiredAttestation = JSON.parse(binding.required_attestation_json);
+binding.free();
+```
+
+The role index is zero-based. Binding validates that the task's ordered loss
+requirements exactly match its active roles. A controller may copy the returned
+attestation into `NodeResult.lineage.loss_attestations` only after `loss(...)`
+returns successfully.
+
+For scheduler execution, lower the roles into the native plan and execute that
+plan rather than rebuilding a loss-free campaign plan:
+
+```js
+const planJson = build_execution_plan_with_training_losses_json(
+  planId,
+  JSON.stringify(graph),
+  JSON.stringify(campaign),
+  JSON.stringify(controllerManifests),
+  JSON.stringify(trainingLossRoles),
+);
+
+const resultsJson = execute_execution_plan_phase_json(
+  planJson,
+  JSON.stringify(controllerManifests),
+  runId,
+  rootSeed,
+  "FIT_CV",
+  (controllerId, taskJson, exactSeed) =>
+    controller.invoke(controllerId, taskJson, exactSeed),
+);
+```
+
+The native lowerer replaces all plan loss roles, groups them by node and sorts
+them canonically before validating controller capabilities. At execution, every
+manifest embedded in the plan must exactly match the independently supplied
+trusted controller registry before any callback runs. The scheduler then checks
+that each callback result contains exactly the task's required loss attestations
+in the same order.
+
+The callback's `exactSeed` argument is a decimal string (or `null`), avoiding
+precision loss for native `u64` seeds beyond JavaScript's safe-integer range.
+The callback may set `NodeResult.lineage.seed` to `null`; the WASM bridge then
+injects the authoritative native seed before scheduler validation. The returned
+`resultsJson` still contains native numeric `u64` values; use a lossless JSON
+integer parser, or preserve the raw JSON, when inspecting lineage seeds exactly.
+
+JavaScript-local descriptors use `binding:javascript` and a `host_local` or
+`portable_registered` lifecycle. A Web Worker must populate its own registry;
+functions are not cloned, posted, or embedded in replay artifacts. Resolution
+is rejected when the exact descriptor or phase does not match.
+
 Rust-side validation failures are returned as JSON strings with the ADR-11
 descriptor fields `category`, `code`, `severity`, `message`,
 `remediation_hint` and `context`.

package/dag_ml_wasm.d.ts

@@ -1,8 +1,40 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class LocalImplementationRegistry {
+    free(): void;
+    [Symbol.dispose](): void;
+    bind_training_loss(node_task_json: string, role_index: number): TrainingLossBinding;
+    clear(): void;
+    descriptors_json(): string;
+    constructor();
+    register_loss(loss_reference_json: string, implementation: Function): void;
+    register_metric(metric_reference_json: string, implementation: Function): void;
+    resolve_loss(loss_reference_json: string): Function;
+    resolve_metric(metric_reference_json: string): Function;
+    resolve_training_loss(training_loss_role_json: string, phase: string): Function;
+    toJSON(): any;
+    unregister_loss(loss_reference_json: string): Function;
+    unregister_metric(metric_reference_json: string): Function;
+    readonly size: number;
+}
+
+export class TrainingLossBinding {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly invoke: Function;
+    readonly required_attestation_json: string;
+}
+
 export function build_execution_plan_json(plan_id: string, graph_json: string, campaign_json: string, controller_manifests_json: string): string;
 
+/**
+ * Build an execution plan and lower an explicit set of native training-loss
+ * roles into its node plans. The supplied set replaces every node's roles.
+ */
+export function build_execution_plan_with_training_losses_json(plan_id: string, graph_json: string, campaign_json: string, controller_manifests_json: string, training_loss_roles_json: string): string;
+
 export function compile_pipeline_dsl_artifact_json(json: string): string;
 
 export function compile_pipeline_dsl_artifact_with_controllers_json(dsl_json: string, controller_manifests_json: string): string;
@@ -24,13 +56,25 @@ export function derive_controller_manifest_list_json(host_controller_specs_json:
  * - `graph_json` / `campaign_json` / `controller_manifests_json`: the same
  *   inputs as [`build_execution_plan_json`]. The campaign's
  *   `split_invocation.fold_set` drives the FIT_CV fold loop.
- * - `js_invoke`: `(controllerId: string, taskJson: string) => nodeResultJson: string`,
- *   **synchronous** (no `await` across this boundary).
+ * - `js_invoke`: `(controllerId: string, taskJson: string, exactSeed: string | null)
+ *   => nodeResultJson: string`, **synchronous** (no `await` across this boundary).
+ *   A callback may return `lineage.seed: null`; the bridge injects the native
+ *   `u64` from the task before scheduler validation.
  *
  * Returns the phase's `Vec<NodeResult>` as JSON (predictions + lineage).
  */
 export function execute_campaign_phase_json(plan_id: string, graph_json: string, campaign_json: string, controller_manifests_json: string, run_id: string, root_seed: number, phase: string, js_invoke: Function): string;
 
+/**
+ * Execute one phase from a previously built and validated execution plan.
+ *
+ * Unlike [`execute_campaign_phase_json`], this preserves native training-loss
+ * roles already lowered into `NodePlan.training_losses`. Every embedded
+ * controller manifest must exactly match the independently supplied trusted
+ * runtime registry before any callback is dispatched.
+ */
+export function execute_execution_plan_phase_json(execution_plan_json: string, trusted_controller_manifests_json: string, run_id: string, root_seed: number, phase: string, js_invoke: Function): string;
+
 export function fold_set_fingerprint_json(json: string): string;
 
 /**
@@ -39,6 +83,8 @@ export function fold_set_fingerprint_json(json: string): string;
  */
 export function kfold_split_json(spec_json: string, sample_ids_json: string, id: string): string;
 
+export function loss_execution_attestation_json(training_loss_role_json: string, phase: string): string;
+
 /**
  * Rank candidate variants and return the winner — the SELECT phase for in-browser
  * generators/finetune. Selection stays in dag-ml (deterministic argmin/argmax +
@@ -75,7 +121,26 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_localimplementationregistry_free: (a: number, b: number) => void;
+    readonly __wbg_traininglossbinding_free: (a: number, b: number) => void;
+    readonly localimplementationregistry_bind_training_loss: (a: number, b: number, c: number, d: any) => [number, number, number];
+    readonly localimplementationregistry_clear: (a: number) => void;
+    readonly localimplementationregistry_descriptors_json: (a: number) => [number, number, number, number];
+    readonly localimplementationregistry_new: () => number;
+    readonly localimplementationregistry_register_loss: (a: number, b: number, c: number, d: any) => [number, number];
+    readonly localimplementationregistry_register_metric: (a: number, b: number, c: number, d: any) => [number, number];
+    readonly localimplementationregistry_resolve_loss: (a: number, b: number, c: number) => [number, number, number];
+    readonly localimplementationregistry_resolve_metric: (a: number, b: number, c: number) => [number, number, number];
+    readonly localimplementationregistry_resolve_training_loss: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+    readonly localimplementationregistry_size: (a: number) => number;
+    readonly localimplementationregistry_toJSON: (a: number) => [number, number, number];
+    readonly localimplementationregistry_unregister_loss: (a: number, b: number, c: number) => [number, number, number];
+    readonly localimplementationregistry_unregister_metric: (a: number, b: number, c: number) => [number, number, number];
+    readonly loss_execution_attestation_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly traininglossbinding_invoke: (a: number) => any;
+    readonly traininglossbinding_required_attestation_json: (a: number) => [number, number];
     readonly build_execution_plan_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
+    readonly build_execution_plan_with_training_losses_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number, number];
     readonly compile_pipeline_dsl_artifact_json: (a: number, b: number) => [number, number, number, number];
     readonly compile_pipeline_dsl_artifact_with_controllers_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
     readonly compile_pipeline_dsl_graph_json: (a: number, b: number) => [number, number, number, number];
@@ -84,6 +149,7 @@ export interface InitOutput {
     readonly derive_controller_manifest_json: (a: number, b: number) => [number, number, number, number];
     readonly derive_controller_manifest_list_json: (a: number, b: number) => [number, number, number, number];
     readonly execute_campaign_phase_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: any) => [number, number, number, number];
+    readonly execute_execution_plan_phase_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: any) => [number, number, number, number];
     readonly fold_set_fingerprint_json: (a: number, b: number) => [number, number, number, number];
     readonly kfold_split_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
     readonly select_candidates_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];

package/dag_ml_wasm.js

@@ -1,5 +1,214 @@
 /* @ts-self-types="./dag_ml_wasm.d.ts" */
 
+export class LocalImplementationRegistry {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LocalImplementationRegistryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_localimplementationregistry_free(ptr, 0);
+    }
+    /**
+     * @param {string} node_task_json
+     * @param {number} role_index
+     * @returns {TrainingLossBinding}
+     */
+    bind_training_loss(node_task_json, role_index) {
+        const ptr0 = passStringToWasm0(node_task_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_bind_training_loss(this.__wbg_ptr, ptr0, len0, role_index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrainingLossBinding.__wrap(ret[0]);
+    }
+    clear() {
+        wasm.localimplementationregistry_clear(this.__wbg_ptr);
+    }
+    /**
+     * @returns {string}
+     */
+    descriptors_json() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.localimplementationregistry_descriptors_json(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);
+        }
+    }
+    constructor() {
+        const ret = wasm.localimplementationregistry_new();
+        this.__wbg_ptr = ret;
+        LocalImplementationRegistryFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} loss_reference_json
+     * @param {Function} implementation
+     */
+    register_loss(loss_reference_json, implementation) {
+        const ptr0 = passStringToWasm0(loss_reference_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_register_loss(this.__wbg_ptr, ptr0, len0, implementation);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} metric_reference_json
+     * @param {Function} implementation
+     */
+    register_metric(metric_reference_json, implementation) {
+        const ptr0 = passStringToWasm0(metric_reference_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_register_metric(this.__wbg_ptr, ptr0, len0, implementation);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} loss_reference_json
+     * @returns {Function}
+     */
+    resolve_loss(loss_reference_json) {
+        const ptr0 = passStringToWasm0(loss_reference_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_resolve_loss(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} metric_reference_json
+     * @returns {Function}
+     */
+    resolve_metric(metric_reference_json) {
+        const ptr0 = passStringToWasm0(metric_reference_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_resolve_metric(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} training_loss_role_json
+     * @param {string} phase
+     * @returns {Function}
+     */
+    resolve_training_loss(training_loss_role_json, phase) {
+        const ptr0 = passStringToWasm0(training_loss_role_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(phase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_resolve_training_loss(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get size() {
+        const ret = wasm.localimplementationregistry_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    toJSON() {
+        const ret = wasm.localimplementationregistry_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} loss_reference_json
+     * @returns {Function}
+     */
+    unregister_loss(loss_reference_json) {
+        const ptr0 = passStringToWasm0(loss_reference_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_unregister_loss(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} metric_reference_json
+     * @returns {Function}
+     */
+    unregister_metric(metric_reference_json) {
+        const ptr0 = passStringToWasm0(metric_reference_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.localimplementationregistry_unregister_metric(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) LocalImplementationRegistry.prototype[Symbol.dispose] = LocalImplementationRegistry.prototype.free;
+
+export class TrainingLossBinding {
+    static __wrap(ptr) {
+        const obj = Object.create(TrainingLossBinding.prototype);
+        obj.__wbg_ptr = ptr;
+        TrainingLossBindingFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrainingLossBindingFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_traininglossbinding_free(ptr, 0);
+    }
+    /**
+     * @returns {Function}
+     */
+    get invoke() {
+        const ret = wasm.traininglossbinding_invoke(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get required_attestation_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.traininglossbinding_required_attestation_json(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);
+        }
+    }
+}
+if (Symbol.dispose) TrainingLossBinding.prototype[Symbol.dispose] = TrainingLossBinding.prototype.free;
+
 /**
  * @param {string} plan_id
  * @param {string} graph_json
@@ -34,6 +243,45 @@ export function build_execution_plan_json(plan_id, graph_json, campaign_json, co
     }
 }
 
+/**
+ * Build an execution plan and lower an explicit set of native training-loss
+ * roles into its node plans. The supplied set replaces every node's roles.
+ * @param {string} plan_id
+ * @param {string} graph_json
+ * @param {string} campaign_json
+ * @param {string} controller_manifests_json
+ * @param {string} training_loss_roles_json
+ * @returns {string}
+ */
+export function build_execution_plan_with_training_losses_json(plan_id, graph_json, campaign_json, controller_manifests_json, training_loss_roles_json) {
+    let deferred7_0;
+    let deferred7_1;
+    try {
+        const ptr0 = passStringToWasm0(plan_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(graph_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(campaign_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(controller_manifests_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(training_loss_roles_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.build_execution_plan_with_training_losses_json(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        var ptr6 = ret[0];
+        var len6 = ret[1];
+        if (ret[3]) {
+            ptr6 = 0; len6 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+    }
+}
+
 /**
  * @param {string} json
  * @returns {string}
@@ -207,8 +455,10 @@ export function derive_controller_manifest_list_json(host_controller_specs_json)
  * - `graph_json` / `campaign_json` / `controller_manifests_json`: the same
  *   inputs as [`build_execution_plan_json`]. The campaign's
  *   `split_invocation.fold_set` drives the FIT_CV fold loop.
- * - `js_invoke`: `(controllerId: string, taskJson: string) => nodeResultJson: string`,
- *   **synchronous** (no `await` across this boundary).
+ * - `js_invoke`: `(controllerId: string, taskJson: string, exactSeed: string | null)
+ *   => nodeResultJson: string`, **synchronous** (no `await` across this boundary).
+ *   A callback may return `lineage.seed: null`; the bridge injects the native
+ *   `u64` from the task before scheduler validation.
  *
  * Returns the phase's `Vec<NodeResult>` as JSON (predictions + lineage).
  * @param {string} plan_id
@@ -252,6 +502,48 @@ export function execute_campaign_phase_json(plan_id, graph_json, campaign_json,
     }
 }
 
+/**
+ * Execute one phase from a previously built and validated execution plan.
+ *
+ * Unlike [`execute_campaign_phase_json`], this preserves native training-loss
+ * roles already lowered into `NodePlan.training_losses`. Every embedded
+ * controller manifest must exactly match the independently supplied trusted
+ * runtime registry before any callback is dispatched.
+ * @param {string} execution_plan_json
+ * @param {string} trusted_controller_manifests_json
+ * @param {string} run_id
+ * @param {number} root_seed
+ * @param {string} phase
+ * @param {Function} js_invoke
+ * @returns {string}
+ */
+export function execute_execution_plan_phase_json(execution_plan_json, trusted_controller_manifests_json, run_id, root_seed, phase, js_invoke) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(execution_plan_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(trusted_controller_manifests_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(run_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(phase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.execute_execution_plan_phase_json(ptr0, len0, ptr1, len1, ptr2, len2, root_seed, ptr3, len3, js_invoke);
+        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} json
  * @returns {string}
@@ -310,6 +602,34 @@ export function kfold_split_json(spec_json, sample_ids_json, id) {
     }
 }
 
+/**
+ * @param {string} training_loss_role_json
+ * @param {string} phase
+ * @returns {string}
+ */
+export function loss_execution_attestation_json(training_loss_role_json, phase) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(training_loss_role_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(phase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.loss_execution_attestation_json(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);
+    }
+}
+
 /**
  * Rank candidate variants and return the winner — the SELECT phase for in-browser
  * generators/finetune. Selection stays in dag-ml (deterministic argmin/argmax +
@@ -488,6 +808,12 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
         __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -499,8 +825,8 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_call_e3b662382210db98: function() { return handleError(function (arg0, arg1, arg2, arg3) {
-            const ret = arg0.call(arg1, arg2, arg3);
+        __wbg_call_44b7209e1e252e6a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = arg0.call(arg1, arg2, arg3, arg4);
             return ret;
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
@@ -524,6 +850,13 @@ function __wbg_get_imports() {
     };
 }
 
+const LocalImplementationRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_localimplementationregistry_free(ptr, 1));
+const TrainingLossBindingFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_traininglossbinding_free(ptr, 1));
+
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
     wasm.__wbindgen_externrefs.set(idx, obj);

package/package.json

@@ -5,7 +5,7 @@
     "G. Beurier <beurier@cirad.fr>"
   ],
   "description": "WASM bindings for DAG-ML JSON contracts.",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "license": "CECILL-2.1 OR AGPL-3.0-or-later",
   "repository": {
     "type": "git",