@tellegen/svelte 0.1.2 → 0.3.0

package/dist/controller.svelte.js

@@ -3,10 +3,10 @@ import { previewScaleFor, scalarDomain, sensFlatColor, sensitivityDomain } from
 import { caseDeltas as sharedCaseDeltas, caseRatings as sharedCaseRatings, displayMetaFor, displaySeriesFor } from './display.js';
 import { CaseState, LocalCase, MulticonductorCase } from './state.svelte.js';
 import { placeSyntheticTopology } from './synthetic-layout.js';
-import { studyCommitIndex } from './study-package.js';
-import { classifyJson, distExtensionFormat, isGeoFileName } from './drop-classify.js';
-import { buildGeographicView, placeMultiView } from './multiconductor.js';
-import { applyDisplayGeo, applyGeo, applyLayout, createStudy, exportStudy, extractGeo, FORMULATIONS, formatOf, ingestCase, ingestDistCase, isDisplayFile, isPermanentEngineFailure, loadPackage, parseDisplay, parseGeo } from '@tellegen/engine';
+import { distExtensionFormat, isGeoFileName } from './drop-classify.js';
+import { DropBatchGate, readDropFileBytes, validateDropBatch } from './drop-limits.js';
+import { buildGeographicView, buildDiagramView, placeMultiView } from './multiconductor.js';
+import { browserWasmTransport, applyDisplayGeo, applyGeo, applyLayout, createStudy, extractGeo, FORMULATIONS, formatPowerIoDiagnostic, formatOf, ingestCase, ingestDistCaseBytes, ingestJsonDrop, isDisplayFile, isPermanentEngineFailure, parseDisplay, parseGeo } from '@tellegen/engine';
 import { errorText, extent, formulationLabel, rgbaCss } from './format.js';
 const HIDDEN_DEFAULT_CASES_KEY = 'tellegen.hiddenDefaultCases.v1';
 // Open on South Carolina by default: it has the most interesting price action.
@@ -21,6 +21,16 @@ const COMPUTE_OFF_NOTICE = 'solving in this browser did not complete, and server
  * starts anyway: a missing map or a cue that never appears must not stall the
  * selection. */
 const FOCUS_SETTLE_CAP_MS = 1200;
+function previewUnits(sensitivityUnits) {
+    const numerator = sensitivityUnits.replace(/\/(?:MW|MVA)$/, '').trim();
+    const unwrapped = numerator.startsWith('(') && numerator.endsWith(')') ? numerator.slice(1, -1) : numerator;
+    return unwrapped.replaceAll('objective_unit', 'objective units');
+}
+/** A lowered analysis row is view-only only when a current producer says so;
+ * absence keeps payloads from older compatible engine/server versions editable. */
+export function isDisplayOnlyElement(element) {
+    return element?.editable === false;
+}
 function delayUntilFocusSettles(ms, signal) {
     if (ms <= 0 || signal.aborted)
         return Promise.resolve();
@@ -55,6 +65,7 @@ function downloadText(text, filename, mime) {
 export class Controller {
     app;
     api;
+    mcTransport;
     abort = null;
     // While set (epoch ms), the server sensitivity fallback is rate limited: skip
     // the request and show the rate-limit copy instead of burning the budget on a
@@ -64,11 +75,12 @@ export class Controller {
     // Latched once any server fallback answers 403: compute is disabled on this
     // deploy, so later fallbacks show the notice instead of firing doomed requests.
     serverComputeOff = false;
-    // Build-once browser Study per case: the network is parsed and the model built
+    // Build-once browser Study per case: the retained PowerIO module is parsed and the model built
     // when the Study is created, so a drag re-solves (commit) and previews without
     // re-parsing. Kept in a WeakMap off the reactive/raw case payloads — the wasm
     // handle is neither serialized nor part of any $state.
     caseStudies = new WeakMap();
+    detachedCaseCaptures = new WeakMap();
     // Latch a permanent sensitivity-module failure per case so we don't retry
     // createStudy — and the same permanent error — on every drag. Transient
     // failures are not latched.
@@ -83,6 +95,9 @@ export class Controller {
     // In-flight initial case-list load, so a remount during the first fetch dedupes
     // instead of firing a second concurrent load().
     loading = null;
+    // File reads and worker messages retain whole buffers. Admit one validated
+    // batch at a time so repeated drops cannot multiply the aggregate byte cap.
+    dropBatchGate = new DropBatchGate();
     nearbyRangeAnchor = $state(null);
     // Default cases the user has closed; drives the restore affordance. Seeded in load().
     hiddenDefaults = $state(new Set());
@@ -104,6 +119,7 @@ export class Controller {
     constructor(app, options = {}) {
         this.app = app;
         this.api = options.api ?? createApiClient({ apiBase: options.apiBase });
+        this.mcTransport = options.mcTransport ?? browserWasmTransport;
     }
     // ===== helpers =====
     isBackendCase(c) {
@@ -131,6 +147,9 @@ export class Controller {
     isPerturbed(c) {
         return c?.perturbed ?? false;
     }
+    bumpRevision(c) {
+        c.revisionGeneration += 1;
+    }
     setNearbyRangeAnchor(c, bus, delta = this.caseDeltas(c)[bus] ?? 0) {
         this.nearbyRangeAnchor = { caseId: c.id, bus, delta };
     }
@@ -140,6 +159,7 @@ export class Controller {
     // the sensitivity seq the caller guards its async writes with.
     beginBusSelection(c, busId) {
         this.abort?.abort();
+        this.bumpRevision(c);
         const ac = new AbortController();
         this.abort = ac;
         const sensitivitySeq = (c.sensitivitySeq ?? 0) + 1;
@@ -161,6 +181,7 @@ export class Controller {
     // but the selection lands on a branch and the demand preview fields are cleared.
     beginBranchSelection(c, branchId) {
         this.abort?.abort();
+        this.bumpRevision(c);
         const ac = new AbortController();
         this.abort = ac;
         const sensitivitySeq = (c.sensitivitySeq ?? 0) + 1;
@@ -210,45 +231,50 @@ export class Controller {
         this.hiddenDefaults = new Set(hidden);
     }
     localNetwork(c) {
-        if (!c.summary || !c.view)
+        const view = c.displayMode === 'diagram' ? c.diagram?.view : c.view;
+        if (!c.summary || !view)
             return null;
         return {
             id: c.id,
             name: c.label,
             base_mva: c.summary.base_mva,
             synthetic_coords: c.coordsKind !== 'file' && c.coordsKind !== 'geofile',
-            buses: c.view.buses,
-            branches: c.view.branches
+            ...(c.network?.model_details ? { model_details: c.network.model_details } : {}),
+            coordinate_space: view.coordinate_space,
+            buses: view.buses,
+            branches: view.branches
         };
     }
     maybeStartLocalSolve(id) {
         const c = this.app.localCases.find((lc) => lc.id === id);
-        if (!c?.networkJson || !c.view || !c.summary)
+        if (!c?.studyInputJson || (!c.view && !c.diagram) || !c.summary)
             return;
         c.network = this.localNetwork(c) ?? c.network ?? null;
-        if (c.networkJson && c.network && !c.solution)
+        if (c.network && !c.solution)
             this.runSolve(c, null);
     }
-    // The case's Study, building it once for `(networkJson, formulation)` and rebuilding
+    // The case's Study, building it once for `(studyInputJson, formulation)` and rebuilding
     // (after free) if either changed — so picking a new formulation re-parses and re-solves
     // under that formulation. Returns null when the sens module can't load; the caller then
     // falls back to the server, surfacing solveFallbackReason.
-    async getStudy(c, networkJson) {
+    async getStudy(c, studyInputJson) {
         const latched = this.studyUnavailable.get(c);
         if (latched) {
             c.solveFallbackReason ??= latched;
             return null;
         }
         const cached = this.caseStudies.get(c);
-        if (cached && cached.networkJson === networkJson && cached.formulation === c.formulation)
+        if (cached && cached.studyInputJson === studyInputJson && cached.formulation === c.formulation)
             return cached.study;
-        // Coalesce concurrent builds for the same (case, networkJson, formulation): a
+        // Coalesce concurrent builds for the same (case, module, formulation): a
         // bus-select sensitivity fetch and a solve can both reach here before either
         // createStudy resolves. Without this each builds its own wasm Study and the
         // later set() orphans the earlier one (a leaked handle), and the cache can end
         // up holding an instance the live solve never committed on.
         const inflight = this.studyBuilds.get(c);
-        if (inflight && inflight.networkJson === networkJson && inflight.formulation === c.formulation)
+        if (inflight &&
+            inflight.studyInputJson === studyInputJson &&
+            inflight.formulation === c.formulation)
             return inflight.promise;
         // Different params, or no build pending: drop any stale Study before rebuilding.
         if (cached) {
@@ -261,7 +287,7 @@ export class Controller {
         const token = {};
         const build = (async () => {
             try {
-                const study = await createStudy(networkJson, formulation);
+                const study = await createStudy(studyInputJson, formulation);
                 const baseSolution = await study.currentSolution();
                 // The case may have switched formulation or been disposed (removed, or its
                 // list reloaded) while building; don't cache a now-unwanted Study, and free
@@ -270,7 +296,12 @@ export class Controller {
                     study.free();
                     return null;
                 }
-                this.caseStudies.set(c, { study, networkJson, formulation, baseSolution });
+                this.caseStudies.set(c, {
+                    study,
+                    studyInputJson,
+                    formulation,
+                    baseSolution
+                });
                 return study;
             }
             catch (e) {
@@ -288,20 +319,23 @@ export class Controller {
                     this.studyBuilds.delete(c);
             }
         })();
-        this.studyBuilds.set(c, { networkJson, formulation, token, promise: build });
+        this.studyBuilds.set(c, {
+            studyInputJson,
+            formulation,
+            token,
+            promise: build
+        });
         return build;
     }
-    // The ∂LMP/∂parameter column at `target` for the case's active formulation, solved in
+    // The nodal-value/parameter column at `target` for the case's active formulation, solved in
     // the browser. Every column, bus or branch, any formulation, comes from the Study's
     // exact re-solve at the case's operating point. The column is null (with the reason on
     // `solveFallbackReason`) when the Study can't be built; the selection paths then
     // reconcile via the server where a DC endpoint exists. Throws only on a hard browser
     // error.
-    async browserSensitivity(c, networkJson, target) {
-        const study = await this.getStudy(c, networkJson);
-        return study
-            ? study.sensitivity(c.id, this.caseDeltas(c), this.caseRatings(c), target)
-            : null;
+    async browserSensitivity(c, studyInputJson, target) {
+        const study = await this.getStudy(c, studyInputJson);
+        return study ? study.sensitivity(c.id, this.caseDeltas(c), this.caseRatings(c), target) : null;
     }
     // Release a case's Study (if any) when the case is removed.
     disposeStudy(c) {
@@ -343,21 +377,21 @@ export class Controller {
             this.app.previewDeltaMw = null;
             this.app.previewRatingMw = null;
             // The committed solution supersedes the live engine preview.
-            this.app.previewLmp = null;
+            this.app.previewPrices = null;
             this.previewObjective = null;
         }
     }
-    // Fetch and cache the raw powerio Network JSON for the browser solver.
-    // Returns null when it can't be loaded, so callers fall back to the server.
-    async ensureNetworkJson(c) {
+    // Fetch and cache the retained PowerIO module used by every browser Study.
+    // Returns null when it cannot be loaded, so callers can report or fall back.
+    async ensureStudyInputJson(c) {
+        if (c.studyInputJson)
+            return c.studyInputJson;
         if (!this.isBackendCase(c))
-            return c.networkJson ?? null;
-        if (c.networkJson)
-            return c.networkJson;
+            return null;
         try {
-            const json = await this.api.getCaseNetworkJson(c.id);
-            c.networkJson = json;
-            return json;
+            const moduleJson = await this.api.getCaseModuleJson(c.id);
+            c.studyInputJson = moduleJson;
+            return moduleJson;
         }
         catch (e) {
             c.solveFallbackReason = `case fetch failed: ${errorText(e)}`;
@@ -376,7 +410,7 @@ export class Controller {
         return deltas;
     }
     demandBounds(mode, bus, center) {
-        if (!bus)
+        if (!bus || isDisplayOnlyElement(bus))
             return { min: 0, max: 0, span: 0 };
         // Floor, not ceil: -ceil(demand) can push base + delta below zero for
         // non-integer demand, which the server rejects (400) and which is
@@ -384,7 +418,11 @@ export class Controller {
         const physicalMin = -Math.floor(bus.demand_mw);
         const physicalMax = Math.max(Math.ceil(bus.demand_mw), 50);
         if (mode === 'full')
-            return { min: physicalMin, max: physicalMax, span: physicalMax - physicalMin };
+            return {
+                min: physicalMin,
+                max: physicalMax,
+                span: physicalMax - physicalMin
+            };
         const span = Math.max(5, Math.min(25, 0.1 * Math.max(bus.demand_mw, 50)));
         return {
             min: Math.max(physicalMin, center - span),
@@ -403,8 +441,12 @@ export class Controller {
             buses: c.network.buses.length,
             branches: c.network.branches.length,
             objective: c.solution?.objective ?? null,
-            deltaObjective: c.solution && c.baseSolution ? c.solution.objective - c.baseSolution.objective : null,
-            binding: c.solution ? c.solution.flows.filter((f) => f.loading >= 0.999).length : null
+            deltaObjective: c.solution?.objective != null && c.baseSolution?.objective != null
+                ? c.solution.objective - c.baseSolution.objective
+                : null,
+            binding: c.solution && c.formulation !== 'acpf'
+                ? c.solution.flows.filter((f) => f.loading >= 0.999).length
+                : null
         };
     });
     displayOptions = $derived(displayMetaFor(this.activeSolvable));
@@ -416,8 +458,11 @@ export class Controller {
             return null;
         // Drive the values off the resolved mode, not app.displayMode, so the
         // displayOptions[0] fallback holds while displayMode is stale relative to the
-        // formulation (e.g. leaving SOCWR before +page resets it to 'lmp').
-        return { ...activeMeta, values: displaySeriesFor(this.activeSolvable, activeMeta.mode) };
+        // formulation (e.g. leaving SOCWR before +page resets it to price).
+        return {
+            ...activeMeta,
+            values: displaySeriesFor(this.activeSolvable, activeMeta.mode)
+        };
     });
     displayStats = $derived.by(() => {
         if (!this.activeDisplay)
@@ -427,7 +472,7 @@ export class Controller {
             return null;
         const domain = scalarDomain(this.activeDisplay.mode, values);
         const { min, max } = extent(values);
-        const flatThreshold = this.activeDisplay.mode === 'lmp' ? 1 : 1e-5;
+        const flatThreshold = this.activeDisplay.mode === 'price' ? 1 : 1e-5;
         return {
             lo: { value: domain.lo, clamped: min < domain.lo - flatThreshold / 20 },
             hi: { value: domain.hi, clamped: max > domain.hi + flatThreshold / 20 },
@@ -446,8 +491,8 @@ export class Controller {
             return null;
         return c.network.branches.find((b) => b.id === this.app.selectedBranch) ?? null;
     });
-    // The sensitivity target of the current selection: the selected bus (∂LMP/∂d),
-    // else the selected branch (∂LMP/∂rating), else null. Selections are mutually
+    // The sensitivity target of the current selection: the selected bus (price/demand),
+    // else the selected branch (price/rating), else null. Selections are mutually
     // exclusive, so bus-first ordering is only a tiebreak for impossible states.
     selectionTarget = $derived.by(() => this.app.selectedBus !== null
         ? { bus: this.app.selectedBus }
@@ -471,6 +516,7 @@ export class Controller {
     sliderBounds = $derived.by(() => this.demandBounds(this.app.demandRangeMode, this.selectedBusData, this.nearbyRangeCenter));
     sliderMin = $derived(this.sliderBounds.min);
     sliderMax = $derived(this.sliderBounds.max);
+    sliderDisabled = $derived(!this.selectedBusData || isDisplayOnlyElement(this.selectedBusData));
     committedRating = $derived.by(() => this.activeSolvable && this.app.selectedBranch !== null
         ? (this.caseRatings(this.activeSolvable)[this.app.selectedBranch] ?? 0)
         : 0);
@@ -482,10 +528,14 @@ export class Controller {
     // to perturb.
     ratingBounds = $derived.by(() => {
         const b = this.selectedBranchData;
-        if (!b || b.rate_mw <= 0)
+        if (!b || isDisplayOnlyElement(b) || b.rate_mw <= 0)
             return { min: 0, max: 0, disabled: true };
         const span = Math.min(50, Math.max(5, 0.2 * b.rate_mw));
-        return { min: Math.max(-(b.rate_mw - 1), -span), max: span, disabled: false };
+        return {
+            min: Math.max(-(b.rate_mw - 1), -span),
+            max: span,
+            disabled: false
+        };
     });
     selectedSensitivity = $derived.by(() => {
         const c = this.activeSolvable;
@@ -516,9 +566,9 @@ export class Controller {
         const c = this.activeSolvable;
         if (!c?.solution || this.app.selectedBus === null)
             return null;
-        return c.solution.lmp.find((e) => e.bus === this.app.selectedBus)?.usd_per_mwh ?? null;
+        return c.solution.prices.find((e) => e.bus === this.app.selectedBus)?.value ?? null;
     });
-    // Self-sensitivity ∂LMP_bb/∂d at the selected bus: the curvature term the
+    // Self-sensitivity of the selected bus value to demand: the curvature term the
     // first-order fallback uses for a second-order objective estimate. Zero when no
     // sensitivity column is loaded for the bus.
     selfSens = $derived.by(() => {
@@ -530,13 +580,13 @@ export class Controller {
     // engine preview (Study.preview at the committed point, plus the committed part);
     // fall back to a second-order gradient estimate when no Study preview is available
     // (server-only cases, or a browser that can't load the sensitivity module): the
-    // exact committed part plus lmp·step + S_bb·step²/2 along the gradient. The
-    // gradient fallback is demand-only — a rating step has no LMP-at-bus analogue —
+    // exact committed part plus price·step + S_bb·step²/2 along the gradient. The
+    // gradient fallback is demand-only — a rating step has no corresponding bus term —
     // so a branch selection without an engine slope shows no prediction.
     predictedDeltaObj = $derived.by(() => {
         const c = this.activeSolvable;
         const target = this.selectionTarget;
-        if (!c?.solution || !c.baseSolution || target === null)
+        if (c?.solution?.objective == null || c.baseSolution?.objective == null || target === null)
             return null;
         const committedPart = c.solution.objective - c.baseSolution.objective;
         if (this.previewObjective &&
@@ -551,7 +601,10 @@ export class Controller {
     });
     gradientScore = $derived.by(() => {
         const c = this.activeSolvable;
-        if (!c?.solution || !c.baseSolution || c.predictedObjective == null || c.solving)
+        if (c?.solution?.objective == null ||
+            c.baseSolution?.objective == null ||
+            c.predictedObjective == null ||
+            c.solving)
             return null;
         const exact = c.solution.objective - c.baseSolution.objective;
         return { pred: c.predictedObjective, exact };
@@ -605,7 +658,9 @@ export class Controller {
                 this.app.activeLocalId = null;
                 this.app.placingLocalId = null;
                 this.app.activeCaseId =
-                    this.app.cases.find((c) => c.id === DEFAULT_CASE_ID)?.id ?? this.app.cases[0]?.id ?? null;
+                    this.app.cases.find((c) => c.id === DEFAULT_CASE_ID && !c.unavailableReason)?.id ??
+                        this.app.cases.find((c) => !c.unavailableReason)?.id ??
+                        null;
                 const active = this.app.active;
                 if (active)
                     await this.loadBackendCase(active, true);
@@ -625,6 +680,10 @@ export class Controller {
         return this.loading;
     };
     loadBackendCase = async (c, frame = false) => {
+        if (c.unavailableReason) {
+            this.fail(`${c.name}: ${c.unavailableReason}`);
+            return;
+        }
         if (c.network && c.solution && c.baseSolution) {
             if (frame && this.app.activeCaseId === c.id)
                 this.app.requestFrame(c.id);
@@ -636,7 +695,7 @@ export class Controller {
             const [network, dcBaseSolution] = await Promise.all([
                 c.network ? Promise.resolve(c.network) : this.api.getNetwork(c.id),
                 // The server caches only the DC OPF base solution. Other formulations
-                // must hydrate from the browser Study so their cost, prices, flows, and
+                // must hydrate from the browser Study so their objective, nodal values, flows, and
                 // voltage fields all come from the selected formulation.
                 requestedFormulation === 'dcopf' ? this.api.getSolution(c.id) : Promise.resolve(null)
             ]);
@@ -671,10 +730,19 @@ export class Controller {
         this.app.placingMultiId = null;
     }
     activateCase = async (id) => {
+        const candidate = this.app.byId(id);
+        if (!candidate)
+            return;
+        if (candidate.unavailableReason) {
+            this.fail(`${candidate.name}: ${candidate.unavailableReason}`);
+            return;
+        }
+        const inspectedSavedState = this.app.studyView !== null;
+        this.app.studyView = null;
         this.app.activeLocalId = null;
         this.app.placingLocalId = null;
         this.leaveMulti();
-        if (this.app.activeCaseId !== id) {
+        if (inspectedSavedState || this.app.activeCaseId !== id) {
             this.clearSelection();
             this.app.activeCaseId = id;
         }
@@ -710,6 +778,7 @@ export class Controller {
         await this.hydrateFallback(this.app.removeCase(c.id));
     };
     activateLocal = (c) => {
+        this.app.studyView = null;
         this.clearSelection();
         // Mirror activateCase's reset: a local and a backend case are mutually
         // exclusive, so drop the backend selection. Otherwise app.active (derived
@@ -718,8 +787,10 @@ export class Controller {
         this.app.activeCaseId = null;
         this.leaveMulti();
         this.app.activeLocalId = c.id;
-        this.app.placingLocalId = c.coordsKind === 'synthetic_pending' ? c.id : null;
-        if (c.view || c.substations)
+        if (c.formulation === 'acpf' && this.app.displayMode === 'price')
+            this.app.displayMode = 'voltage';
+        this.app.placingLocalId = c.coordsKind === 'synthetic_pending' && !c.diagram ? c.id : null;
+        if (c.view || c.diagram || c.substations)
             this.app.requestFrame(c.id);
         this.maybeStartLocalSolve(c.id);
     };
@@ -735,11 +806,16 @@ export class Controller {
         await this.hydrateFallback(this.app.removeLocal(c.id));
     };
     addAndActivateLocal = (c) => {
+        this.app.studyView = null;
         this.clearSelection();
         this.app.activeCaseId = null;
         this.leaveMulti();
         this.app.addLocal(c);
-        if (c.view || c.substations)
+        if (c.formulation === 'acpf' && this.app.displayMode === 'price')
+            this.app.displayMode = 'voltage';
+        if (c.diagram)
+            this.app.placingLocalId = null;
+        if (c.view || c.diagram || c.substations)
             this.app.requestFrame(c.id);
         this.maybeStartLocalSolve(c.id);
     };
@@ -761,18 +837,18 @@ export class Controller {
     };
     /** Write the case's on-screen layout into its network payload
      * (`Bus.location` with `synthetic` provenance — the engine also accepts
-     * `manual`, which round trips through restored packages), so saves,
+     * `manual`, which round trips through saved PowerIO modules), so saves,
      * exports, and the `.geo.json` download carry it. Best effort: on an
      * engine failure the view still renders, only the layout's persistence is
      * lost. */
     stampLayout = async (c) => {
-        if (!c.networkJson || !c.view)
+        if (!c.studyInputJson || !c.view)
             return;
         try {
             const coords = Object.fromEntries(c.view.buses.map((b) => [b.id, [b.lon, b.lat]]));
-            const stamped = await applyLayout(c.networkJson, coords, 'synthetic');
-            c.networkJson = stamped.network_json;
-            await this.syncCachedStudy(c, stamped.network_json, [stamped.layer]);
+            const stamped = await applyLayout(c.studyInputJson, coords, 'synthetic');
+            c.studyInputJson = stamped.module_json;
+            await this.syncStudyGeo(c, [stamped.layer]);
         }
         catch {
             // The on-screen view is unaffected; only persistence was lost.
@@ -782,10 +858,12 @@ export class Controller {
      * GeoJSON with provenance stamped (`synthetic`/`manual` for layouts), the
      * document powerio and tellegen both read back. */
     downloadGeoLayer = async (c) => {
-        if (!c.networkJson)
+        if (!c.studyInputJson)
             return;
         try {
-            downloadText(await extractGeo(c.networkJson), `${this.caseFileStem(c)}.geo.json`, 'application/geo+json');
+            downloadText(c.displayMode === 'diagram' && c.diagram
+                ? c.diagram.layer
+                : await extractGeo(c.studyInputJson), `${this.caseFileStem(c)}.geo.json`, 'application/geo+json');
             this.app.error = null;
         }
         catch (e) {
@@ -801,23 +879,46 @@ export class Controller {
      * wins on shared elements). The engine owns matching and the network becomes
      * the single owner of the coordinates: matched points land in
      * `Bus.location`, routes in `Branch.route`, and the refreshed
-     * `network_json` replaces the case payload — so a saved package or export
+     * `module_json` replaces the case IR — so a saved module or export
      * carries exactly what is on screen. A live Study is synced the same way.
      * Throws when a layer matches nothing. */
     applyGeoLayers = async (c, layers) => {
-        if (!c.networkJson || layers.length === 0)
+        if (!c.studyInputJson || layers.length === 0)
             return;
         let payload = null;
-        let networkJson = c.networkJson;
+        const geographic = [];
+        for (const entry of layers) {
+            const document = JSON.parse(entry.layer);
+            const space = document.powerio_geo?.space;
+            if (space === 'diagram' || space?.kind === 'diagram') {
+                const payload = await applyGeo(c.studyInputJson, entry.layer);
+                if (payload.view) {
+                    c.diagram = {
+                        view: payload.view,
+                        layer: entry.layer,
+                        name: entry.name,
+                        warnings: payload.report.notes
+                    };
+                    if (!c.view)
+                        c.displayMode = 'diagram';
+                }
+            }
+            else
+                geographic.push(entry);
+        }
+        layers = geographic;
+        if (!layers.length)
+            return;
+        let moduleJson = c.studyInputJson;
         const warnings = [];
         let routes = 0;
         let unmatched = 0;
         for (const l of layers) {
-            payload = await applyGeo(networkJson, l.layer);
-            networkJson = payload.network_json;
+            payload = await applyGeo(moduleJson, l.layer);
+            moduleJson = payload.module_json;
             routes += payload.report.matched_branches;
             unmatched += payload.report.unmatched_features;
-            warnings.push(...l.warnings.map((w) => `${l.name}: ${w}`), ...payload.report.notes.map((n) => `${l.name}: ${n}`));
+            warnings.push(...l.diagnostics.map((d) => `${l.name}: ${formatPowerIoDiagnostic(d)}`), ...payload.report.notes.map((n) => `${l.name}: ${n}`));
         }
         if (!payload)
             return;
@@ -827,56 +928,258 @@ export class Controller {
             ...(unmatched > 0 ? [`${unmatched} feature(s) matched no case element`] : []),
             ...warnings
         ]);
-        await this.syncCachedStudy(c, networkJson, layers.map((l) => l.layer));
+        await this.syncStudyGeo(c, layers.map((l) => l.layer));
     };
     /** Adopt an engine geo apply onto the case: the refreshed payload becomes
      * the case's network and view, provenance flips to the geographic source,
      * and the warnings panel gets the placement summary. */
     adoptGeoPayload(c, payload, sourceLabel, placedFrom, extraWarnings) {
-        c.networkJson = payload.network_json;
+        c.studyInputJson = payload.module_json;
         c.view = payload.view;
         c.coordsKind = 'geofile';
+        c.displayMode = payload.view?.coordinate_space === 'diagram' ? 'diagram' : 'geographic';
         c.syntheticCenter = undefined;
         c.geoSource = sourceLabel;
+        const placedCanonicalBuses = payload.view?.buses.filter((bus) => bus.editable !== false).length ?? 0;
         c.geoWarnings = [
-            `${payload.view?.buses.length ?? 0} of ${payload.n_bus} buses placed from ${placedFrom}`,
+            `${placedCanonicalBuses} of ${payload.n_bus} buses placed from ${placedFrom}`,
             ...extraWarnings,
             ...payload.warnings
         ];
     }
-    /** Keep a live Study's base network in step with a geo change (locations
-     * are metadata the model never reads, so nothing re-solves), and re-key its
-     * cache entry so the next solve reuses it instead of rebuilding. */
-    syncCachedStudy = async (c, networkJson, layers) => {
+    /** Update an existing numerical Study after the base input receives geographic data. */
+    syncStudyGeo = async (c, layers) => {
         const cached = this.caseStudies.get(c);
         if (!cached)
             return;
-        cached.networkJson = networkJson;
-        for (const layer of layers)
-            await cached.study.applyGeoLayer(layer);
+        if (cached.formulation !== c.formulation) {
+            this.disposeStudy(c);
+            return;
+        }
+        try {
+            for (const layer of layers)
+                await cached.study.applyGeoLayer(layer);
+            cached.studyInputJson = c.studyInputJson;
+        }
+        catch (error) {
+            this.disposeStudy(c);
+            throw error;
+        }
     };
-    applyGeoLayersToExisting = async (layers) => {
-        const target = (this.app.activeLocal?.networkJson ? this.app.activeLocal : null) ??
-            this.app.localCases.find((c) => c.coordsKind === 'synthetic_pending' && c.networkJson) ??
-            [...this.app.localCases].reverse().find((c) => c.networkJson);
-        if (!target?.networkJson) {
-            this.app.error =
-                'drop a case file with the geographic file, or select a parsed local case first';
+    caseEditKey(c) {
+        return JSON.stringify([c.formulation, this.caseDeltas(c), this.caseRatings(c)]);
+    }
+    async localSidecarCopy(source) {
+        if (source.solving)
+            throw new Error('Wait for the current solve before attaching coordinates');
+        const revision = source.revisionGeneration;
+        const captured = await this.captureSavedCase(source);
+        const base = await this.ensureStudyInputJson(source);
+        if (!base)
+            throw new Error('The selected case input is unavailable');
+        const parsed = await ingestJsonDrop(new TextEncoder().encode(base));
+        if (!parsed.payload || !('topology' in parsed.payload))
+            throw new Error('The selected case has no balanced network data');
+        const copy = this.localFromBalancedPayload(`${source.name}.pio.json`, {
+            ...parsed.payload,
+            name: `${source.name} (local copy)`
+        });
+        copy.formulation = source.formulation;
+        copy.deltas = { ...source.deltas };
+        copy.ratings = { ...source.ratings };
+        copy.solution = source.solution;
+        copy.baseSolution = source.baseSolution;
+        copy.iterations = source.iterations;
+        copy.solveMs = source.solveMs;
+        copy.solveBackend = source.solveBackend;
+        copy.network = source.network;
+        if (source.network) {
+            copy.view = {
+                buses: source.network.buses,
+                branches: source.network.branches,
+                coordinate_space: source.network.coordinate_space
+            };
+            copy.coordsKind = source.network.synthetic_coords ? 'synthetic' : 'file';
+            if (!source.network.synthetic_coords && source.network.coordinate_space !== 'diagram') {
+                const layer = JSON.stringify({
+                    type: 'FeatureCollection',
+                    powerio_geo: { space: 'geographic' },
+                    features: [
+                        ...source.network.buses.map((bus) => ({
+                            type: 'Feature',
+                            properties: { target: 'bus', id: String(bus.id) },
+                            geometry: { type: 'Point', coordinates: [bus.lon, bus.lat] }
+                        })),
+                        ...source.network.branches
+                            .filter((branch) => branch.path.length > 1)
+                            .map((branch) => ({
+                            type: 'Feature',
+                            properties: {
+                                target: 'branch',
+                                branch_id: String(branch.id),
+                                from: String(branch.from),
+                                to: String(branch.to)
+                            },
+                            geometry: { type: 'LineString', coordinates: branch.path }
+                        }))
+                    ]
+                });
+                const placed = await applyGeo(copy.studyInputJson, layer);
+                copy.studyInputJson = placed.module_json;
+                copy.view = placed.view;
+            }
+        }
+        if (source.revisionGeneration !== revision || source.solving)
+            throw new Error('The selected case changed while loading. Attach the coordinates again');
+        this.detachedCaseCaptures.set(copy, {
+            baseInput: copy.studyInputJson,
+            edits: this.caseEditKey(copy),
+            solution: copy.solution,
+            captured
+        });
+        return copy;
+    }
+    stageLocalSidecars(source) {
+        const copy = new LocalCase({
+            id: source.id,
+            label: source.label,
+            fileName: source.fileName,
+            summary: source.summary,
+            studyInputJson: source.studyInputJson,
+            topology: source.topology,
+            coordsKind: source.coordsKind,
+            view: source.view,
+            substations: source.substations
+        });
+        for (const key of [
+            'diagram',
+            'displayMode',
+            'geoSource',
+            'geoWarnings',
+            'syntheticCenter',
+            'formulation',
+            'deltas',
+            'ratings',
+            'solution',
+            'baseSolution',
+            'iterations',
+            'solveMs',
+            'solveBackend'
+        ])
+            Object.assign(copy, { [key]: source[key] });
+        const captured = this.detachedCaseCaptures.get(source);
+        if (captured)
+            this.detachedCaseCaptures.set(copy, { ...captured });
+        return copy;
+    }
+    async attachSidecarsToSelected(layers, displays = [], expected) {
+        if (this.app.studyView) {
+            this.app.error = 'Return to the live case before attaching coordinates';
             return;
         }
+        const source = this.app.activeMulti ?? this.app.activeLocal ?? this.app.active;
+        if (expected !== undefined && source !== expected) {
+            this.app.error = 'The selected case changed. Attach the coordinates again';
+            return;
+        }
+        if (!source) {
+            this.app.error = 'Select the matching case before attaching coordinates';
+            return;
+        }
+        if (source instanceof MulticonductorCase) {
+            try {
+                await this.applyMultiGeoLayers(source, layers);
+            }
+            catch (error) {
+                this.app.error = errorText(error);
+            }
+            if (displays.length)
+                this.app.error = 'Attach a GeoJSON or CSV drawing to this multiconductor case';
+            return;
+        }
+        const selectedId = source.id;
+        const revision = source.revisionGeneration;
+        let target = null;
         try {
-            await this.applyGeoLayers(target, layers);
+            target =
+                source instanceof CaseState
+                    ? await this.localSidecarCopy(source)
+                    : this.stageLocalSidecars(source);
+            if ((this.app.activeLocal ?? this.app.active)?.id !== selectedId || this.app.studyView)
+                throw new Error('The selected case changed. Attach the coordinates again');
+            const placement = await this.prepareDroppedLocal(target, layers, displays);
+            const applied = placement.geoLayersConsumed || displays.some((display) => display.consumed);
+            if (!applied)
+                throw new Error(placement.error ?? 'No coordinates matched the selected case');
+            if ((this.app.activeLocal ?? this.app.active)?.id !== selectedId ||
+                this.app.studyView ||
+                source.revisionGeneration !== revision)
+                throw new Error('The selected case changed. Attach the coordinates again');
+            const saved = this.detachedCaseCaptures.get(target);
+            if (saved)
+                saved.baseInput = target.studyInputJson;
+            if ((this.app.activeLocal ?? this.app.active)?.id !== selectedId ||
+                this.app.studyView ||
+                source.revisionGeneration !== revision ||
+                source.solving)
+                throw new Error('The selected case changed. Attach the coordinates again');
+            if (source instanceof LocalCase) {
+                const cached = this.caseStudies.get(source);
+                if (cached && target.studyInputJson && target.view) {
+                    const layer = await extractGeo(target.studyInputJson);
+                    try {
+                        await cached.study.applyGeoLayer(layer);
+                    }
+                    catch (error) {
+                        this.disposeStudy(source);
+                        throw error;
+                    }
+                    if ((this.app.activeLocal ?? this.app.active)?.id !== selectedId ||
+                        this.app.studyView ||
+                        source.revisionGeneration !== revision ||
+                        source.solving) {
+                        this.disposeStudy(source);
+                        throw new Error('The selected case changed. Attach the coordinates again');
+                    }
+                    cached.studyInputJson = target.studyInputJson;
+                }
+                for (const key of [
+                    'studyInputJson',
+                    'view',
+                    'diagram',
+                    'displayMode',
+                    'coordsKind',
+                    'geoSource',
+                    'geoWarnings',
+                    'syntheticCenter'
+                ])
+                    Object.assign(source, { [key]: target[key] });
+                if (saved)
+                    this.detachedCaseCaptures.set(source, saved);
+                target = source;
+            }
+            this.app.studyView = null;
+            this.clearSelection();
             this.app.activeCaseId = null;
             this.leaveMulti();
+            if (target !== source)
+                this.app.addLocal(target);
             this.app.activeLocalId = target.id;
             this.app.placingLocalId = null;
+            target.network = this.localNetwork(target);
+            this.bumpRevision(target);
             this.app.requestFrame(target.id);
             this.maybeStartLocalSolve(target.id);
-            this.app.error = null;
+            this.app.error = placement.error;
         }
-        catch (e) {
-            this.app.error = `${layers.map((l) => l.name).join(' + ')}: ${errorText(e)}; use place on map for manual placement`;
+        catch (error) {
+            if (target && target !== source)
+                this.disposeStudy(target);
+            this.app.error = errorText(error);
         }
+    }
+    applyGeoLayersToExisting = async (layers) => {
+        await this.attachSidecarsToSelected(layers);
     };
     /** Ask the map to frame the selected branch and wait for the camera to land,
      * capped by FOCUS_SETTLE_CAP_MS and cut short by the selection's abort. */
@@ -916,13 +1219,15 @@ export class Controller {
                 if (ac.signal.aborted)
                     return;
             }
+            if (c.formulation === 'acpf')
+                return;
             try {
                 // The column from the browser Study (under the case's formulation). DC OPF
                 // may reconcile a null column via the server; AC OPF / SOCWR are browser
                 // only, so a null column there is terminal.
-                const networkJson = await this.ensureNetworkJson(c);
-                if (networkJson) {
-                    const sensitivity = await this.browserSensitivity(c, networkJson, target);
+                const studyInputJson = await this.ensureStudyInputJson(c);
+                if (studyInputJson) {
+                    const sensitivity = await this.browserSensitivity(c, studyInputJson, target);
                     if (!ac.signal.aborted && sensitivity) {
                         this.acceptSensitivity(c, sensitivity, target, sensitivitySeq);
                         handled = true;
@@ -975,7 +1280,7 @@ export class Controller {
     computeOffNotice(c) {
         return this.studyUnavailable.has(c) ? WASM_REQUIRED_NOTICE : COMPUTE_OFF_NOTICE;
     }
-    /** The one server ∂LMP/∂parameter request a selection may make: the
+    /** The one server nodal-value/parameter request a selection may make: the
      * reconciliation path when the browser Study produced no column for a DC OPF
      * case. Never retries on its own: a second request inside the same rate limit
      * window is a guaranteed rejection, and the retry button covers the user
@@ -1041,7 +1346,7 @@ export class Controller {
     };
     selectLocalBus = async (localId, busId) => {
         const c = this.app.localCases.find((lc) => lc.id === localId);
-        if (!c?.networkJson || !c.network)
+        if (!c?.studyInputJson || !c.network)
             return;
         this.app.activeCaseId = null;
         this.leaveMulti();
@@ -1049,14 +1354,20 @@ export class Controller {
         this.app.placingLocalId = null;
         const { ac, sensitivitySeq } = this.beginBusSelection(c, busId);
         try {
-            const sensitivity = await this.browserSensitivity(c, c.networkJson, { bus: busId });
+            if (c.formulation === 'acpf')
+                return;
+            const sensitivity = await this.browserSensitivity(c, c.studyInputJson, {
+                bus: busId
+            });
             if (!ac.signal.aborted)
                 this.acceptSensitivity(c, sensitivity, { bus: busId }, sensitivitySeq);
             if (!ac.signal.aborted && !sensitivity) {
-                // A null column means the solve ran but produced no dLMP/dd for this bus (or the
+                // A null column means the solve ran but produced no price/demand column for this bus (or the
                 // Study could not be built); local cases have no server fallback, so say so
-                // instead of leaving the panel in LMP view with no explanation.
-                this.app.error = `${c.label}: ${formulationLabel(c.formulation)} sensitivity unavailable in the browser${c.solveFallbackReason ? `: ${c.solveFallbackReason}` : ' (no dLMP/dd column for this bus)'}`;
+                // instead of leaving the panel in nodal value view with no explanation.
+                this.app.error = `${c.label}: ${formulationLabel(c.formulation)} sensitivity unavailable in the browser${c.solveFallbackReason
+                    ? `: ${c.solveFallbackReason}`
+                    : ' (no price sensitivity column for this bus)'}`;
             }
         }
         catch (e) {
@@ -1080,7 +1391,7 @@ export class Controller {
     failColumnUnavailable(c, target, retry) {
         const what = 'bus' in target
             ? `${formulationLabel(c.formulation)} sensitivity`
-            : '∂LMP/∂rating sensitivity';
+            : 'price/rating sensitivity';
         this.fail(`${this.caseName(c)}: ${what} unavailable${c.solveFallbackReason ? `: ${c.solveFallbackReason}` : ''}`, retry);
     }
     /** `focus` frames the selected line on the map first; the sensitivity solve
@@ -1088,7 +1399,7 @@ export class Controller {
     selectBranch = (caseId, branchId, opts = {}) => this.selectTarget(caseId, { branch: branchId }, opts.focus ?? false);
     selectLocalBranch = async (localId, branchId, opts = {}) => {
         const c = this.app.localCases.find((lc) => lc.id === localId);
-        if (!c?.networkJson || !c.network)
+        if (!c?.studyInputJson || !c.network)
             return;
         this.app.activeCaseId = null;
         this.leaveMulti();
@@ -1102,7 +1413,11 @@ export class Controller {
                 if (ac.signal.aborted)
                     return;
             }
-            const sensitivity = await this.browserSensitivity(c, c.networkJson, { branch: branchId });
+            if (c.formulation === 'acpf')
+                return;
+            const sensitivity = await this.browserSensitivity(c, c.studyInputJson, {
+                branch: branchId
+            });
             if (ac.signal.aborted)
                 return;
             if (sensitivity) {
@@ -1126,11 +1441,13 @@ export class Controller {
         this.abort?.abort();
         const c = this.app.active;
         if (c) {
+            this.bumpRevision(c);
             c.sensitivitySeq++;
             c.sensitivity = null;
         }
         const lc = this.app.activeLocal;
         if (lc) {
+            this.bumpRevision(lc);
             lc.sensitivitySeq = (lc.sensitivitySeq ?? 0) + 1;
             lc.sensitivity = null;
         }
@@ -1146,7 +1463,7 @@ export class Controller {
         this.app.previewDeltaMw = null;
         this.app.previewRatingMw = null;
         this.app.previewActive = false;
-        this.app.previewLmp = null;
+        this.app.previewPrices = null;
         this.previewObjective = null;
         this.ratingSlope = null;
         this.app.demandRangeMode = 'local';
@@ -1154,12 +1471,14 @@ export class Controller {
         this.app.sensitivityLoading = false;
     };
     // Exact solve in the browser (wasm). The build-once Study commits the new
-    // operating point without re-parsing, returning the ∂LMP/∂parameter column for
-    // the selection target in the same solve; on a Study failure or missing network
-    // JSON it reconciles via the server stream (backend cases). Rating edits never
+    // operating point without re-parsing, returning the nodal-value/parameter column for
+    // the selection target in the same solve; on a Study failure or missing PowerIO
+    // module it reconciles via the server stream (backend cases). Rating edits never
     // fall back: the server solves at base ratings, so a Study failure there is
     // terminal.
     runSolve = (c, target) => {
+        if (c.formulation === 'acpf')
+            target = null;
         // Cancel this case's own previous server stream, if any (backend only).
         if (this.isBackendCase(c)) {
             c.closeStream?.();
@@ -1173,11 +1492,11 @@ export class Controller {
         c.solveFallbackReason = null;
         c.iterations = [];
         c.solveMs = null;
-        this.ensureNetworkJson(c).then(async (networkJson) => {
+        this.ensureStudyInputJson(c).then(async (studyInputJson) => {
             if (seq !== (c.solveSeq ?? 0))
                 return;
-            if (!networkJson) {
-                c.solveFallbackReason ??= 'browser network JSON unavailable';
+            if (!studyInputJson) {
+                c.solveFallbackReason ??= 'PowerIO module unavailable';
                 if (this.hasRatingEdits(c)) {
                     c.solving = false;
                     this.app.error = this.ratingEditsFallbackError(c);
@@ -1186,15 +1505,15 @@ export class Controller {
                 if (this.isBackendCase(c))
                     return this.serverSolve(c, target, seq);
                 c.solving = false;
-                this.app.error = `${c.label}: local case has no browser network JSON`;
+                this.app.error = `${c.label}: local case has no retained PowerIO module`;
                 return;
             }
             const t0 = performance.now();
             c.solveBackend = 'clarabel-wasm';
             // Build-once Study path: commit the new operating point (no re-parse). The
-            // ∂LMP/∂parameter column for the selection target is computed in the same
+            // selected nodal value sensitivity column is computed in the same
             // solve and comes back with it, so there is no second solve to reconcile it.
-            const study = await this.getStudy(c, networkJson);
+            const study = await this.getStudy(c, studyInputJson);
             if (seq !== (c.solveSeq ?? 0))
                 return;
             if (study) {
@@ -1325,18 +1644,21 @@ export class Controller {
     commitDelta = (value) => {
         const c = this.activeSolvable;
         const bus = this.app.selectedBus;
-        if (!c || bus === null)
+        if (!c || bus === null || this.sliderDisabled)
             return;
         // Refresh the engine preview at the commit value (a typed value may not have
         // driven a drag), then score the commit with the engine's predicted Δobjective.
         this.runPreview(c, bus, value);
         c.predictedObjective = this.predictedDeltaObj;
         c.deltas = this.previewDeltas(c, bus, value);
+        this.bumpRevision(c);
         this.app.previewDeltaMw = value;
         this.app.previewActive = true;
         this.runSolve(c, { bus });
     };
     finishDemandInput = (value) => {
+        if (this.sliderDisabled)
+            return;
         if (Math.abs(value - this.committedDelta) < 0.25) {
             if (!this.activeSolvable?.solving) {
                 this.app.previewActive = false;
@@ -1349,8 +1671,9 @@ export class Controller {
     resetCase = (c) => {
         c.deltas = {};
         c.ratings = {};
+        this.bumpRevision(c);
         c.predictedObjective = null;
-        this.app.previewLmp = null;
+        this.app.previewPrices = null;
         this.previewObjective = null;
         this.ratingSlope = null;
         this.app.previewDeltaMw = this.app.selectedBus === null ? null : 0;
@@ -1363,19 +1686,19 @@ export class Controller {
             c.solution = c.baseSolution;
         this.runSolve(c, this.selectionTarget);
     };
-    // Switch the active case to a new OPF formulation. Solving every formulation stays
-    // entirely in the browser via the Study (nothing is routed to the server), so this
-    // disposes the old Study — `getStudy` rebuilds it for the new formulation, re-parsing
-    // and re-solving the base — then re-solves at the committed demand. The base solution
-    // is dropped so it is recaptured under the new formulation (a DC and an AC objective
-    // are not comparable). A no-op when the choice is unchanged.
+    /** Rebuild the numerical Study for a selected calculation at the current demand. */
     changeFormulation = (c, next) => {
         if (c.formulation === next)
             return;
-        // Disabled menu items (e.g. AC OPF, coming soon) are not selectable in the engine yet.
+        if (c instanceof LocalCase && c.declaredFormulation && c.declaredFormulation !== next) {
+            this.fail('This PowerIO instance requires its declared calculation.');
+            return;
+        }
         if (FORMULATIONS.find((f) => f.id === next)?.disabled)
             return;
         c.formulation = next;
+        this.app.displayMode = next === 'acpf' ? 'voltage' : 'price';
+        this.bumpRevision(c);
         // The committed point carries over (same demand), but the model and its solution do
         // not; drop the Study and the cached solutions so they rebuild under `next`.
         this.disposeStudy(c);
@@ -1384,7 +1707,7 @@ export class Controller {
         c.iterations = [];
         c.solveMs = null;
         c.predictedObjective = null;
-        this.app.previewLmp = null;
+        this.app.previewPrices = null;
         this.previewObjective = null;
         this.ratingSlope = null;
         this.app.error = null;
@@ -1395,32 +1718,57 @@ export class Controller {
         this.runSolve(c, this.selectionTarget);
     };
     /** Parse dropped files in the browser via the powerio wasm module. Case
-     * files (.m, .raw, .aux) become local networks; geographic files can
+     * files (.m, .raw, .aux, .epc, .pwb) become local networks; geographic files can
      * place those networks; a PowerWorld .pwd becomes a substation point
      * preview. Files run serially; nothing uploads. */
     ingestFiles = async (files) => {
-        const list = Array.from(files);
+        const release = this.dropBatchGate.enter();
+        if (!release) {
+            this.app.error = 'another file batch is still being parsed';
+            return;
+        }
+        try {
+            let list;
+            try {
+                list = validateDropBatch(files);
+            }
+            catch (e) {
+                this.app.error = errorText(e);
+                return;
+            }
+            await this.ingestFileBatch(list);
+        }
+        catch (e) {
+            this.app.error = errorText(e);
+        }
+        finally {
+            this.app.parsingFile = false;
+            release();
+        }
+    };
+    ingestFileBatch = async (list) => {
+        const sidecarTarget = this.app.activeMulti ?? this.app.activeLocal ?? this.app.active;
         let parsedCaseCount = 0;
-        // True once a dropped case file took the geographic sidecars; a restored
-        // package or an existing case only takes them when no case file did.
-        let geoLayersConsumed = false;
-        // Routable `.json` content (a saved study package, a multiconductor package,
-        // a BMOPF/PMD document) shares the `.json` extension with a geographic file,
-        // so classify and consume it up front: the geo/case split below sends every
-        // `.json` to the coordinate parser, which would misread these as coordinate
-        // data. Unroutable `.json` files fall through unchanged.
+        // Routable `.json` content (saved packages, model JSON, and transmission or
+        // distribution documents) shares the extension with geographic files. Route
+        // it up front, but stage recognized payloads until the geographic/display
+        // sidecars below have parsed. Unrouted JSON retains its first byte buffer so
+        // the geographic fallback does not read a potentially large file twice.
         const rest = [];
-        let restoredAnyPackage = false;
+        const routedJson = [];
+        const jsonBytes = new Map();
         for (const file of list) {
             if (file.name.toLowerCase().endsWith('.json')) {
-                const outcome = await this.ingestJsonDrop(file);
-                if (outcome === 'restored' || outcome === 'viewed') {
+                const route = await this.routeJsonDrop(file);
+                if (route.outcome === 'balanced' || route.outcome === 'multiconductor') {
                     parsedCaseCount++;
-                    restoredAnyPackage ||= outcome === 'restored';
+                    routedJson.push({ file, route });
                     continue;
                 }
-                if (outcome === 'failed')
+                if (route.outcome === 'failed')
                     continue;
+                if (route.bytes)
+                    jsonBytes.set(file, route.bytes);
             }
             rest.push(file);
         }
@@ -1428,8 +1776,14 @@ export class Controller {
         for (const file of rest.filter((f) => isGeoFileName(f.name))) {
             this.app.parsingFile = true;
             try {
-                const parsed = await parseGeo(new Uint8Array(await file.arrayBuffer()), file.name);
-                geoLayers.push({ name: file.name, layer: parsed.layer, warnings: parsed.warnings });
+                const bytes = await readDropFileBytes(file, jsonBytes.get(file));
+                jsonBytes.delete(file);
+                const parsed = await parseGeo(bytes, file.name);
+                geoLayers.push({
+                    name: file.name,
+                    layer: parsed.layer,
+                    diagnostics: parsed.diagnostics
+                });
                 this.app.error = null;
             }
             catch (e) {
@@ -1447,7 +1801,12 @@ export class Controller {
             this.app.parsingFile = true;
             try {
                 const bytes = new Uint8Array(await file.arrayBuffer());
-                displays.push({ file, bytes, preview: await parseDisplay(bytes), consumed: false });
+                displays.push({
+                    file,
+                    bytes,
+                    preview: await parseDisplay(bytes),
+                    consumed: false
+                });
                 this.app.error = null;
             }
             catch (e) {
@@ -1457,23 +1816,64 @@ export class Controller {
                 this.app.parsingFile = false;
             }
         }
+        // Materialize routed JSON cases only after sidecars are ready. This keeps
+        // placement ahead of the first solve and preserves the original JSON order.
+        // `prepareDroppedLocal` is a wasm call that takes seconds on a large case,
+        // and the drop gate refuses a second batch throughout, so the UI has to
+        // keep saying so.
+        if (routedJson.length > 0)
+            this.app.parsingFile = true;
+        try {
+            for (const { file, route } of routedJson) {
+                if (route.outcome === 'multiconductor') {
+                    const multi = this.addMultiCase(file.name, route.payload);
+                    if (geoLayers.length) {
+                        try {
+                            await this.applyMultiGeoLayers(multi, geoLayers);
+                        }
+                        catch (error) {
+                            this.app.error = errorText(error);
+                        }
+                    }
+                    continue;
+                }
+                if (route.outcome !== 'balanced')
+                    continue;
+                const local = this.localFromBalancedPayload(file.name, route.payload);
+                const placement = await this.prepareDroppedLocal(local, geoLayers, displays);
+                this.addAndActivateLocal(local);
+                this.app.error = placement.error;
+            }
+        }
+        finally {
+            this.app.parsingFile = false;
+        }
         for (const file of rest.filter((f) => !isGeoFileName(f.name) && !isDisplayFile(f.name))) {
             // OpenDSS routes by extension into the multiconductor viewing path.
             const distFormat = distExtensionFormat(file.name);
             if (distFormat) {
-                if (await this.ingestDistFile(file, distFormat))
+                if (await this.ingestDistFile(file, distFormat)) {
                     parsedCaseCount++;
+                    if (geoLayers.length && this.app.activeMulti) {
+                        try {
+                            await this.applyMultiGeoLayers(this.app.activeMulti, geoLayers);
+                        }
+                        catch (error) {
+                            this.app.error = errorText(error);
+                        }
+                    }
+                }
                 continue;
             }
             const format = formatOf(file.name);
             if (!format) {
-                this.app.error = `${file.name}: not a case or geographic file (.m, .raw, .aux, .dss, .pwd, .csv, .json, .geojson)`;
+                this.app.error = `${file.name}: not a case or geographic file (.m, .raw, .aux, .epc, .pwb, .dss, .pwd, .csv, .json, .geojson)`;
                 continue;
             }
             this.app.parsingFile = true;
             try {
-                const text = await file.text();
-                const { network_json, topology, view, ...summary } = await ingestCase(text, format);
+                const bytes = new Uint8Array(await file.arrayBuffer());
+                const { module_json, topology, view, ...summary } = await ingestCase(bytes, format);
                 if (format === 'aux' && (summary.n_branch === 0 || summary.n_gen === 0)) {
                     this.app.error = `${file.name}: aux parsed, but no complete network; drop the matching .m or .raw case file`;
                     continue;
@@ -1487,34 +1887,15 @@ export class Controller {
                     label,
                     fileName: file.name,
                     summary,
-                    networkJson: network_json,
+                    studyInputJson: module_json,
                     topology,
                     coordsKind: summary.coords_kind,
                     view
                 });
-                // A co-dropped geographic file places (or repositions) the network. Apply
-                // it for any parsed case, not just synthetic ones, so a geo overlay
-                // dropped alongside a case that already has coordinates takes effect
-                // instead of being silently discarded. A failed apply keeps the parsed
-                // case (placement still works) and surfaces the reason.
-                let geoError = null;
-                if (geoLayers.length > 0 && local.networkJson) {
-                    try {
-                        await this.applyGeoLayers(local, geoLayers);
-                        geoLayersConsumed = true;
-                    }
-                    catch (e) {
-                        geoError = `${geoLayers.map((l) => l.name).join(' + ')}: ${errorText(e)}; use place on map for manual placement`;
-                    }
-                }
-                else if (local.coordsKind === 'synthetic_pending' && local.networkJson) {
-                    // No sidecar: a coordinate-less case may still borrow a co-dropped
-                    // .pwd's substation points through the SubNum join.
-                    await this.fillFromDisplaySibling(local, displays);
-                }
+                const placement = await this.prepareDroppedLocal(local, geoLayers, displays);
                 this.addAndActivateLocal(local);
                 parsedCaseCount++;
-                this.app.error = geoError; // a successful parse clears a prior file's error
+                this.app.error = placement.error; // a successful parse clears a prior file's error
             }
             catch (e) {
                 this.app.error = `${file.name}: ${e instanceof Error ? e.message : e}`;
@@ -1523,92 +1904,147 @@ export class Controller {
                 this.app.parsingFile = false;
             }
         }
-        // A .pwd no case consumed becomes a substation point preview entry, at
-        // the approximate positions the engine projected.
-        for (const d of displays.filter((entry) => !entry.consumed)) {
-            const points = d.preview.substations.map((s) => ({
-                number: s.number,
-                name: s.name,
-                lon: s.lon,
-                lat: s.lat
-            }));
-            this.addAndActivateLocal(new LocalCase({
-                id: `local-${++this.localSeq}`,
-                label: d.file.name.replace(/\.[^.]+$/, ''),
-                fileName: d.file.name,
-                summary: null,
-                view: null,
-                substations: { points, approximate: true }
-            }));
-        }
-        // Unconsumed sidecars apply to the restored package (now the active local
-        // case) so a saved study co-dropped with its coordinates places, or to an
-        // existing case when nothing in the drop parsed at all.
-        if (geoLayers.length > 0 && !geoLayersConsumed && (restoredAnyPackage || parsedCaseCount === 0)) {
-            await this.applyGeoLayersToExisting(geoLayers);
+        if (parsedCaseCount === 0 && (geoLayers.length > 0 || displays.length > 0)) {
+            await this.attachSidecarsToSelected(geoLayers, displays, sidecarTarget);
+        }
+        else {
+            const unmatchedDisplays = displays.filter((display) => !display.consumed);
+            if (unmatchedDisplays.length)
+                this.app.error = `${unmatchedDisplays.map((display) => display.file.name).join(' + ')}: no drawing objects matched the dropped case`;
         }
     };
-    /** Fill a coordinate-less case's positions from a co-dropped PowerWorld
-     * `.pwd`: the display's substation points project to approximate
-     * longitude/latitude and join onto buses through the `SubNum` extras key.
-     * The first display that joins wins; one that matches nothing stays
-     * available as its own preview entry, and the case stays placeable. */
+    /** Apply co-dropped geographic data before a local case becomes active and
+     * starts solving. Without geographic data, let a coordinate-less case borrow
+     * the first matching PowerWorld display. A failed geographic join keeps the
+     * parsed case and returns the user-facing placement error. */
+    prepareDroppedLocal = async (local, geoLayers, displays) => {
+        let geoLayersConsumed = false;
+        let error = null;
+        if (geoLayers.length > 0 && local.studyInputJson) {
+            try {
+                await this.applyGeoLayers(local, geoLayers);
+                geoLayersConsumed = true;
+            }
+            catch (e) {
+                error = `${geoLayers.map((layer) => layer.name).join(' + ')}: ${errorText(e)}`;
+            }
+        }
+        if (local.studyInputJson && displays.length > 0) {
+            await this.fillFromDisplaySibling(local, displays);
+        }
+        if (!local.view && !local.diagram && local.topology) {
+            const view = {
+                ...placeSyntheticTopology(local.topology, { lon: 0, lat: 0 }),
+                coordinate_space: 'diagram'
+            };
+            const layer = JSON.stringify({
+                type: 'FeatureCollection',
+                powerio_geo: { space: 'diagram', kind: 'synthetic' },
+                features: [
+                    ...view.buses.map((b) => ({
+                        type: 'Feature',
+                        properties: { target: 'bus', id: String(b.id) },
+                        geometry: { type: 'Point', coordinates: [b.lon, b.lat] }
+                    })),
+                    ...view.branches.map((b) => ({
+                        type: 'Feature',
+                        properties: {
+                            target: 'branch',
+                            branch_id: String(b.id),
+                            from: String(b.from),
+                            to: String(b.to)
+                        },
+                        geometry: { type: 'LineString', coordinates: b.path }
+                    }))
+                ]
+            });
+            local.diagram = {
+                view,
+                layer,
+                name: 'Network diagram',
+                warnings: ['No geographic coordinates; positions follow network connectivity.']
+            };
+            local.displayMode = 'diagram';
+        }
+        return { geoLayersConsumed, error };
+    };
+    /** Retain diagram geometry separately from the electrical case's geographic data. */
     fillFromDisplaySibling = async (c, displays) => {
-        if (!c.networkJson)
+        if (!c.studyInputJson)
             return;
         for (const d of displays.filter((entry) => !entry.consumed)) {
             try {
-                const payload = await applyDisplayGeo(c.networkJson, d.bytes);
-                this.adoptGeoPayload(c, payload, d.file.name, `${d.file.name} substations`, payload.report.notes);
+                const payload = await applyDisplayGeo(c.studyInputJson, d.bytes);
+                if (!payload.view)
+                    continue;
+                c.diagram = {
+                    view: payload.view,
+                    layer: d.preview.layer,
+                    name: d.file.name,
+                    warnings: [
+                        `${payload.report.matched_buses} buses, ${payload.report.matched_branches} routes matched; ${payload.report.unmatched_features} unmatched objects`,
+                        ...payload.report.notes
+                    ]
+                };
+                if (!c.view)
+                    c.displayMode = 'diagram';
+                c.geoWarnings = [...(c.geoWarnings ?? []), ...c.diagram.warnings];
                 d.consumed = true;
-                return;
             }
-            catch {
-                // No SubNum join against this display; try the next one.
+            catch (error) {
+                c.geoWarnings = [errorText(error)];
             }
         }
     };
-    /** Route a dropped `.json` by its content: a saved study package restores
-     * (`restored`), a multiconductor package or a BMOPF/PMD distribution
-     * document views (`viewed`), `failed` means the content looked routable but
-     * the engine rejected it (a fail-closed message is set), and `not-package`
-     * falls through to the caller's geo/case handling. `drop-classify` is the
-     * single owner of the classification. */
-    ingestJsonDrop = async (file) => {
-        let text;
+    setCaseDisplayMode = (c, mode) => {
+        if (mode === 'diagram' ? !c.diagram : !c.view)
+            return;
+        c.displayMode = mode;
+        c.network = this.localNetwork(c);
+        this.app.requestFrame(c.id);
+    };
+    /** Route a dropped `.json` by its content. Recognized payloads return without
+     * mutating case state so co-dropped sidecars can be applied first; unrouted
+     * content returns the bytes already read for the geographic fallback. */
+    routeJsonDrop = async (file) => {
+        let bytes;
         try {
-            text = await file.text();
+            bytes = await readDropFileBytes(file);
         }
         catch {
-            return 'not-package';
+            return { outcome: 'unrouted', bytes: null };
         }
-        const kind = classifyJson(text);
-        if (kind === 'not-json')
-            return 'not-package';
         this.app.parsingFile = true;
         try {
-            if (kind === 'balanced-package') {
-                this.restoreLocalFromPackage(file.name, await loadPackage(text));
+            const result = await ingestJsonDrop(bytes);
+            if (result.kind === 'unknown')
+                return { outcome: 'unrouted', bytes };
+            if (result.kind === 'ambiguous') {
+                this.app.error = `${file.name}: JSON markers name both transmission and distribution formats`;
+                return { outcome: 'failed' };
+            }
+            if (result.kind === 'transmission') {
                 this.app.error = null;
-                return 'restored';
-            }
-            const format = kind === 'multiconductor-package' ? 'pio' : kind;
-            const payload = await ingestDistCase(text, format);
-            // BMOPF is the classifier's catch-all and its reader is liberal: an
-            // arbitrary JSON object parses as an empty case (unknown fields land
-            // in extras). Zero buses means this was not a distribution document;
-            // leave the file to the geo sidecar path (which places coordinates
-            // or reports its own precise error) instead of adding a phantom
-            // empty multiconductor case.
-            if (kind === 'bmopf' && payload.n_bus === 0)
-                return 'not-package';
-            this.addMultiCase(file.name, payload);
-            this.app.error = null;
-            return 'viewed';
+                return { outcome: 'balanced', payload: result.payload };
+            }
+            if (result.kind === 'module') {
+                // A stored module carries either network family; the payload's own
+                // marker decides the route, mirroring the engine's value kind.
+                this.app.error = null;
+                const payload = result.payload;
+                if ('model' in payload)
+                    return { outcome: 'multiconductor', payload };
+                return { outcome: 'balanced', payload };
+            }
+            if (result.kind === 'distribution') {
+                this.app.error = null;
+                return { outcome: 'multiconductor', payload: result.payload };
+            }
+            throw new Error('engine returned an unsupported JSON drop result');
         }
         catch (e) {
             this.app.error = `${file.name}: ${errorText(e)}`;
-            return 'failed';
+            return { outcome: 'failed' };
         }
         finally {
             this.app.parsingFile = false;
@@ -1619,7 +2055,8 @@ export class Controller {
     ingestDistFile = async (file, format) => {
         this.app.parsingFile = true;
         try {
-            this.addMultiCase(file.name, await ingestDistCase(await file.text(), format));
+            const bytes = new Uint8Array(await file.arrayBuffer());
+            this.addMultiCase(file.name, await ingestDistCaseBytes(bytes, format));
             this.app.error = null;
             return true;
         }
@@ -1631,14 +2068,14 @@ export class Controller {
             this.app.parsingFile = false;
         }
     };
-    /** Build a `MulticonductorCase` from an ingest payload and make it active.
-     * Geographic cases place immediately; planar/synthetic cases enter placement
-     * (a map click or "place on map") so the user picks their center. */
+    /** Retain parsed electrical inputs and draw each declared coordinate space directly. */
     addMultiCase(fileName, payload) {
         const { graph, ...summary } = payload;
         const coordsKind = payload.coords_kind;
         const label = summary.name && summary.name !== 'case' ? summary.name : fileName.replace(/\.[^.]+$/, '');
-        const view = coordsKind === 'geographic' ? buildGeographicView(graph) : null;
+        const view = coordsKind === 'geographic'
+            ? buildGeographicView(graph, payload.geo_layer)
+            : buildDiagramView(graph, payload.geo_layer);
         const c = new MulticonductorCase({
             id: `dist-${++this.localSeq}`,
             label,
@@ -1648,12 +2085,291 @@ export class Controller {
             coordsKind,
             view
         });
+        this.app.studyView = null;
+        this.clearSelection();
         this.app.addMulti(c);
         if (c.placed)
             this.app.requestFrame(c.id);
+        return c;
     }
+    /** Compute terminal quantities only for the retained input and current case revision. */
+    solveMultiCase = async (c, options = {}, signal) => {
+        if (signal?.aborted)
+            throw new DOMException('Calculation cancelled', 'AbortError');
+        if (c.solving)
+            throw new Error('A calculation is already running for this case');
+        const unavailable = c.mcPfReason;
+        if (unavailable) {
+            this.app.error = unavailable;
+            throw new Error(unavailable);
+        }
+        let input = c.moduleJson;
+        const retainedAtStart = c.mcSession;
+        const revision = c.revisionGeneration;
+        const seq = ++c.solveSeq;
+        const abort = new AbortController();
+        const cancel = () => abort.abort();
+        signal?.addEventListener('abort', cancel, { once: true });
+        c.solveAbort = abort;
+        c.solving = true;
+        this.app.error = null;
+        const started = performance.now();
+        let nextSession = null;
+        try {
+            if (retainedAtStart)
+                input = await retainedAtStart.inputModule();
+            let snapshot = null;
+            let result;
+            let loadBranches = c.mcLoadBranches;
+            if (this.mcTransport.createMcPfSession) {
+                nextSession = await this.mcTransport.createMcPfSession(input, options, abort.signal);
+                [result, loadBranches] = await Promise.all([
+                    nextSession.result(),
+                    nextSession.loadBranches()
+                ]);
+            }
+            else {
+                snapshot = this.mcTransport.solveMcStudy
+                    ? await this.mcTransport.solveMcStudy(input, crypto.randomUUID(), c.label, options, abort.signal)
+                    : null;
+                result =
+                    snapshot?.result ?? (await this.mcTransport.solveMcModule(input, options, abort.signal));
+            }
+            if (abort.signal.aborted)
+                throw new DOMException('Calculation cancelled', 'AbortError');
+            if (seq !== c.solveSeq ||
+                (retainedAtStart ? retainedAtStart !== c.mcSession : input !== c.moduleJson) ||
+                revision !== c.revisionGeneration ||
+                !this.app.multiCases.includes(c))
+                throw new Error('The case changed while calculating. Run AC power flow again');
+            if (!result.converged)
+                throw new Error('AC power flow did not converge');
+            // A load edit staged against the previous session has nothing to
+            // apply to the fresh operating point; drop its pending flush.
+            if (c.mcEditTimer !== null) {
+                clearTimeout(c.mcEditTimer);
+                c.mcEditTimer = null;
+            }
+            c.mcSession?.free();
+            c.mcSession = nextSession;
+            nextSession = null;
+            c.mcLoadBranches = loadBranches;
+            c.mcLoadEdits = [];
+            c.moduleJson = input;
+            c.result = result;
+            c.mcSnapshot = snapshot;
+            c.mcSavedAt = null;
+            c.solveMs = performance.now() - started;
+            c.revisionGeneration++;
+            return result;
+        }
+        catch (error) {
+            nextSession?.free();
+            if (!abort.signal.aborted &&
+                !(error instanceof DOMException && error.name === 'AbortError')) {
+                this.app.error = errorText(error);
+                this.app.errorRetry = () => {
+                    void this.solveMultiCase(c, options).catch(() => { });
+                };
+            }
+            throw error;
+        }
+        finally {
+            signal?.removeEventListener('abort', cancel);
+            if (c.solveSeq === seq) {
+                c.solving = false;
+                c.solveAbort = null;
+            }
+        }
+    };
+    /** Materialize the current retained operating point only when a portable
+     * snapshot is actually needed (save/export/geography). */
+    snapshotMultiCase = async (c) => {
+        if (c.mcSnapshot)
+            return c.mcSnapshot;
+        const session = c.mcSession;
+        if (!session || !c.result)
+            throw new Error('Run AC power flow before saving its result');
+        if (c.solving)
+            throw new Error('Wait for the calculation before saving its result');
+        const revision = c.revisionGeneration;
+        const snapshot = await session.snapshot(crypto.randomUUID(), c.label);
+        if (session !== c.mcSession ||
+            revision !== c.revisionGeneration ||
+            !this.app.multiCases.includes(c))
+            throw new Error('The case changed while preparing its result');
+        c.mcSnapshot = snapshot;
+        return snapshot;
+    };
+    /** Apply coordinates atomically to the explicitly selected conductor-resolved case. */
+    applyMultiGeoLayers = async (c, layers) => {
+        if (!layers.length)
+            return;
+        if (this.app.studyView || this.app.activeMulti !== c)
+            throw new Error('Select the matching case before attaching coordinates');
+        if (c.solving)
+            throw new Error('Wait for the calculation before attaching coordinates');
+        if (!c.moduleJson || !this.mcTransport.applyMcGeo)
+            throw new Error('Coordinate attachment is unavailable for this case');
+        const baseInput = c.moduleJson;
+        const retainedAtStart = c.mcSession;
+        let snapshot = c.mcSnapshot;
+        if (!snapshot && c.mcSession && c.result)
+            snapshot = await this.snapshotMultiCase(c);
+        const input = snapshot?.input_module ?? c.moduleJson;
+        const revision = c.revisionGeneration;
+        let next = input;
+        let payload;
+        const notes = [];
+        let matched = 0;
+        for (const layer of layers) {
+            payload = await this.mcTransport.applyMcGeo(next, layer.layer);
+            if (snapshot) {
+                if (!this.mcTransport.applyMcStudyGeo)
+                    throw new Error('Saved result coordinates are unavailable in this build');
+                snapshot = await this.mcTransport.applyMcStudyGeo(snapshot, layer.layer);
+            }
+            if (!payload.module_json)
+                throw new Error('Coordinate attachment returned no electrical input');
+            next = payload.module_json;
+            matched += payload.report.matched_buses + payload.report.matched_branches;
+            notes.push(`${payload.report.matched_buses} buses, ${payload.report.matched_branches} routes matched; ${payload.report.unmatched_features} unmatched objects`, ...payload.report.notes, ...layer.diagnostics.map(formatPowerIoDiagnostic));
+        }
+        if (!payload || !matched)
+            throw new Error('No coordinates matched the selected case');
+        if (this.app.studyView ||
+            this.app.activeMulti !== c ||
+            c.moduleJson !== baseInput ||
+            c.mcSession !== retainedAtStart ||
+            c.revisionGeneration !== revision ||
+            c.solving)
+            throw new Error('The selected case changed. Attach the coordinates again');
+        const { graph, ...summary } = payload;
+        if (c.mcEditTimer !== null) {
+            clearTimeout(c.mcEditTimer);
+            c.mcEditTimer = null;
+        }
+        c.mcSession?.free();
+        c.mcSession = null;
+        c.mcLoadBranches = [];
+        c.mcLoadEdits = [];
+        c.moduleJson = next;
+        c.mcSnapshot = snapshot ? { ...snapshot, id: crypto.randomUUID() } : null;
+        c.mcSavedAt = null;
+        c.geoLayer = payload.geo_layer ?? null;
+        c.graph = graph;
+        c.summary = summary;
+        c.coordsKind = payload.coords_kind;
+        c.view =
+            payload.coords_kind === 'geographic'
+                ? buildGeographicView(graph, payload.geo_layer)
+                : buildDiagramView(graph, payload.geo_layer);
+        c.geoWarnings = notes;
+        c.revisionGeneration++;
+        this.app.placingMultiId = null;
+        this.app.error = null;
+        this.app.requestFrame(c.id);
+    };
+    /** Stage an absolute load-branch P/Q edit and coalesce rapid UI changes into
+     * one retained-factor warm solve. */
+    queueMultiLoadPower = (c, load, branch, p_w, q_var) => {
+        if (!c.mcSession) {
+            this.app.error = 'Run AC power flow once before editing loads';
+            return;
+        }
+        if (!Number.isFinite(p_w) || !Number.isFinite(q_var)) {
+            this.app.error = 'Load P and Q must be finite numbers';
+            return;
+        }
+        const row = c.mcLoadBranches.find((entry) => entry.load === load && entry.branch === branch);
+        if (!row) {
+            this.app.error = `Load ${load} branch ${branch} is unavailable`;
+            return;
+        }
+        c.mcLoadBranches = c.mcLoadBranches.map((entry) => entry.load === load && entry.branch === branch ? { ...entry, p_w, q_var } : entry);
+        const next = { load, branch, p_w, q_var };
+        const without = c.mcLoadEdits.filter((edit) => edit.load !== load || edit.branch !== branch);
+        c.mcLoadEdits = p_w === row.base_p_w && q_var === row.base_q_var ? without : [...without, next];
+        c.mcEditRevision++;
+        c.mcSnapshot = null;
+        c.mcSavedAt = null;
+        c.solving = true;
+        if (c.mcEditTimer !== null)
+            clearTimeout(c.mcEditTimer);
+        c.mcEditTimer = setTimeout(() => {
+            c.mcEditTimer = null;
+            void this.flushMultiLoadPowers(c);
+        }, 180);
+    };
+    flushMultiLoadPowers = async (c) => {
+        // A running flush picks the new revision up in its own loop.
+        if (c.mcEditRunning)
+            return;
+        const session = c.mcSession;
+        if (!session || !this.app.multiCases.includes(c)) {
+            // `queueMultiLoadPower` marked the case as solving on behalf of
+            // this flush; release it, or Save and Export stay disabled.
+            c.solving = false;
+            return;
+        }
+        c.mcEditRunning = true;
+        c.solving = true;
+        this.app.error = null;
+        try {
+            for (;;) {
+                const revision = c.mcEditRevision;
+                const edits = c.mcLoadEdits.map((edit) => ({ ...edit }));
+                const started = performance.now();
+                const result = await session.replaceLoadPowers(edits);
+                if (session !== c.mcSession || !this.app.multiCases.includes(c))
+                    return;
+                if (revision !== c.mcEditRevision)
+                    continue;
+                const loadBranches = await session.loadBranches();
+                if (revision !== c.mcEditRevision)
+                    continue;
+                c.mcLoadBranches = loadBranches;
+                c.result = result;
+                c.mcSnapshot = null;
+                c.mcSavedAt = null;
+                c.solveMs = performance.now() - started;
+                c.revisionGeneration++;
+                break;
+            }
+        }
+        catch (error) {
+            if (session === c.mcSession) {
+                try {
+                    c.mcLoadBranches = await session.loadBranches();
+                }
+                catch {
+                    // The session itself no longer answers (the worker trapped
+                    // or the handle is gone). Retrying against it would fail
+                    // forever, so drop it and let the next run rebuild the
+                    // session against a fresh worker.
+                    session.free();
+                    c.mcSession = null;
+                    c.mcLoadEdits = [];
+                }
+            }
+            this.app.error = errorText(error);
+            this.app.errorRetry = c.mcSession
+                ? () => void this.flushMultiLoadPowers(c)
+                : () => void this.solveMultiCase(c).catch(() => { });
+        }
+        finally {
+            // The running flag belongs to this call regardless of whether the
+            // session was replaced meanwhile; leaving it set would silently
+            // ignore every later edit. The solving flag is shared with an
+            // explicit solve, which clears it itself when it owns it.
+            c.mcEditRunning = false;
+            if (session === c.mcSession || c.mcSession === null)
+                c.solving = false;
+        }
+    };
     /** Make a multiconductor case active, framing it when it is placed. */
     activateMulti = (c) => {
+        this.app.studyView = null;
         this.clearSelection();
         this.app.activeCaseId = null;
         this.app.activeLocalId = null;
@@ -1711,6 +2427,11 @@ export class Controller {
     };
     removeMultiCase = async (c, event) => {
         event?.stopPropagation();
+        c.solveAbort?.abort();
+        if (c.mcEditTimer !== null)
+            clearTimeout(c.mcEditTimer);
+        c.mcSession?.free();
+        c.mcSession = null;
         if (this.app.activeMultiId === c.id) {
             c.selectedBusId = null;
             c.selectedEdgeId = null;
@@ -1725,37 +2446,89 @@ export class Controller {
         else
             this.placeLocalCase(lon, lat);
     };
-    /** Build a local case from a restored study package: the same shape a dropped case
-     * takes, with the saved demand/rating deltas and formulation pre-applied. */
-    restoreLocalFromPackage = (fileName, pkg) => {
-        const { network_json, topology, view, formulation, deltas, rates, ...summary } = pkg;
-        const id = `local-${++this.localSeq}`;
+    async projectStudyInput(input, layer) {
+        const parsed = layer
+            ? { payload: await applyGeo(input, layer) }
+            : await ingestJsonDrop(new TextEncoder().encode(input));
+        if (!parsed.payload || !('topology' in parsed.payload))
+            throw new Error('Study requires a balanced network');
+        const c = parsed.payload;
+        const view = c.view ?? {
+            ...placeSyntheticTopology(c.topology, { lon: 0, lat: 0 }),
+            coordinate_space: 'diagram'
+        };
+        return { id: 'study', name: c.name, base_mva: c.base_mva, synthetic_coords: !c.view, ...view };
+    }
+    async caseGeographyLayers(c) {
+        if (!c.studyInputJson || !c.view)
+            return [];
+        return [await extractGeo(c.studyInputJson)];
+    }
+    /** Capture a matching cached result without constructing or solving a model. */
+    async captureSavedCase(c) {
+        const base = await this.ensureStudyInputJson(c);
+        if (!base)
+            throw new Error('The case input is unavailable');
+        const detached = c instanceof LocalCase ? this.detachedCaseCaptures.get(c) : undefined;
+        if (detached?.baseInput === base &&
+            detached.edits === this.caseEditKey(c) &&
+            detached.solution === c.solution)
+            return detached.captured;
+        const cached = this.caseStudies.get(c);
+        if (c.solution && cached?.studyInputJson === base && cached.formulation === c.formulation) {
+            const current = await cached.study.currentSolution();
+            if (JSON.stringify(current) === JSON.stringify(c.solution)) {
+                return {
+                    input: await cached.study.saveInstanceModule(),
+                    solution: await cached.study.saveSolutionModule(),
+                    view: await cached.study.currentView()
+                };
+            }
+        }
+        if (Object.values(this.caseDeltas(c)).some((v) => v !== 0) ||
+            Object.values(this.caseRatings(c)).some((v) => v !== 0)) {
+            throw new Error('The displayed edits have no matching saved result. Finish solving before saving them.');
+        }
+        if (c instanceof CaseState &&
+            c.solution &&
+            c.formulation === 'dcopf' &&
+            this.api.getSavedCase) {
+            const snapshot = await this.api.getSavedCase(c.id);
+            if (snapshot.base_input !== base ||
+                JSON.stringify(snapshot.display_solution) !== JSON.stringify(c.solution))
+                throw new Error('The server case changed. Reload it before saving.');
+            return { input: snapshot.input, solution: snapshot.solution, view: snapshot.view };
+        }
+        return { input: base };
+    }
+    /** Build a local case from a balanced PowerIO ingest payload without activating
+     * it yet; co-dropped placement data is applied before the first solve. */
+    localFromBalancedPayload = (fileName, payload) => {
+        const { module_json, topology, view, formulation, ...summary } = payload;
         const label = summary.name && summary.name !== 'case' ? summary.name : fileName.replace(/\.[^.]+$/, '');
-        const local = new LocalCase({
-            id,
+        return new LocalCase({
+            id: `local-${++this.localSeq}`,
             label,
             fileName,
+            formulation,
+            declaredFormulation: formulation,
             summary,
-            networkJson: network_json,
+            studyInputJson: module_json,
             topology,
             coordsKind: summary.coords_kind,
             view
         });
-        local.deltas = deltas;
-        local.ratings = rates;
-        local.formulation = formulation;
-        this.addAndActivateLocal(local);
     };
     /** Build (or reuse) the case's Study and commit it at the current edit state, so a
      * save or export captures exactly what is on screen. Null (with an error set) when no
-     * network or Study is available. */
+     * PowerIO module or Study is available. */
     syncedStudy = async (c) => {
-        const networkJson = await this.ensureNetworkJson(c);
-        if (!networkJson) {
-            this.app.error = `${this.caseName(c)}: no network available to save`;
+        const studyInputJson = await this.ensureStudyInputJson(c);
+        if (!studyInputJson) {
+            this.app.error = `${this.caseName(c)}: no PowerIO module available to save`;
             return null;
         }
-        const study = await this.getStudy(c, networkJson);
+        const study = await this.getStudy(c, studyInputJson);
         if (!study) {
             this.app.error = `${this.caseName(c)}: the browser study is unavailable`;
             return null;
@@ -1763,31 +2536,47 @@ export class Controller {
         await study.commit(c.id, this.caseDeltas(c), this.caseRatings(c), null);
         return study;
     };
-    /** Save the active study as a `.pio.json` package and download it. */
-    saveStudyPackage = async (c) => {
+    /** Save the materialized case as a retained PowerIO module. */
+    saveCaseModule = async (c) => {
+        const study = await this.syncedStudy(c);
+        if (!study)
+            return;
+        try {
+            downloadText(await study.saveModule(), `${this.caseFileStem(c)}.pio.json`, 'application/json');
+            this.app.error = null;
+        }
+        catch (e) {
+            this.app.error = `${this.caseName(c)}: could not save PowerIO module: ${errorText(e)}`;
+        }
+    };
+    /** Save the exact DC OPF result with the materialized problem instance it solved. */
+    saveSolutionModule = async (c) => {
+        if (c.formulation !== 'dcopf') {
+            this.app.error = `${this.caseName(c)}: exact solution modules require the DC OPF formulation`;
+            return;
+        }
         const study = await this.syncedStudy(c);
         if (!study)
             return;
         try {
-            downloadText(await study.savePackage(), `${this.caseFileStem(c)}.pio.json`, 'application/json');
+            downloadText(await study.saveSolutionModule(), `${this.caseFileStem(c)}.solution.pio.json`, 'application/json');
             this.app.error = null;
         }
         catch (e) {
-            this.app.error = `${this.caseName(c)}: could not save study: ${errorText(e)}`;
+            this.app.error = `${this.caseName(c)}: could not save exact solution: ${errorText(e)}`;
         }
     };
-    /** Export the active study's committed state to `format` and download it. Returns the
-     * writer's fidelity warnings so the caller can surface them. */
-    exportStudyAs = async (c, format) => {
+    /** Export the active study's committed state to `format` and download it.
+     * Returns this output operation's structured diagnostics. */
+    exportCaseAs = async (c, format) => {
         const study = await this.syncedStudy(c);
         if (!study)
             return [];
         try {
-            const packageJson = await study.savePackage();
-            const exported = await exportStudy(packageJson, studyCommitIndex(packageJson), format);
+            const exported = await study.export(format);
             downloadText(exported.text, `${this.caseFileStem(c)}.${exported.extension}`, 'text/plain');
             this.app.error = null;
-            return exported.warnings;
+            return exported.diagnostics;
         }
         catch (e) {
             this.app.error = `${this.caseName(c)}: could not export study: ${errorText(e)}`;
@@ -1797,7 +2586,7 @@ export class Controller {
     /** A filesystem-safe base name for a downloaded case file. */
     caseFileStem(c) {
         const base = this.isBackendCase(c) ? c.name : c.label || c.fileName.replace(/\.[^.]+$/, '');
-        return base.replace(/[^\w.-]+/g, '_') || 'study';
+        return base.replace(/[^\w.-]+/g, '_') || 'case';
     }
     setDemandRangeMode = (mode) => {
         this.app.demandRangeMode = mode;
@@ -1812,11 +2601,13 @@ export class Controller {
     };
     // First-order engine preview for the live drag. Uses the case's already-built
     // Study (no re-parse, no re-solve) to paint predicted per-bus
-    // ΔLMP and the predicted Δobjective. A no-op when the Study isn't built yet or
+    // nodal value changes and the predicted objective change. A no-op when the Study isn't built yet or
     // can't preview (browser fallback path, server-only cases): the map then
     // falls back to the JS sensitivity-times-step preview.
     runPreview = (c, bus, value) => {
-        // Fast path: the committed ∂LMP/∂d column (already solved at the committed point),
+        if (c.formulation === 'acpf')
+            return;
+        // Fast path: the committed price/demand column (already solved at the committed point),
         // scaled by the demand step, is the same first-order linearization the engine preview
         // returns — without rebuilding the differentiable KKT every drag frame. That engine
         // preview is ~80 ms/frame on the largest case (CATS, ~8870 buses), which blocked the
@@ -1828,12 +2619,21 @@ export class Controller {
             const delta = new Map();
             for (const v of col.values)
                 delta.set(v.bus, v.value * step);
-            this.app.previewLmp = { caseId: c.id, target: { bus }, delta };
-            const lmpAtBus = c.solution?.lmp.find((l) => l.bus === bus)?.usd_per_mwh ?? null;
+            this.app.previewPrices = {
+                caseId: c.id,
+                target: { bus },
+                delta,
+                units: previewUnits(col.units)
+            };
+            const priceAtBus = c.solution?.prices.find((price) => price.bus === bus)?.value ?? null;
             this.previewObjective =
-                lmpAtBus === null
+                priceAtBus === null
                     ? null
-                    : { caseId: c.id, target: { bus }, objectiveDelta: lmpAtBus * step };
+                    : {
+                        caseId: c.id,
+                        target: { bus },
+                        objectiveDelta: priceAtBus * step
+                    };
             return;
         }
         // Fallback (no committed column yet): the engine's first-order preview, which
@@ -1864,23 +2664,26 @@ export class Controller {
                 if (!study)
                     continue;
                 try {
-                    const { lmp, objectiveDelta } = await study.preview(this.previewDeltas(c, bus, value), this.caseRatings(c));
+                    const { prices, objectiveDelta, units } = await study.preview(this.previewDeltas(c, bus, value), this.caseRatings(c));
                     // Apply only while this point is still the live drag target: a
                     // preview that resolves after a re-selection or a commit is stale.
-                    if (!this.app.previewActive ||
-                        this.activeSolvable !== c ||
-                        this.app.selectedBus !== bus)
+                    if (!this.app.previewActive || this.activeSolvable !== c || this.app.selectedBus !== bus)
                         continue;
                     const delta = new Map();
-                    for (const e of lmp)
-                        delta.set(e.bus, e.usd_per_mwh);
-                    this.app.previewLmp = { caseId: c.id, target: { bus }, delta };
+                    for (const e of prices)
+                        delta.set(e.bus, e.value);
+                    this.app.previewPrices = {
+                        caseId: c.id,
+                        target: { bus },
+                        delta,
+                        units: units?.replaceAll('objective_unit', 'objective units') ?? 'objective units/MW'
+                    };
                     this.previewObjective =
                         objectiveDelta === null ? null : { caseId: c.id, target: { bus }, objectiveDelta };
                 }
                 catch {
                     if (this.activeSolvable === c && this.app.selectedBus === bus) {
-                        this.app.previewLmp = null;
+                        this.app.previewPrices = null;
                         this.previewObjective = null;
                     }
                 }
@@ -1891,7 +2694,7 @@ export class Controller {
         }
     }
     setSliderPreview = (value) => {
-        if (value === undefined)
+        if (value === undefined || this.sliderDisabled)
             return;
         this.app.previewActive = true;
         this.app.previewDeltaMw = value;
@@ -1911,12 +2714,14 @@ export class Controller {
         return ratings;
     }
     // First-order engine preview for the live rating drag, mirroring runPreview: the
-    // committed ∂LMP/∂rating column scaled by the rating step paints predicted per-bus
-    // ΔLMP without touching the engine per frame. The predicted Δobjective comes from
+    // committed price/rating column scaled by the rating step paints predicted per-bus
+    // nodal value changes without touching the engine per frame. The predicted objective change comes from
     // a per-MW slope taken once from Study.preview at a +1 MW step off the committed
     // point (preview is replacement-absolute, so the absolute ratings map is built),
     // then scaled by the live step; null when no Study slope is available.
     runRatingPreview = (c, branch, value) => {
+        if (c.formulation === 'acpf')
+            return;
         const committedAtBranch = this.caseRatings(c)[branch] ?? 0;
         const step = (Math.abs(value) < 0.25 ? 0 : value) - committedAtBranch;
         const col = c.sensitivity;
@@ -1924,7 +2729,12 @@ export class Controller {
             const delta = new Map();
             for (const v of col.values)
                 delta.set(v.bus, v.value * step);
-            this.app.previewLmp = { caseId: c.id, target: { branch }, delta };
+            this.app.previewPrices = {
+                caseId: c.id,
+                target: { branch },
+                delta,
+                units: previewUnits(col.units)
+            };
         }
         let cached = this.ratingSlope;
         if (cached?.caseId !== c.id || cached.branch !== branch) {
@@ -1996,7 +2806,7 @@ export class Controller {
     commitRating = async (value) => {
         const c = this.activeSolvable;
         const branch = this.app.selectedBranch;
-        if (!c || branch === null)
+        if (!c || branch === null || isDisplayOnlyElement(this.selectedBranchData))
             return;
         // Refresh the engine preview at the commit value (a typed value may not have
         // driven a drag), then score the commit with the engine's predicted Δobjective.
@@ -2009,6 +2819,7 @@ export class Controller {
         }
         c.predictedObjective = this.predictedDeltaObj;
         c.ratings = this.previewRatings(c, branch, value);
+        this.bumpRevision(c);
         // The slope was taken at the old committed point; the next drag re-derives it.
         this.ratingSlope = null;
         this.app.previewRatingMw = value;