@tellegen/engine 0.2.0 → 0.3.0

package/dist/wasm-pkg/tellegen.js

@@ -1,17 +1,171 @@
 /* @ts-self-types="./tellegen.d.ts" */
 
 /**
- * A build-once handle over the engine, exported to JS. Construct once per case (the
- * network is parsed and the model built here); then [`replace_edits`](Study::replace_edits)
+ * A retained fixed-point current-injection session. The prepared network,
+ * sparse LU, and last converged voltage remain in this WASM object across
+ * load edits.
+ */
+export class McPfSession {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McPfSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcpfsession_free(ptr, 0);
+    }
+    /**
+     * Materialize the current edited input as PowerIO IR.
+     * @returns {string}
+     */
+    input_module() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcpfsession_input_module(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);
+        }
+    }
+    /**
+     * Editable load branches with base and current P/Q values.
+     * @returns {string}
+     */
+    load_branches() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcpfsession_load_branches(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 {string} module_json
+     * @param {string} options_json
+     */
+    constructor(module_json, options_json) {
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mcpfsession_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        McPfSessionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Replace the absolute branch-power edit state and solve with the retained
+     * factorization and previous converged voltage.
+     * @param {string} edits_json
+     * @returns {string}
+     */
+    replace_load_powers(edits_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(edits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mcpfsession_replace_load_powers(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);
+        }
+    }
+    /**
+     * The current complete solver result.
+     * @returns {string}
+     */
+    result() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcpfsession_result(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);
+        }
+    }
+    /**
+     * Save the current edited point and result without re-solving.
+     * @param {string} study_id
+     * @param {string} study_title
+     * @returns {string}
+     */
+    snapshot(study_id, study_title) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(study_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(study_title, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.mcpfsession_snapshot(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);
+        }
+    }
+}
+if (Symbol.dispose) McPfSession.prototype[Symbol.dispose] = McPfSession.prototype.free;
+
+/**
+ * A retained handle over the engine, exported to JS. Construct once per PowerIO module;
+ * then [`replace_edits`](Study::replace_edits)
  * solves exactly at an absolute edit state and [`preview_replacement`](Study::preview_replacement)
- * returns a first-order linearization toward an absolute edit state — neither re-parses
- * the network, unlike `solve_json` which rebuilds it on every call. This is
- * the path a reactive drag should use.
+ * returns a first order linearization toward an absolute edit state.
  *
  * Arguments and results are JSON in the engine's `Study` shapes: edits are a
  * `NetworkEdit[]` (e.g. `[{"kind":"add_load","bus":2,"p_mw":50}]`; the element key
- * also accepts the powerio row uid string `ingest_case` stamps, e.g.
- * `"bus":"buses:1"`), `preview` watches an
+ * also accepts a powerio row uid string when the source format carries uids,
+ * e.g. `"bus":"buses:1"`), `preview` watches an
  * `Operand[]` (e.g. `[{"Price":"Active"}]`) and returns a `Preview`. `commit` takes the
  * edits plus a `SensRequest[]` of watched cells and returns `{ solution, iterations,
  * sensitivities }` — the committed [`SolveResponse`] plus the requested ∂operand/∂param
@@ -32,7 +186,7 @@ export class Study {
     /**
      * Apply a geographic layer (a canonical `.geo.json` from [`parse_geo`] or
      * [`apply_layout`]) onto this study's base network, so a later
-     * [`save_package`](Study::save_package) or export carries the coordinates
+     * [`save_module`](Study::save_module) or export carries the coordinates
      * on screen. Locations are metadata the model never reads; nothing
      * re-solves. Returns the apply report JSON.
      * @param {string} layer_geojson
@@ -92,6 +246,34 @@ export class Study {
             wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
         }
     }
+    /**
+     * Export the committed operating point to a powerio `format` (`matpower`,
+     * `psse`, ...). Returns `{ text, diagnostics, format,
+     * extension }` as JSON: the serialized case, this output operation's
+     * structured diagnostics, and the format token and file extension.
+     * @param {string} format
+     * @returns {string}
+     */
+    export(format) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.study_export(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);
+        }
+    }
     /**
      * The formulation tag (`"dcopf"` / `"acpf"`).
      * @returns {string}
@@ -109,14 +291,14 @@ export class Study {
         }
     }
     /**
-     * Build a study over `network_json` for `formulation` (`"dcopf"` / `"acpf"`, and —
+     * Build a study over `module_json` for `formulation` (`"dcopf"` / `"acpf"`, and —
      * in a build that includes them — `"socwr"` / `"acopf"`), solving the base case.
-     * Errors on an unknown or not-built formulation.
-     * @param {string} network_json
+     * Bare model JSON and unknown or unavailable formulations are rejected.
+     * @param {string} module_json
      * @param {string} formulation
      */
-    constructor(network_json, formulation) {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    constructor(module_json, formulation) {
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(formulation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
@@ -128,6 +310,38 @@ export class Study {
         StudyFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Run a bounded differentiable planning search over the committed
+     * operating point: the implicit gradient of the serializable outer
+     * objective through the exact DC OPF KKT orders capacity trials
+     * whose every step is verified by an exact re-solve. Read only — the
+     * committed case, edits, and revision are untouched. `spec_json` is a
+     * [`tellegen::plan::CapacityPlanSpec`]; the returned JSON is the complete
+     * [`tellegen::plan::CapacityPlanOutcome`] trace with the unapplied
+     * proposal. A non-DC formulation returns a typed error.
+     * @param {string} spec_json
+     * @returns {string}
+     */
+    plan(spec_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(spec_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.study_plan(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);
+        }
+    }
     /**
      * First-order preview of `edits_json` (a `NetworkEdit[]`) for the `watched_json`
      * operands (an `Operand[]`), at the committed point, without re-solving. Returns the
@@ -219,17 +433,62 @@ export class Study {
         }
     }
     /**
-     * Serialize this study as a `.pio.json` package: the base network is the payload,
-     * the edit log is the study block (one commit per `commit` call, keyed by row uid),
-     * and the formulation and solve options ride under `study.app["tellegen"]`. Returns
-     * the package JSON, ready to download or hand to [`export_study`].
+     * Serialize the exact problem instance, including its inner objective and constraints.
      * @returns {string}
      */
-    save_package() {
+    save_instance_module() {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.study_save_package(this.__wbg_ptr);
+            const ret = wasm.study_save_instance_module(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);
+        }
+    }
+    /**
+     * Serialize the committed operating point as a stored PowerIO module:
+     * the materialized network with one descriptive `Edit` history entry per
+     * committed edit, ready to download as `.pio.json`. Any PowerIO reader
+     * understands the file; reloading it starts a fresh session.
+     * @returns {string}
+     */
+    save_module() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.study_save_module(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);
+        }
+    }
+    /**
+     * Save the committed exact DC OPF result as a PowerIO solution module.
+     * The embedded instance contains the materialized case that was solved.
+     * @returns {string}
+     */
+    save_solution_module() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.study_save_solution_module(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -273,15 +532,15 @@ if (Symbol.dispose) Study.prototype[Symbol.dispose] = Study.prototype.free;
  * project to approximate longitude/latitude and join onto buses through the
  * `SubNum` extras key. Returns the refreshed `ingest_case` payload plus a
  * `report`; errors when no bus joined.
- * @param {string} network_json
+ * @param {string} module_json
  * @param {Uint8Array} bytes
  * @returns {string}
  */
-export function apply_display_geo(network_json, bytes) {
+export function apply_display_geo(module_json, bytes) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
@@ -306,15 +565,15 @@ export function apply_display_geo(network_json, bytes) {
  * id, name, and the unordered endpoint pair — upstream semantics). Returns
  * the refreshed `ingest_case` payload plus a `report` of matched/unmatched
  * counts; errors when nothing matched.
- * @param {string} network_json
+ * @param {string} module_json
  * @param {string} layer_geojson
  * @returns {string}
  */
-export function apply_geo(network_json, layer_geojson) {
+export function apply_geo(module_json, layer_geojson) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(layer_geojson, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
@@ -338,16 +597,16 @@ export function apply_geo(network_json, layer_geojson) {
  * `kind` provenance (`synthetic` or `manual`). Returns the refreshed
  * `ingest_case` payload plus `layer`, the stamped layout as a canonical
  * `.geo.json` document.
- * @param {string} network_json
+ * @param {string} module_json
  * @param {string} coords_json
  * @param {string} kind
  * @returns {string}
  */
-export function apply_layout(network_json, coords_json, kind) {
+export function apply_layout(module_json, coords_json, kind) {
     let deferred5_0;
     let deferred5_1;
     try {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
@@ -368,6 +627,35 @@ export function apply_layout(network_json, coords_json, kind) {
     }
 }
 
+/**
+ * Attach geographic or drawing positions to a saved multiconductor result.
+ * @param {string} snapshot_json
+ * @param {string} layer_geojson
+ * @returns {string}
+ */
+export function apply_mc_study_geo(snapshot_json, layer_geojson) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(snapshot_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(layer_geojson, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.apply_mc_study_geo(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);
+    }
+}
+
 /**
  * The capability matrix as JSON: which `(formulation, operand, parameter)` cells this
  * build supports, so the UI can populate menus and grey out the rest.
@@ -413,52 +701,18 @@ export function classify_json(bytes) {
     }
 }
 
-/**
- * Export the balanced study state at commit `commit` to a powerio `format`
- * (`matpower`, `psse`, `model-json`, ...). Returns `{ text, warnings, format,
- * extension }` as JSON: the serialized case, the writer's fidelity warnings so the
- * frontend can surface them, and the format token and file extension. The package
- * JSON is untrusted; malformed input returns a `JsError`, never a panic.
- * @param {string} package_json
- * @param {number} commit
- * @param {string} format
- * @returns {string}
- */
-export function export_study(package_json, commit, format) {
-    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(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.export_study(ptr0, len0, commit, 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);
-    }
-}
-
 /**
  * A case's coordinates as a canonical `.geo.json` document (one point per
  * located bus, one route per routed branch, provenance preserved). Errors
  * when the case carries none.
- * @param {string} network_json
+ * @param {string} module_json
  * @returns {string}
  */
-export function extract_geo(network_json) {
+export function extract_geo(module_json) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.extract_geo(ptr0, len0);
         var ptr2 = ret[0];
@@ -477,7 +731,7 @@ export function extract_geo(network_json) {
 
 /**
  * Everything the drop panel needs from one parse: counts, total load and
- * capacity, parse warnings, and a `view` of buses and branches in the shape
+ * capacity, parse diagnostics, and a `view` of buses and branches in the shape
  * the tellegen API serves, placed at the coordinates the file carries
  * (PowerWorld complete case aux exports). `view` is null when the file has no
  * coordinates.
@@ -514,13 +768,14 @@ export function ingest_case(bytes, format) {
 /**
  * The distribution counterpart of [`ingest_case`]: view a multiconductor case
  * with no solve. `format` is a distribution reader token (`dss`, `bmopf`,
- * `pmd`) parsed by [`powerio_dist`], or `pio` for a `.pio.json` package
- * carrying a multiconductor payload. Returns the drop-panel payload JSON:
- * name, element counts, connected load/generation (kW), parse warnings,
+ * `pmd`) parsed by [`powerio_dist`], or `pio` for a `.pio.json` stored module
+ * holding a supported multiconductor network, instance, or solution. Returns
+ * the drop-panel payload JSON:
+ * name, element counts, connected load/generation (kW), parse diagnostics,
  * coordinate provenance, and the bus/terminal graph the frontend renders (see
- * [`dist`]).
+ * the private `dist` adapter).
  *
- * Untrusted input: the parse and package restore return error strings (mapped
+ * Untrusted input: the parse and module restore return error strings (mapped
  * to `JsError` here), so a malformed, truncated, or oversized `.dss`/JSON
  * rejects cleanly and never panics the wasm instance.
  * @param {string} text
@@ -583,8 +838,9 @@ export function ingest_dist_case_bytes(bytes, format) {
  * Classify and ingest one dropped JSON byte buffer. Known inputs return their
  * render-ready payload; ambiguous and unknown documents return a null payload
  * so the caller can request an explicit format without decoding the bytes a
- * second time. Package envelopes are decoded once and the parsed package is
- * passed directly to the appropriate restore path.
+ * second time. A stored module is read once and its value routed to the
+ * balanced or multiconductor view. The TS drop-classify layer must mirror
+ * the kinds (`module` and powerio's families).
  * @param {Uint8Array} bytes
  * @returns {string}
  */
@@ -610,102 +866,115 @@ export function ingest_json_drop(bytes) {
 }
 
 /**
- * [`ingest_case`] for powerio's own model JSON, the document `export_study`
- * writes under the `model-json` token and powerio classifies as
- * `JsonClass::ModelJson`. It is not a case format, so it reaches
- * `BalancedNetwork::from_json` rather than a case reader, and there are no
- * reader warnings to carry: nothing was converted.
- * @param {string} network_json
+ * Parse a case file (MATPOWER, PSS/E RAW, PowerWorld aux, PowerModels or
+ * egret JSON) and return `{"network": ..., "diagnostics": [...]}` as JSON.
+ *
+ * Takes the upload's bytes, not decoded text: powerio refuses a text format
+ * whose bytes are not UTF-8, where a browser side `File.text()` would have
+ * replaced each offending byte with U+FFFD and parsed on. It also reaches
+ * PowerWorld `.pwb`, which has no text form at all.
+ * @param {Uint8Array} bytes
+ * @param {string} format
  * @returns {string}
  */
-export function ingest_model_json(network_json) {
-    let deferred3_0;
-    let deferred3_1;
+export function parse_case(bytes, format) {
+    let deferred4_0;
+    let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ingest_model_json(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.parse_case(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
         if (ret[3]) {
-            ptr2 = 0; len2 = 0;
+            ptr3 = 0; len3 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
 }
 
 /**
- * Byte counterpart of [`ingest_model_json`] for dropped files. UTF-8 decoding
- * and model validation both stay in powerio.
+ * Decode a PowerWorld drawing as a canonical PowerIO GeoLayer in diagram units.
  * @param {Uint8Array} bytes
+ * @param {string} format
  * @returns {string}
  */
-export function ingest_model_json_bytes(bytes) {
-    let deferred3_0;
-    let deferred3_1;
+export function parse_display(bytes, format) {
+    let deferred4_0;
+    let deferred4_1;
     try {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ingest_model_json_bytes(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.parse_display(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
         if (ret[3]) {
-            ptr2 = 0; len2 = 0;
+            ptr3 = 0; len3 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
 }
 
 /**
- * Restore a study saved by [`Study::save_package`]. Returns a JSON bundle the frontend
- * reads to rebuild its case, edit sliders, formulation, and solve options in one step.
- * See [`load_package_bundle`] for the shape and the fail-closed contract.
- * @param {string} package_json
+ * Parse a geographic sidecar (buscoords CSV, aliased CSV/JSON records,
+ * GeoJSON) from raw dropped bytes; `hint` is the file name ("" to sniff).
+ * Returns `{ layer, diagnostics, n_points, n_routes }` — the layer as its
+ * canonical `.geo.json` document, ready for [`apply_geo`]. Untrusted input
+ * rejects as a `JsError`, never a panic.
+ * @param {Uint8Array} bytes
+ * @param {string} hint
  * @returns {string}
  */
-export function load_package(package_json) {
-    let deferred3_0;
-    let deferred3_1;
+export function parse_geo(bytes, hint) {
+    let deferred4_0;
+    let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(package_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.load_package(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ptr1 = passStringToWasm0(hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.parse_geo(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
         if (ret[3]) {
-            ptr2 = 0; len2 = 0;
+            ptr3 = 0; len3 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
 }
 
 /**
- * Byte counterpart of [`load_package`] for a dropped package.
- * @param {Uint8Array} bytes
+ * Validate and canonicalize a saved multiconductor Study snapshot without
+ * re-solving it.
+ * @param {string} snapshot_json
  * @returns {string}
  */
-export function load_package_bytes(bytes) {
+export function replay_mc_study(snapshot_json) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passStringToWasm0(snapshot_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.load_package_bytes(ptr0, len0);
+        const ret = wasm.replay_mc_study(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -721,26 +990,22 @@ export function load_package_bytes(bytes) {
 }
 
 /**
- * Parse a case file (MATPOWER, PSS/E RAW, PowerWorld aux, PowerModels or
- * egret JSON) and return `{"network": ..., "warnings": [...]}` as JSON.
- *
- * Takes the upload's bytes, not decoded text: `powerio::parse_bytes` refuses a
- * text format whose bytes are not UTF-8, where a browser side `File.text()`
- * would have replaced each offending byte with U+FFFD and parsed on. It also
- * reaches PowerWorld `.pwb`, which has no text form at all.
- * @param {Uint8Array} bytes
- * @param {string} format
+ * Solve a raw BMOPF multiconductor constant-power case.  The parser and
+ * fixed-point implementation remain in the engine crate; this export only
+ * performs the bounded text/JSON conversion at the browser boundary.
+ * @param {string} text
+ * @param {string} options_json
  * @returns {string}
  */
-export function parse_case(bytes, format) {
+export function solve_mc_bmopf(text, options_json) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.parse_case(ptr0, len0, ptr1, len1);
+        const ret = wasm.solve_mc_bmopf(ptr0, len0, ptr1, len1);
         var ptr3 = ret[0];
         var len3 = ret[1];
         if (ret[3]) {
@@ -756,25 +1021,21 @@ export function parse_case(bytes, format) {
 }
 
 /**
- * Decode a PowerWorld `.pwd` display file (binary). Returns the substation
- * symbols at the diagram coordinates the file stores (x east, y north) plus
- * the canvas size, each with the approximate `lon`/`lat` projection
- * (`pwd_mercator_to_lonlat`; hand edited diagrams drift from it). A `.pwd`
- * carries no buses or branches. `format` is "pwd". Pure in-memory parsing,
- * no filesystem, so it runs in the browser.
- * @param {Uint8Array} bytes
- * @param {string} format
+ * Solve a stored PowerIO multiconductor module. This accepts the portable
+ * module form used by browser persistence in addition to raw BMOPF text.
+ * @param {string} module_json
+ * @param {string} options_json
  * @returns {string}
  */
-export function parse_display(bytes, format) {
+export function solve_mc_module(module_json, options_json) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.parse_display(ptr0, len0, ptr1, len1);
+        const ret = wasm.solve_mc_module(ptr0, len0, ptr1, len1);
         var ptr3 = ret[0];
         var len3 = ret[1];
         if (ret[3]) {
@@ -790,55 +1051,59 @@ export function parse_display(bytes, format) {
 }
 
 /**
- * Parse a geographic sidecar (buscoords CSV, aliased CSV/JSON records,
- * GeoJSON) from raw dropped bytes; `hint` is the file name ("" to sniff).
- * Returns `{ layer, warnings, n_points, n_routes }` — the layer as its
- * canonical `.geo.json` document, ready for [`apply_geo`]. Untrusted input
- * rejects as a `JsError`, never a panic.
- * @param {Uint8Array} bytes
- * @param {string} hint
+ * Solve a supported multiconductor Study input and return a self-contained,
+ * replayable snapshot containing the typed input, PowerIO solution module, and
+ * terminal-aware result view.
+ * @param {string} module_json
+ * @param {string} study_id
+ * @param {string} study_title
+ * @param {string} options_json
  * @returns {string}
  */
-export function parse_geo(bytes, hint) {
-    let deferred4_0;
-    let deferred4_1;
+export function solve_mc_study(module_json, study_id, study_title, options_json) {
+    let deferred6_0;
+    let deferred6_1;
     try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(study_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.parse_geo(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
+        const ptr2 = passStringToWasm0(study_title, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.solve_mc_study(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var ptr5 = ret[0];
+        var len5 = ret[1];
         if (ret[3]) {
-            ptr3 = 0; len3 = 0;
+            ptr5 = 0; len5 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
     }
 }
 
 /**
- * The stateless solve front door: a [`SolveRequest`](tellegen::SolveRequest) JSON
- * in, a [`SolveResponse`](tellegen::SolveResponse) JSON out. One-shot callers only;
+ * The stateless solve front door: a retained PowerIO module and a
+ * [`tellegen::SolveRequest`] JSON in, a [`tellegen::SolveResponse`] JSON out. One-shot callers only;
  * the reactive hot path is the [`Study`].
- * @param {string} network_json
+ * @param {string} module_json
  * @param {string} request_json
  * @returns {string}
  */
-export function solve_json(network_json, request_json) {
+export function solve_module(module_json, request_json) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(module_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.solve_json(ptr0, len0, ptr1, len1);
+        const ret = wasm.solve_module(ptr0, len0, ptr1, len1);
         var ptr3 = ret[0];
         var len3 = ret[1];
         if (ret[3]) {
@@ -852,21 +1117,109 @@ export function solve_json(network_json, request_json) {
         wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
 }
+
+/**
+ * Create a portable application Study through the shared native controller.
+ * @param {string} request_json
+ * @returns {string}
+ */
+export function study_document_create(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.study_document_create(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);
+    }
+}
+
+/**
+ * Validate and normalize a portable bundle without executing its contents.
+ * @param {string} bundle_json
+ * @returns {string}
+ */
+export function study_document_import(bundle_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(bundle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.study_document_import(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);
+    }
+}
+
+/**
+ * Execute a revision-checked Study operation and return the completed bundle.
+ * @param {string} bundle_json
+ * @param {string} request_json
+ * @param {Function} cancelled
+ * @returns {Promise<string>}
+ */
+export function study_document_run(bundle_json, request_json, cancelled) {
+    const ptr0 = passStringToWasm0(bundle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.study_document_run(ptr0, len0, ptr1, len1, cancelled);
+    return ret;
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
+        __wbg_Error_67e7344beaa85059: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_is_undefined_721f8decd50c87a3: function(arg0) {
+        __wbg___wbindgen_boolean_get_7a12af2b3f899c5a: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __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_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+        __wbg__wbg_cb_unref_997e73d32238e655: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_call_269c5566fbede3eb: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_error_757e9472f8410341: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -881,6 +1234,42 @@ function __wbg_get_imports() {
             const ret = new Error();
             return ret;
         },
+        __wbg_new_8f72ed7c652bf5a2: 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__convert__closures_____invoke__h0178a8f776e4ef73(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __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__convert__closures_____invoke__h0178a8f776e4ef73(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = 0;
+            }
+        },
         __wbg_now_cace042f68c814d8: function(arg0) {
             const ret = arg0.now();
             return ret;
@@ -889,6 +1278,20 @@ function __wbg_get_imports() {
             const ret = arg0.performance;
             return ret;
         },
+        __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_setTimeout_b92adebff51f057a: function(arg0, arg1) {
+            setTimeout(arg0, arg1);
+        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -896,22 +1299,40 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_static_accessor_GLOBAL_THIS_2fee5048bcca5938: function() {
-            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
+            const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_GLOBAL_ce44e66a4935da8c: function() {
-            const ret = typeof global === 'undefined' ? null : global;
+        __wbg_static_accessor_GLOBAL_THIS_1e7044f654e934db: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_SELF_44f6e0cb5e67cdad: function() {
+        __wbg_static_accessor_SELF_d8b50611246a6d92: function() {
             const ret = typeof self === 'undefined' ? null : self;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_WINDOW_168f178805d978fe: function() {
+        __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: 498, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h42fc1c09ce4112c3);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -928,6 +1349,20 @@ function __wbg_get_imports() {
     };
 }
 
+function wasm_bindgen__convert__closures_____invoke__h42fc1c09ce4112c3(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h42fc1c09ce4112c3(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h0178a8f776e4ef73(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h0178a8f776e4ef73(arg0, arg1, arg2, arg3);
+}
+
+const McPfSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcpfsession_free(ptr, 1));
 const StudyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_study_free(ptr, 1));
@@ -938,6 +1373,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));
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -958,10 +1397,47 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 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 passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -1054,11 +1530,15 @@ function __wbg_finalize_init(instance, module) {
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
             } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
+                const validResponse = expectedResponseType(module.type);
 
                 if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);