@tellegen/engine 0.2.0 → 0.4.0

package/dist/wasm-pkg/tellegen.js

@@ -1,17 +1,315 @@
 /* @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. Ordinary edits return the compact summary; detailed terminal
+ * and equipment values are fetched on demand.
+ */
+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);
+    }
+    /**
+     * Phase timings of the session's parse, preparation, factorization, and first solve.
+     * @returns {string}
+     */
+    cold_profile() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcpfsession_cold_profile(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);
+        }
+    }
+    /**
+     * One bounded page of terminal and equipment values for a bus or element.
+     * @param {string} query_json
+     * @returns {string}
+     */
+    detail(query_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mcpfsession_detail(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);
+        }
+    }
+    /**
+     * 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);
+        }
+    }
+    /**
+     * Edited networks materialized for portable output; ordinary edits build none.
+     * @returns {number}
+     */
+    materialization_count() {
+        const ret = wasm.mcpfsession_materialization_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @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;
+    }
+    /**
+     * Phase timings of the most recent solve.
+     * @returns {string}
+     */
+    profile() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcpfsession_profile(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);
+        }
+    }
+    /**
+     * Replace the absolute branch-power edit state, solve with the retained
+     * factorization and previous converged voltage, and return the summary.
+     * @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 complete terminal and equipment result, built on demand. Its size
+     * grows with the network; the interactive path uses `summary`/`detail`.
+     * @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);
+        }
+    }
+    /**
+     * The compact summary of the current operating point (constant size).
+     * @returns {string}
+     */
+    summary() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcpfsession_summary(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);
+        }
+    }
+    /**
+     * Currents injected into the network as interleaved `[re, im]` amperes.
+     * @returns {Float64Array}
+     */
+    terminal_currents() {
+        const ret = wasm.mcpfsession_terminal_currents(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Terminal identities as `[bus, terminal]` pairs in calculation order.
+     * They never change for a session, so a host fetches them once.
+     * @returns {string}
+     */
+    terminal_ids() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcpfsession_terminal_ids(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);
+        }
+    }
+    /**
+     * Terminal voltages as interleaved `[re, im]` volts (a `Float64Array`).
+     * @returns {Float64Array}
+     */
+    terminal_voltages() {
+        const ret = wasm.mcpfsession_terminal_voltages(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+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 +330,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 +390,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 +435,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 +454,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 +577,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_instance_module() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            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_package() {
+    save_module() {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.study_save_package(this.__wbg_ptr);
+            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]) {
@@ -247,11 +650,274 @@ export class Study {
      * The most recent committed solution as `SolveResponse` JSON.
      * @returns {string}
      */
-    solution() {
+    solution() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.study_solution(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Study.prototype[Symbol.dispose] = Study.prototype.free;
+
+/**
+ * A synthetic preview as flat arrays: bus `[lon, lat]` pairs, kinds (0 load,
+ * 1 substation, 2 generator, 3 converter) and kV in bus order, branch route
+ * points, the index where each route starts (one entry more than there are
+ * branches) and branch kV.
+ */
+export class SynthPreviewBuffers {
+    static __wrap(ptr) {
+        const obj = Object.create(SynthPreviewBuffers.prototype);
+        obj.__wbg_ptr = ptr;
+        SynthPreviewBuffersFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SynthPreviewBuffersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_synthpreviewbuffers_free(ptr, 0);
+    }
+    /**
+     * @returns {Float32Array}
+     */
+    branch_kv() {
+        const ret = wasm.synthpreviewbuffers_branch_kv(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    branch_positions() {
+        const ret = wasm.synthpreviewbuffers_branch_positions(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    branch_start_indices() {
+        const ret = wasm.synthpreviewbuffers_branch_start_indices(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    bus_kinds() {
+        const ret = wasm.synthpreviewbuffers_bus_kinds(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Float32Array}
+     */
+    bus_kv() {
+        const ret = wasm.synthpreviewbuffers_bus_kv(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    bus_positions() {
+        const ret = wasm.synthpreviewbuffers_bus_positions(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) SynthPreviewBuffers.prototype[Symbol.dispose] = SynthPreviewBuffers.prototype.free;
+
+/**
+ * A staged synthetic generation: one bounded stage per `advance`, a map
+ * preview between stages, and the module, the report and the drop-panel
+ * payload once it is done.
+ */
+export class SynthSession {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SynthSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_synthsession_free(ptr, 0);
+    }
+    /**
+     * Run one stage (one calibration iteration for `calibrate`); returns the
+     * `StepOutcome` JSON.
+     * @returns {string}
+     */
+    advance() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.synthsession_advance(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);
+        }
+    }
+    /**
+     * The network as GridFM graphkit JSON (per-unit feature matrices on a
+     * 0-based bus index), from `electrify` on.
+     * @returns {string}
+     */
+    export_gridfm() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.synthsession_export_gridfm(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);
+        }
+    }
+    /**
+     * The drop-panel payload of the module (the `ingest_case` shape with
+     * `module_json`).
+     * @returns {string}
+     */
+    ingest() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.synthsession_ingest(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);
+        }
+    }
+    /**
+     * The module as generation 2 PowerIO IR text, with bus locations and
+     * branch routes, from `electrify` on.
+     * @returns {string}
+     */
+    module() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.synthsession_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);
+        }
+    }
+    /**
+     * Open a session at the `context` stage. `osm_json` is the Overpass
+     * document (one, or a JSON array of documents) for `source: "osm"`.
+     * @param {string} request_json
+     * @param {string | null} [osm_json]
+     */
+    constructor(request_json, osm_json) {
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(osm_json) ? 0 : passStringToWasm0(osm_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.synthsession_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        SynthSessionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * The map preview as `Preview` JSON records.
+     * @returns {string}
+     */
+    preview() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.synthsession_preview(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);
+        }
+    }
+    /**
+     * The map preview as flat arrays for binary map attributes, computed
+     * once; read each array, then `free()` the buffers.
+     * @returns {SynthPreviewBuffers}
+     */
+    preview_buffers() {
+        const ret = wasm.synthsession_preview_buffers(this.__wbg_ptr);
+        return SynthPreviewBuffers.__wrap(ret);
+    }
+    /**
+     * The `GenerationReport` JSON, partial until the session is done.
+     * @returns {string}
+     */
+    report() {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.study_solution(this.__wbg_ptr);
+            const ret = wasm.synthsession_report(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -265,23 +931,39 @@ export class Study {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * The stage the next `advance` runs.
+     * @returns {string}
+     */
+    stage() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.synthsession_stage(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
 }
-if (Symbol.dispose) Study.prototype[Symbol.dispose] = Study.prototype.free;
+if (Symbol.dispose) SynthSession.prototype[Symbol.dispose] = SynthSession.prototype.free;
 
 /**
  * Fill case coordinates from a PowerWorld `.pwd` sibling: substation symbols
  * 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 +988,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 +1020,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 +1050,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.
@@ -414,25 +1125,55 @@ 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
+ * 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} module_json
+ * @returns {string}
+ */
+export function extract_geo(module_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        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];
+        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);
+    }
+}
+
+/**
+ * Everything the drop panel needs from one parse: counts, total load and
+ * 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.
+ *
+ * Takes the dropped file's bytes, as [`parse_case`] does and for the same
+ * reason.
+ * @param {Uint8Array} bytes
  * @param {string} format
  * @returns {string}
  */
-export function export_study(package_json, commit, format) {
+export function ingest_case(bytes, format) {
     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 ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.export_study(ptr0, len0, commit, ptr1, len1);
+        const ret = wasm.ingest_case(ptr0, len0, ptr1, len1);
         var ptr3 = ret[0];
         var len3 = ret[1];
         if (ret[3]) {
@@ -448,19 +1189,91 @@ export function export_study(package_json, commit, format) {
 }
 
 /**
- * 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
+ * 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` 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
+ * the private `dist` adapter).
+ *
+ * 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
+ * @param {string} format
+ * @returns {string}
+ */
+export function ingest_dist_case(text, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        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 len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ingest_dist_case(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);
+    }
+}
+
+/**
+ * Byte counterpart of [`ingest_dist_case`] for dropped files.
+ * @param {Uint8Array} bytes
+ * @param {string} format
+ * @returns {string}
+ */
+export function ingest_dist_case_bytes(bytes, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ingest_dist_case_bytes(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);
+    }
+}
+
+/**
+ * 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. 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}
  */
-export function extract_geo(network_json) {
+export function ingest_json_drop(bytes) {
     let deferred3_0;
     let deferred3_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.extract_geo(ptr0, len0);
+        const ret = wasm.ingest_json_drop(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -476,19 +1289,37 @@ 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
- * 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.
+ * Engine heap accounting: live and peak bytes held by the WASM allocator
+ * (peak since the last reset) and the size of linear memory, which only
+ * grows. Native builds report zeros.
+ * @returns {string}
+ */
+export function memory_stats() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.memory_stats();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Parse a case file (MATPOWER, PSS/E RAW, PowerWorld aux, PowerModels or
+ * egret JSON) and return `{"network": ..., "diagnostics": [...]}` as JSON.
  *
- * Takes the dropped file's bytes, as [`parse_case`] does and for the same
- * reason.
+ * 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_case(bytes, format) {
+export function parse_case(bytes, format) {
     let deferred4_0;
     let deferred4_1;
     try {
@@ -496,46 +1327,134 @@ export function ingest_case(bytes, format) {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.ingest_case(ptr0, len0, ptr1, len1);
+        const ret = wasm.parse_case(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);
+    }
+}
+
+/**
+ * Decode a PowerWorld drawing as a canonical PowerIO GeoLayer in diagram units.
+ * @param {Uint8Array} bytes
+ * @param {string} format
+ * @returns {string}
+ */
+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 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]) {
+            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);
+    }
+}
+
+/**
+ * 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 parse_geo(bytes, hint) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        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]) {
             ptr3 = 0; len3 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Validate and canonicalize a saved multiconductor Study snapshot without
+ * re-solving it.
+ * @param {string} snapshot_json
+ * @returns {string}
+ */
+export function replay_mc_study(snapshot_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(snapshot_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.replay_mc_study(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(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
 
 /**
- * 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,
- * coordinate provenance, and the bus/terminal graph the frontend renders (see
- * [`dist`]).
- *
- * Untrusted input: the parse and package restore return error strings (mapped
- * to `JsError` here), so a malformed, truncated, or oversized `.dss`/JSON
- * rejects cleanly and never panics the wasm instance.
+ * Start a new peak-heap window at the current live size.
+ */
+export function reset_peak_memory() {
+    wasm.reset_peak_memory();
+}
+
+/**
+ * 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} format
+ * @param {string} options_json
  * @returns {string}
  */
-export function ingest_dist_case(text, format) {
+export function solve_mc_bmopf(text, options_json) {
     let deferred4_0;
     let deferred4_1;
     try {
         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.ingest_dist_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]) {
@@ -551,20 +1470,21 @@ export function ingest_dist_case(text, format) {
 }
 
 /**
- * Byte counterpart of [`ingest_dist_case`] for dropped files.
- * @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 ingest_dist_case_bytes(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.ingest_dist_case_bytes(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]) {
@@ -580,106 +1500,85 @@ 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.
- * @param {Uint8Array} bytes
- * @returns {string}
- */
-export function ingest_json_drop(bytes) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ingest_json_drop(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);
-    }
-}
-
-/**
- * [`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
+ * 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 ingest_model_json(network_json) {
-    let deferred3_0;
-    let deferred3_1;
+export function solve_mc_study(module_json, study_id, study_title, options_json) {
+    let deferred6_0;
+    let deferred6_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.ingest_model_json(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ptr1 = passStringToWasm0(study_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        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]) {
-            ptr2 = 0; len2 = 0;
+            ptr5 = 0; len5 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
     }
 }
 
 /**
- * Byte counterpart of [`ingest_model_json`] for dropped files. UTF-8 decoding
- * and model validation both stay in powerio.
- * @param {Uint8Array} bytes
+ * 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} module_json
+ * @param {string} request_json
  * @returns {string}
  */
-export function ingest_model_json_bytes(bytes) {
-    let deferred3_0;
-    let deferred3_1;
+export function solve_module(module_json, request_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 ret = wasm.ingest_model_json_bytes(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.solve_module(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
+ * Create a portable application Study through the shared native controller.
+ * @param {string} request_json
  * @returns {string}
  */
-export function load_package(package_json) {
+export function study_document_create(request_json) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passStringToWasm0(package_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.load_package(ptr0, len0);
+        const ret = wasm.study_document_create(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -695,17 +1594,17 @@ export function load_package(package_json) {
 }
 
 /**
- * Byte counterpart of [`load_package`] for a dropped package.
- * @param {Uint8Array} bytes
+ * Validate and normalize a portable bundle without executing its contents.
+ * @param {string} bundle_json
  * @returns {string}
  */
-export function load_package_bytes(bytes) {
+export function study_document_import(bundle_json) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passStringToWasm0(bundle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.load_package_bytes(ptr0, len0);
+        const ret = wasm.study_document_import(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -721,60 +1620,36 @@ 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
- * @returns {string}
+ * 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 parse_case(bytes, format) {
-    let deferred4_0;
-    let deferred4_1;
-    try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        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]) {
-            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);
-    }
+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;
 }
 
 /**
- * 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
+ * Run every stage of a synthetic generation: `{module_json, report, ingest}`.
+ * @param {string} request_json
+ * @param {string | null} [osm_json]
  * @returns {string}
  */
-export function parse_display(bytes, format) {
+export function synth_generate(request_json, osm_json) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passStringToWasm0(request_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.parse_display(ptr0, len0, ptr1, len1);
+        var ptr1 = isLikeNone(osm_json) ? 0 : passStringToWasm0(osm_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.synth_generate(ptr0, len0, ptr1, len1);
         var ptr3 = ret[0];
         var len3 = ret[1];
         if (ret[3]) {
@@ -790,83 +1665,94 @@ 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.
+ * Load the populated places table every synthetic session of this instance
+ * reads (the engine package's `data/populated_places.json`, or any table of
+ * `{n, lo, la, p, c}` rows). Returns `{count, sha256}`.
  * @param {Uint8Array} bytes
- * @param {string} hint
  * @returns {string}
  */
-export function parse_geo(bytes, hint) {
-    let deferred4_0;
-    let deferred4_1;
+export function synth_load_places(bytes) {
+    let deferred3_0;
+    let deferred3_1;
     try {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        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];
+        const ret = wasm.synth_load_places(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
         if (ret[3]) {
-            ptr3 = 0; len3 = 0;
+            ptr2 = 0; len2 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
 
 /**
- * The stateless solve front door: a [`SolveRequest`](tellegen::SolveRequest) JSON
- * in, a [`SolveResponse`](tellegen::SolveResponse) JSON out. One-shot callers only;
- * the reactive hot path is the [`Study`].
- * @param {string} network_json
+ * The Overpass QL queries for a synthetic request's region: a JSON array, two
+ * entries when the region crosses the antimeridian.
  * @param {string} request_json
  * @returns {string}
  */
-export function solve_json(network_json, request_json) {
-    let deferred4_0;
-    let deferred4_1;
+export function synth_overpass_queries(request_json) {
+    let deferred3_0;
+    let deferred3_1;
     try {
-        const ptr0 = passStringToWasm0(network_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(request_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);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
+        const ret = wasm.synth_overpass_queries(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
         if (ret[3]) {
-            ptr3 = 0; len3 = 0;
+            ptr2 = 0; len2 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
+        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_is_undefined_721f8decd50c87a3: function(arg0) {
+        __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+        __wbg__wbg_cb_unref_dcc1a90847f04c41: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_error_757e9472f8410341: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -881,6 +1767,50 @@ function __wbg_get_imports() {
             const ret = new Error();
             return ret;
         },
+        __wbg_new_5502aad30c185fc8: 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__h67ba427e9454f1d8(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_typed_b01cb72a8af741a3: 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__h67ba427e9454f1d8(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_now_8a594da121f77701: function() {
+            const ret = performance.now();
+            return ret;
+        },
+        __wbg_now_aa4ccb83129e9e55: function() {
+            const ret = Date.now();
+            return ret;
+        },
         __wbg_now_cace042f68c814d8: function(arg0) {
             const ret = arg0.now();
             return ret;
@@ -889,6 +1819,20 @@ function __wbg_get_imports() {
             const ret = arg0.performance;
             return ret;
         },
+        __wbg_queueMicrotask_9833f9a49df95a49: function(arg0) {
+            const ret = arg0.queueMicrotask;
+            return ret;
+        },
+        __wbg_queueMicrotask_a72f977e97f23c5f: function(arg0) {
+            queueMicrotask(arg0);
+        },
+        __wbg_resolve_0076e10020304ede: 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 +1840,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_266715b9d96ba635: 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_10fb7dc1ae063179: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_SELF_44f6e0cb5e67cdad: function() {
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
             const ret = typeof self === 'undefined' ? null : self;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_WINDOW_168f178805d978fe: function() {
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_then_c949d5a25a4e78f8: function(arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        },
+        __wbg_then_e71170d78fcf8954: 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: 569, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h1c534e945ee6d3b6);
+            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,9 +1890,29 @@ function __wbg_get_imports() {
     };
 }
 
+function wasm_bindgen__convert__closures_____invoke__h1c534e945ee6d3b6(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h1c534e945ee6d3b6(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h67ba427e9454f1d8(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h67ba427e9454f1d8(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));
+const SynthPreviewBuffersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_synthpreviewbuffers_free(ptr, 1));
+const SynthSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_synthsession_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -938,6 +1920,30 @@ 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 getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -946,10 +1952,34 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -958,10 +1988,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);
@@ -1047,6 +2114,9 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     wasmModule = module;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();
     return wasm;
@@ -1054,11 +2124,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);