dag-ml-wasm 0.3.25 → 0.3.27

package/README.md

@@ -6,6 +6,17 @@ 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.
 
+For parallel browser HPO, call `host_hpo_search_parallel_json` with a
+dispatcher that returns a Promise for each serialized candidate task. Each Web
+Worker loads its own WASM instance and calls `host_hpo_evaluate_worker_task_json`
+with candidate-local controller state. The core dispatches a whole trial window
+before awaiting results, validates scores and checkpoints, then tells the
+optimizer in trial order. `host_hpo_search_json` remains the synchronous
+single-worker route. For progressive pruning, tagged fold tasks call
+`host_hpo_evaluate_worker_fold_json` and return to the coordinator after each
+fold; pruned candidates never execute later folds. Complete candidates run one
+full native FIT_CV pass for the exact global OOF result.
+
 `contract_manifest_json()` returns a stable JSON manifest with the package
 version, supported contract ids, exported Python/WASM function names and shared
 fixture digests. Browser integrations should check it before accepting cached
@@ -113,6 +124,22 @@ 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.
 
+For host hyperparameter search, `host_hpo_search_json(planJson, manifestsJson,
+envelopeJson, requestJson, checkpointJson, controller, optimizer)` runs the same
+sequential native search as Rust and PyO3. The `controller` has the signature
+shown above. The synchronous `optimizer(operation, payloadJson)` must return a
+JSON string: `ask` returns `{"params": {...}}` or `{"params": null}`;
+`report_intermediate` returns `{"prune": true|false}`; `tell`, `pruned`,
+`fail`, and `prepare_terminal` return `{"ok": true}`; `checkpoint` returns
+`{"continue": true|false}`. `prepare_terminal` receives a sealed prospective
+checkpoint before an optimizer transition, so a browser host should persist it
+durably before replying. To resume, pass the last published native checkpoint
+as `checkpointJson` and reconcile any prepared optimizer transition first with
+`recover_host_hpo_checkpoint_json(checkpointJson, preparedJson, interruptedJson)`;
+use `"null"` and `"[]"` when there is no prepared terminal or interrupted trial.
+This export runs one candidate at a time; browser worker parallelism remains
+an adapter gap.
+
 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

package/dag_ml_wasm.d.ts

@@ -27,6 +27,11 @@ export class TrainingLossBinding {
     readonly required_attestation_json: string;
 }
 
+/**
+ * Validate named source/sample coverage and return identity-only row indices.
+ */
+export function align_named_source_rows_json(request_json: string): string;
+
 export function build_execution_plan_json(plan_id: string, graph_json: string, campaign_json: string, controller_manifests_json: string): string;
 
 /**
@@ -75,8 +80,51 @@ export function execute_campaign_phase_json(plan_id: string, graph_json: string,
  */
 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;
 
+/**
+ * Execute a no-splitter REFIT once and return the closed package and node evidence.
+ * The synchronous JS callback owns host-sidecar operator state by artifact ID.
+ */
+export function execute_initial_full_refit_json(plan_json: string, trusted_controller_manifests_json: string, envelope_json: string, training_sample_ids_json: string, package_id: string, run_id: string, root_seed: string, js_invoke: Function): string;
+
 export function fold_set_fingerprint_json(json: string): string;
 
+/**
+ * Evaluate one FIT_CV fold only, then return to the browser coordinator for
+ * its optimizer's prune decision before any later fold is dispatched.
+ */
+export function host_hpo_evaluate_worker_fold_json(task_json: string, fold_index: number, trusted_controller_manifests_json: string, data_envelope_json: string, request_json: string, js_invoke: Function): string;
+
+/**
+ * Evaluate one candidate inside its own Web Worker/WASM instance. The
+ * browser's dispatcher sends the serialized `HostHpoWorkerTask` to a worker,
+ * which invokes this function with its local synchronous controller callback.
+ */
+export function host_hpo_evaluate_worker_task_json(task_json: string, trusted_controller_manifests_json: string, data_envelope_json: string, request_json: string, js_invoke: Function): string;
+
+/**
+ * Run one-worker host HPO with native fold scoring, pruning and durable
+ * checkpoint transitions. Both callbacks are synchronous: the controller is
+ * `(controllerId, taskJson, exactSeed) => nodeResultJson`; the optimizer is
+ * `(operation, payloadJson) => replyJson` (see README). The browser persists
+ * its own optimizer state and native checkpoint before returning from each
+ * `prepare_terminal`/`checkpoint` callback.
+ */
+export function host_hpo_search_json(execution_plan_json: string, trusted_controller_manifests_json: string, data_envelope_json: string, request_json: string, checkpoint_json: string | null | undefined, js_invoke: Function, js_optimizer: Function): string;
+
+/**
+ * Run a true browser worker window: dispatch every candidate before awaiting
+ * any Promise, then reconcile results with native core in trial order. The
+ * dispatcher has shape `(taskJson) => Promise<workerResultJson>`; each worker
+ * owns a separate WASM instance and invokes `host_hpo_evaluate_worker_task_json`.
+ * The existing synchronous `host_hpo_search_json` remains available.
+ */
+export function host_hpo_search_parallel_json(execution_plan_json: string, trusted_controller_manifests_json: string, data_envelope_json: string, request_json: string, checkpoint_json: string | null | undefined, max_workers: number, js_dispatch: Function, js_optimizer: Function): Promise<string>;
+
+/**
+ * Attach a new V2 PREDICT cohort to the package's signed training envelope.
+ */
+export function initial_full_refit_predict_envelope_json(package_json: string, cohort_json: string): string;
+
 /**
  * Build a K-fold `FoldSet` from a `KFoldSpec` JSON + a JSON array of sample ids.
  * dag-ml owns the split — the host stops building folds itself.
@@ -85,6 +133,19 @@ export function kfold_split_json(spec_json: string, sample_ids_json: string, id:
 
 export function loss_execution_attestation_json(training_loss_role_json: string, phase: string): string;
 
+/**
+ * Validate a browser-persisted prepared terminal and seal interrupted trials
+ * before resuming search. This is the same recovery contract as PyO3/C ABI.
+ */
+export function recover_host_hpo_checkpoint_json(checkpoint_json: string, prepared_json: string, interrupted_json: string): string;
+
+/**
+ * Replay selected package outputs on a fresh V2 cohort without training.
+ * Raw native payloads are hydrated from the package; host sidecars use exact
+ * caller-owned artifact handles registered for this invocation only.
+ */
+export function replay_initial_full_refit_json(package_json: string, envelope_json: string, output_ids_json: string, artifact_handles_json: string, run_id: string, js_invoke: Function): string;
+
 /**
  * Rank candidate variants and return the winner — the SELECT phase for in-browser
  * generators/finetune. Selection stays in dag-ml (deterministic argmin/argmax +
@@ -94,6 +155,26 @@ export function loss_execution_attestation_json(training_loss_role_json: string,
  */
 export function select_candidates_json(policy_json: string, candidates_json: string, groups_json?: string | null): string;
 
+/**
+ * Resolve one explicitly named output of a signed portable package.
+ */
+export function select_portable_output_json(package_json: string, binding_id: string): string;
+
+/**
+ * Select a CV fold for stacking test predictions from validation scores.
+ */
+export function select_stacking_fold_json(request_json: string): string;
+
+/**
+ * Select stacking producers from validation scores with the native policy.
+ */
+export function select_stacking_producers_json(request_json: string): string;
+
+/**
+ * Objective-aware normalized CV-fold weights for stacking test predictions.
+ */
+export function stacking_fold_weights_json(request_json: string): string;
+
 /**
  * Build a stratified K-fold `FoldSet`: same OOF-once guarantee as K-fold, but
  * balanced by a per-sample class label. `strata_json` is a JSON object mapping
@@ -115,12 +196,20 @@ export function validate_fold_set_json(json: string): void;
 
 export function validate_graph_json(json: string): void;
 
+/**
+ * Validate a signed no-splitter REFIT package before any host operator callback.
+ */
+export function validate_initial_full_refit_package_json(package_json: string): void;
+
 export function validate_pipeline_dsl_json(json: string): void;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 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 align_named_source_rows_json: (a: number, b: number) => [number, 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];
@@ -132,20 +221,14 @@ export interface InitOutput {
     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 execute_initial_full_refit_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: number, o: any) => [number, number, number, number];
     readonly fold_set_fingerprint_json: (a: number, b: number) => [number, number, number, number];
+    readonly host_hpo_evaluate_worker_fold_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 host_hpo_evaluate_worker_task_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: any) => [number, number, number, number];
+    readonly host_hpo_search_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: any, l: any) => [number, number, number, number];
+    readonly host_hpo_search_parallel_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: any, m: any) => any;
+    readonly initial_full_refit_predict_envelope_json: (a: number, b: number, c: number, d: 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];
-    readonly stratified_kfold_split_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
-    readonly validate_campaign_json: (a: number, b: number) => [number, number];
-    readonly validate_controller_manifest_json: (a: number, b: number) => [number, number];
-    readonly validate_controller_manifest_list_json: (a: number, b: number) => [number, number];
-    readonly validate_execution_bundle_json: (a: number, b: number) => [number, number];
-    readonly validate_execution_plan_json: (a: number, b: number) => [number, number];
-    readonly validate_fold_set_json: (a: number, b: number) => [number, number];
-    readonly validate_graph_json: (a: number, b: number) => [number, number];
-    readonly validate_pipeline_dsl_json: (a: number, b: number) => [number, number];
-    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];
@@ -160,13 +243,33 @@ export interface InitOutput {
     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 recover_host_hpo_checkpoint_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+    readonly replay_initial_full_refit_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: any) => [number, number, number, number];
+    readonly select_candidates_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+    readonly select_portable_output_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly select_stacking_fold_json: (a: number, b: number) => [number, number, number, number];
+    readonly select_stacking_producers_json: (a: number, b: number) => [number, number, number, number];
+    readonly stacking_fold_weights_json: (a: number, b: number) => [number, number, number, number];
+    readonly stratified_kfold_split_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
     readonly traininglossbinding_invoke: (a: number) => any;
     readonly traininglossbinding_required_attestation_json: (a: number) => [number, number];
+    readonly validate_campaign_json: (a: number, b: number) => [number, number];
+    readonly validate_controller_manifest_json: (a: number, b: number) => [number, number];
+    readonly validate_controller_manifest_list_json: (a: number, b: number) => [number, number];
+    readonly validate_execution_bundle_json: (a: number, b: number) => [number, number];
+    readonly validate_execution_plan_json: (a: number, b: number) => [number, number];
+    readonly validate_fold_set_json: (a: number, b: number) => [number, number];
+    readonly validate_graph_json: (a: number, b: number) => [number, number];
+    readonly validate_initial_full_refit_package_json: (a: number, b: number) => [number, number];
+    readonly validate_pipeline_dsl_json: (a: number, b: number) => [number, number];
+    readonly wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___wasm_bindgen_dab8739f2315efff___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_dab8739f2315efff___JsError___true_: (a: number, b: number, c: any) => [number, number];
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;
     readonly __externref_table_alloc: () => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
     readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __wbindgen_start: () => void;

package/dag_ml_wasm.js

@@ -209,6 +209,32 @@ export class TrainingLossBinding {
 }
 if (Symbol.dispose) TrainingLossBinding.prototype[Symbol.dispose] = TrainingLossBinding.prototype.free;
 
+/**
+ * Validate named source/sample coverage and return identity-only row indices.
+ * @param {string} request_json
+ * @returns {string}
+ */
+export function align_named_source_rows_json(request_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.align_named_source_rows_json(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} plan_id
  * @param {string} graph_json
@@ -544,6 +570,52 @@ export function execute_execution_plan_phase_json(execution_plan_json, trusted_c
     }
 }
 
+/**
+ * Execute a no-splitter REFIT once and return the closed package and node evidence.
+ * The synchronous JS callback owns host-sidecar operator state by artifact ID.
+ * @param {string} plan_json
+ * @param {string} trusted_controller_manifests_json
+ * @param {string} envelope_json
+ * @param {string} training_sample_ids_json
+ * @param {string} package_id
+ * @param {string} run_id
+ * @param {string} root_seed
+ * @param {Function} js_invoke
+ * @returns {string}
+ */
+export function execute_initial_full_refit_json(plan_json, trusted_controller_manifests_json, envelope_json, training_sample_ids_json, package_id, run_id, root_seed, js_invoke) {
+    let deferred9_0;
+    let deferred9_1;
+    try {
+        const ptr0 = passStringToWasm0(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(envelope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(training_sample_ids_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(package_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passStringToWasm0(run_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passStringToWasm0(root_seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len6 = WASM_VECTOR_LEN;
+        const ret = wasm.execute_initial_full_refit_json(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, js_invoke);
+        var ptr8 = ret[0];
+        var len8 = ret[1];
+        if (ret[3]) {
+            ptr8 = 0; len8 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred9_0 = ptr8;
+        deferred9_1 = len8;
+        return getStringFromWasm0(ptr8, len8);
+    } finally {
+        wasm.__wbindgen_free(deferred9_0, deferred9_1, 1);
+    }
+}
+
 /**
  * @param {string} json
  * @returns {string}
@@ -569,6 +641,187 @@ export function fold_set_fingerprint_json(json) {
     }
 }
 
+/**
+ * Evaluate one FIT_CV fold only, then return to the browser coordinator for
+ * its optimizer's prune decision before any later fold is dispatched.
+ * @param {string} task_json
+ * @param {number} fold_index
+ * @param {string} trusted_controller_manifests_json
+ * @param {string} data_envelope_json
+ * @param {string} request_json
+ * @param {Function} js_invoke
+ * @returns {string}
+ */
+export function host_hpo_evaluate_worker_fold_json(task_json, fold_index, trusted_controller_manifests_json, data_envelope_json, request_json, js_invoke) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(task_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(data_envelope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.host_hpo_evaluate_worker_fold_json(ptr0, len0, fold_index, ptr1, len1, ptr2, len2, 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);
+    }
+}
+
+/**
+ * Evaluate one candidate inside its own Web Worker/WASM instance. The
+ * browser's dispatcher sends the serialized `HostHpoWorkerTask` to a worker,
+ * which invokes this function with its local synchronous controller callback.
+ * @param {string} task_json
+ * @param {string} trusted_controller_manifests_json
+ * @param {string} data_envelope_json
+ * @param {string} request_json
+ * @param {Function} js_invoke
+ * @returns {string}
+ */
+export function host_hpo_evaluate_worker_task_json(task_json, trusted_controller_manifests_json, data_envelope_json, request_json, js_invoke) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(task_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(data_envelope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.host_hpo_evaluate_worker_task_json(ptr0, len0, ptr1, len1, ptr2, len2, 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);
+    }
+}
+
+/**
+ * Run one-worker host HPO with native fold scoring, pruning and durable
+ * checkpoint transitions. Both callbacks are synchronous: the controller is
+ * `(controllerId, taskJson, exactSeed) => nodeResultJson`; the optimizer is
+ * `(operation, payloadJson) => replyJson` (see README). The browser persists
+ * its own optimizer state and native checkpoint before returning from each
+ * `prepare_terminal`/`checkpoint` callback.
+ * @param {string} execution_plan_json
+ * @param {string} trusted_controller_manifests_json
+ * @param {string} data_envelope_json
+ * @param {string} request_json
+ * @param {string | null | undefined} checkpoint_json
+ * @param {Function} js_invoke
+ * @param {Function} js_optimizer
+ * @returns {string}
+ */
+export function host_hpo_search_json(execution_plan_json, trusted_controller_manifests_json, data_envelope_json, request_json, checkpoint_json, js_invoke, js_optimizer) {
+    let deferred7_0;
+    let deferred7_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(data_envelope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        var ptr4 = isLikeNone(checkpoint_json) ? 0 : passStringToWasm0(checkpoint_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
+        const ret = wasm.host_hpo_search_json(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, js_invoke, js_optimizer);
+        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);
+    }
+}
+
+/**
+ * Run a true browser worker window: dispatch every candidate before awaiting
+ * any Promise, then reconcile results with native core in trial order. The
+ * dispatcher has shape `(taskJson) => Promise<workerResultJson>`; each worker
+ * owns a separate WASM instance and invokes `host_hpo_evaluate_worker_task_json`.
+ * The existing synchronous `host_hpo_search_json` remains available.
+ * @param {string} execution_plan_json
+ * @param {string} trusted_controller_manifests_json
+ * @param {string} data_envelope_json
+ * @param {string} request_json
+ * @param {string | null | undefined} checkpoint_json
+ * @param {number} max_workers
+ * @param {Function} js_dispatch
+ * @param {Function} js_optimizer
+ * @returns {Promise<string>}
+ */
+export function host_hpo_search_parallel_json(execution_plan_json, trusted_controller_manifests_json, data_envelope_json, request_json, checkpoint_json, max_workers, js_dispatch, js_optimizer) {
+    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(data_envelope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    var ptr4 = isLikeNone(checkpoint_json) ? 0 : passStringToWasm0(checkpoint_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len4 = WASM_VECTOR_LEN;
+    const ret = wasm.host_hpo_search_parallel_json(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, max_workers, js_dispatch, js_optimizer);
+    return ret;
+}
+
+/**
+ * Attach a new V2 PREDICT cohort to the package's signed training envelope.
+ * @param {string} package_json
+ * @param {string} cohort_json
+ * @returns {string}
+ */
+export function initial_full_refit_predict_envelope_json(package_json, cohort_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(package_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(cohort_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.initial_full_refit_predict_envelope_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);
+    }
+}
+
 /**
  * Build a K-fold `FoldSet` from a `KFoldSpec` JSON + a JSON array of sample ids.
  * dag-ml owns the split — the host stops building folds itself.
@@ -630,6 +883,80 @@ export function loss_execution_attestation_json(training_loss_role_json, phase)
     }
 }
 
+/**
+ * Validate a browser-persisted prepared terminal and seal interrupted trials
+ * before resuming search. This is the same recovery contract as PyO3/C ABI.
+ * @param {string} checkpoint_json
+ * @param {string} prepared_json
+ * @param {string} interrupted_json
+ * @returns {string}
+ */
+export function recover_host_hpo_checkpoint_json(checkpoint_json, prepared_json, interrupted_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(checkpoint_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(prepared_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(interrupted_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.recover_host_hpo_checkpoint_json(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);
+    }
+}
+
+/**
+ * Replay selected package outputs on a fresh V2 cohort without training.
+ * Raw native payloads are hydrated from the package; host sidecars use exact
+ * caller-owned artifact handles registered for this invocation only.
+ * @param {string} package_json
+ * @param {string} envelope_json
+ * @param {string} output_ids_json
+ * @param {string} artifact_handles_json
+ * @param {string} run_id
+ * @param {Function} js_invoke
+ * @returns {string}
+ */
+export function replay_initial_full_refit_json(package_json, envelope_json, output_ids_json, artifact_handles_json, run_id, js_invoke) {
+    let deferred7_0;
+    let deferred7_1;
+    try {
+        const ptr0 = passStringToWasm0(package_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(envelope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(output_ids_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(artifact_handles_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(run_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.replay_initial_full_refit_json(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, js_invoke);
+        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);
+    }
+}
+
 /**
  * Rank candidate variants and return the winner — the SELECT phase for in-browser
  * generators/finetune. Selection stays in dag-ml (deterministic argmin/argmax +
@@ -666,6 +993,113 @@ export function select_candidates_json(policy_json, candidates_json, groups_json
     }
 }
 
+/**
+ * Resolve one explicitly named output of a signed portable package.
+ * @param {string} package_json
+ * @param {string} binding_id
+ * @returns {string}
+ */
+export function select_portable_output_json(package_json, binding_id) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(package_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(binding_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.select_portable_output_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);
+    }
+}
+
+/**
+ * Select a CV fold for stacking test predictions from validation scores.
+ * @param {string} request_json
+ * @returns {string}
+ */
+export function select_stacking_fold_json(request_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.select_stacking_fold_json(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);
+    }
+}
+
+/**
+ * Select stacking producers from validation scores with the native policy.
+ * @param {string} request_json
+ * @returns {string}
+ */
+export function select_stacking_producers_json(request_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.select_stacking_producers_json(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);
+    }
+}
+
+/**
+ * Objective-aware normalized CV-fold weights for stacking test predictions.
+ * @param {string} request_json
+ * @returns {string}
+ */
+export function stacking_fold_weights_json(request_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stacking_fold_weights_json(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);
+    }
+}
+
 /**
  * Build a stratified K-fold `FoldSet`: same OOF-once guarantee as K-fold, but
  * balanced by a per-sample class label. `strata_json` is a JSON object mapping
@@ -787,6 +1221,19 @@ export function validate_graph_json(json) {
     }
 }
 
+/**
+ * Validate a signed no-splitter REFIT package before any host operator callback.
+ * @param {string} package_json
+ */
+export function validate_initial_full_refit_package_json(package_json) {
+    const ptr0 = passStringToWasm0(package_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.validate_initial_full_refit_package_json(ptr0, len0);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
 /**
  * @param {string} json
  */
@@ -801,20 +1248,28 @@ export function validate_pipeline_dsl_json(json) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_debug_string_a57024b9c6e4a48b: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_0e68cf47c9cbd9b0: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_number_get_136b9679cab35cfb: function(arg0, arg1) {
+        __wbg___wbindgen_is_function_fcda5e3902d732fe: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8c687d0b90d5b524: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_1dc732b810cb937c: 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_d154f1e671052120: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_92ab86bb19cbc12f: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -822,14 +1277,83 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_call_39f824e18d9d2414: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        __wbg__wbg_cb_unref_997e73d32238e655: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_call_7bbd9cceba9949ad: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
+        __wbg_call_c1ad1cb1b78e8130: 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) {
+        __wbg_new_typed_6f8b0d724fe26c07: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined_______true_(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_queueMicrotask_85c90f6987555d65: function(arg0) {
+            const ret = arg0.queueMicrotask;
+            return ret;
+        },
+        __wbg_queueMicrotask_f6a1fa10b81d1fc0: function(arg0) {
+            queueMicrotask(arg0);
+        },
+        __wbg_resolve_35ec7e0c6af4c82c: function(arg0) {
+            const ret = Promise.resolve(arg0);
+            return ret;
+        },
+        __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_1e7044f654e934db: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_d8b50611246a6d92: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_fd0bc376bf0f8b42: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_then_7a850dae4493f353: function(arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        },
+        __wbg_then_b830475380919203: function(arg0, arg1) {
+            const ret = arg0.then(arg1);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 308, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___wasm_bindgen_dab8739f2315efff___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_dab8739f2315efff___JsError___true_);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -850,6 +1374,17 @@ function __wbg_get_imports() {
     };
 }
 
+function wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___wasm_bindgen_dab8739f2315efff___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_dab8739f2315efff___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___wasm_bindgen_dab8739f2315efff___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_dab8739f2315efff___JsError___true_(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_dab8739f2315efff___convert__closures_____invoke___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined___js_sys_dd5193d6d4000a3a___Function_fn_wasm_bindgen_dab8739f2315efff___JsValue_____wasm_bindgen_dab8739f2315efff___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
+}
+
 const LocalImplementationRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_localimplementationregistry_free(ptr, 1));
@@ -863,6 +1398,10 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -961,6 +1500,34 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/package.json

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