@tellegen/svelte 0.2.0 → 0.4.0

package/dist/controller.svelte.js

@@ -3,15 +3,20 @@ 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 { distExtensionFormat, isGeoFileName } from './drop-classify.js';
 import { DropBatchGate, readDropFileBytes, validateDropBatch } from './drop-limits.js';
-import { buildGeographicView, placeMultiView } from './multiconductor.js';
-import { applyDisplayGeo, applyGeo, applyLayout, createStudy, exportStudy, extractGeo, FORMULATIONS, formatOf, ingestCase, ingestDistCaseBytes, ingestJsonDrop, isDisplayFile, isPermanentEngineFailure, parseDisplay, parseGeo } from '@tellegen/engine';
-import { errorText, extent, formulationLabel, rgbaCss } from './format.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, mcPfResultDetail, summarizeMcPfResult } from '@tellegen/engine';
+import { browserSolveFailure, errorText, extent, formulationLabel, rgbaCss } from './format.js';
+import { DEAD_ZONE_MW } from './slider.js';
 const HIDDEN_DEFAULT_CASES_KEY = 'tellegen.hiddenDefaultCases.v1';
 // Open on South Carolina by default: it has the most interesting price action.
 const DEFAULT_CASE_ID = 'case500';
+/** Whether a local case renders or will render a bus with this id. */
+function localHasBus(c, busId) {
+    const buses = c.view?.buses ?? c.diagram?.view.buses ?? c.topology?.buses ?? [];
+    return buses.some((b) => b.id === busId);
+}
 /** Terminal copy when nothing can solve. Two facts decide the wording: whether
  * this browser's engine failure is known permanent, and that the server
  * declines compute. Server compute exists in the codebase but ships disabled;
@@ -22,6 +27,11 @@ 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) {
@@ -60,7 +70,11 @@ function downloadText(text, filename, mime) {
 }
 export class Controller {
     app;
+    /** `null` when the controller was created with `apiBase: null`; every
+     * server path then reports "compute off" instead of fetching. */
     api;
+    loadDefaultCases;
+    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
@@ -70,11 +84,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.
@@ -113,6 +128,8 @@ export class Controller {
     constructor(app, options = {}) {
         this.app = app;
         this.api = options.api ?? createApiClient({ apiBase: options.apiBase });
+        this.loadDefaultCases = options.loadDefaultCases ?? true;
+        this.mcTransport = options.mcTransport ?? browserWasmTransport;
     }
     // ===== helpers =====
     isBackendCase(c) {
@@ -140,6 +157,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 };
     }
@@ -149,6 +169,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;
@@ -170,6 +191,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;
@@ -219,45 +241,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) {
@@ -270,7 +297,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
@@ -281,7 +308,7 @@ export class Controller {
                 }
                 this.caseStudies.set(c, {
                     study,
-                    networkJson,
+                    studyInputJson,
                     formulation,
                     baseSolution
                 });
@@ -303,21 +330,21 @@ export class Controller {
             }
         })();
         this.studyBuilds.set(c, {
-            networkJson,
+            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);
+    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.
@@ -360,21 +387,26 @@ 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;
+        const api = this.api;
+        if (!api) {
+            c.solveFallbackReason = 'no API configured';
+            return null;
+        }
         try {
-            const json = await this.api.getCaseNetworkJson(c.id);
-            c.networkJson = json;
-            return json;
+            const moduleJson = await api.getCaseModuleJson(c.id);
+            c.studyInputJson = moduleJson;
+            return moduleJson;
         }
         catch (e) {
             c.solveFallbackReason = `case fetch failed: ${errorText(e)}`;
@@ -386,7 +418,7 @@ export class Controller {
     // reads as "no change at this bus".
     previewDeltas(c, bus, value) {
         const deltas = { ...this.caseDeltas(c) };
-        if (Math.abs(value) < 0.25)
+        if (Math.abs(value) < DEAD_ZONE_MW)
             delete deltas[bus];
         else
             deltas[bus] = value;
@@ -424,8 +456,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));
@@ -437,7 +473,7 @@ 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').
+        // formulation (e.g. leaving SOCWR before +page resets it to price).
         return {
             ...activeMeta,
             values: displaySeriesFor(this.activeSolvable, activeMeta.mode)
@@ -451,7 +487,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 },
@@ -470,8 +506,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 }
@@ -545,9 +581,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(() => {
@@ -559,13 +595,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 &&
@@ -580,7 +616,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 };
@@ -597,11 +636,20 @@ export class Controller {
     previewing = $derived.by(() => Boolean(this.activeSolvable?.solving ||
         this.app.previewActive ||
         (this.app.previewDeltaMw !== null &&
-            Math.abs(this.sliderValue - this.committedDelta) >= 0.25) ||
+            Math.abs(this.sliderValue - this.committedDelta) >= DEAD_ZONE_MW) ||
         (this.app.previewRatingMw !== null &&
-            Math.abs(this.ratingSliderValue - this.committedRating) >= 0.25)));
+            Math.abs(this.ratingSliderValue - this.committedRating) >= DEAD_ZONE_MW)));
     // ===== actions =====
     load = () => {
+        // Default cases off, or no backend at all: nothing to fetch. The shell
+        // still needs its loaded state and a framed map, and a host that opens
+        // its own cases must never see a request go out.
+        const api = this.api;
+        if (!this.loadDefaultCases || api === null) {
+            this.casesLoaded = true;
+            void this.app.requestFrame('all');
+            return Promise.resolve();
+        }
         // A remount can call load() again before the first getCases() resolves; dedupe
         // so two concurrent loads can't double-fetch the case list and double-fit the map.
         if (this.loading)
@@ -611,14 +659,14 @@ export class Controller {
             // copy and skip doomed requests (the SSE stream cannot see a 403). On
             // failure assume enabled; the 403 latch in fetchServerColumn still
             // catches a disabled deploy.
-            void this.api
+            void api
                 .getComputeStatus()
                 .then((s) => {
                 this.serverComputeOff = !s.enabled;
             })
                 .catch(() => { });
             try {
-                const summaries = await this.api.getCases();
+                const summaries = await api.getCases();
                 const hidden = this.readHiddenDefaultCases();
                 this.hiddenDefaults = new Set(hidden);
                 // Tear down the cases being replaced so their wasm Studies are freed and any
@@ -634,7 +682,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);
@@ -654,20 +704,29 @@ 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);
             return;
         }
+        const api = this.api;
+        if (!api) {
+            this.fail(`${c.name}: no API configured`);
+            return;
+        }
         this.loadingBackendCase = c.id;
         const requestedFormulation = c.formulation;
         try {
             const [network, dcBaseSolution] = await Promise.all([
-                c.network ? Promise.resolve(c.network) : this.api.getNetwork(c.id),
+                c.network ? Promise.resolve(c.network) : 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)
+                requestedFormulation === 'dcopf' ? api.getSolution(c.id) : Promise.resolve(null)
             ]);
             if (!this.app.byId(c.id))
                 return;
@@ -700,10 +759,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;
         }
@@ -739,6 +807,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
@@ -747,8 +816,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);
     };
@@ -763,12 +834,19 @@ export class Controller {
         this.disposeStudy(c);
         await this.hydrateFallback(this.app.removeLocal(c.id));
     };
-    addAndActivateLocal = (c) => {
+    /** Add a prepared local case, make it active, frame it (unless `frame` is
+     * false) and start its browser solve. */
+    addAndActivateLocal = (c, options = {}) => {
+        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 ((options.frame ?? true) && (c.view || c.diagram || c.substations))
             this.app.requestFrame(c.id);
         this.maybeStartLocalSolve(c.id);
     };
@@ -790,18 +868,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.
@@ -811,10 +889,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) {
@@ -830,23 +910,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;
@@ -856,15 +959,16 @@ 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;
@@ -874,39 +978,239 @@ export class Controller {
             ...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. */
@@ -946,13 +1250,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;
@@ -1005,7 +1311,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
@@ -1016,7 +1322,8 @@ export class Controller {
         const retryOp = 'bus' in target
             ? () => this.selectBus(c.id, target.bus)
             : () => this.selectBranch(c.id, target.branch);
-        if (this.serverComputeOff) {
+        const api = this.api;
+        if (this.serverComputeOff || !api) {
             this.fail(this.computeOffNotice(c), retryOp);
             return;
         }
@@ -1026,8 +1333,8 @@ export class Controller {
         }
         try {
             const col = 'bus' in target
-                ? await this.api.getSensitivity(c.id, target.bus, c.deltas, ac.signal)
-                : await this.api.getBranchSensitivity(c.id, target.branch, c.deltas, ac.signal);
+                ? await api.getSensitivity(c.id, target.bus, c.deltas, ac.signal)
+                : await api.getBranchSensitivity(c.id, target.branch, c.deltas, ac.signal);
             if (!ac.signal.aborted) {
                 // The solution on screen came from the browser or the served base
                 // solve; the column came from the server. Label the mix.
@@ -1071,7 +1378,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();
@@ -1079,16 +1386,20 @@ export class Controller {
         this.app.placingLocalId = null;
         const { ac, sensitivitySeq } = this.beginBusSelection(c, busId);
         try {
-            const sensitivity = await this.browserSensitivity(c, c.networkJson, {
+            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) {
@@ -1112,7 +1423,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
@@ -1120,7 +1431,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();
@@ -1134,7 +1445,9 @@ export class Controller {
                 if (ac.signal.aborted)
                     return;
             }
-            const sensitivity = await this.browserSensitivity(c, c.networkJson, {
+            if (c.formulation === 'acpf')
+                return;
+            const sensitivity = await this.browserSensitivity(c, c.studyInputJson, {
                 branch: branchId
             });
             if (ac.signal.aborted)
@@ -1160,11 +1473,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;
         }
@@ -1180,7 +1495,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';
@@ -1188,12 +1503,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?.();
@@ -1207,11 +1524,18 @@ 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';
+                // The server fallback only implements DC OPF. Preserve the requested
+                // calculation when its browser input cannot be loaded.
+                if (c.formulation !== 'dcopf') {
+                    c.solving = false;
+                    this.app.error = `${this.caseName(c)}: ${formulationLabel(c.formulation)} requires its PowerIO module; ${c.solveFallbackReason}`;
+                    return;
+                }
                 if (this.hasRatingEdits(c)) {
                     c.solving = false;
                     this.app.error = this.ratingEditsFallbackError(c);
@@ -1220,15 +1544,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) {
@@ -1303,13 +1627,17 @@ export class Controller {
                 return;
             }
             c.solving = false;
-            this.app.error = `${c.label}: browser solve unavailable${c.solveFallbackReason ? `: ${c.solveFallbackReason}` : ''}`;
+            const failure = browserSolveFailure(c.label, c.solveFallbackReason);
+            this.app.error = failure.message;
+            this.app.errorDetail = failure.detail;
         });
     };
     serverSolve = (c, target, seq = c.solveSeq) => {
-        // Known-disabled server compute: show the notice instead of opening a
-        // stream that answers 403 without a readable body (EventSource hides it).
-        if (this.serverComputeOff) {
+        // Known-disabled server compute (or no backend at all): show the notice
+        // instead of opening a stream that answers 403 without a readable body
+        // (EventSource hides it).
+        const api = this.api;
+        if (this.serverComputeOff || !api) {
             if (seq !== c.solveSeq)
                 return;
             c.solving = false;
@@ -1325,7 +1653,7 @@ export class Controller {
         c.solveFallbackReason ??= 'browser solve unavailable';
         // The server computes bus columns only; a branch target streams no sensitivity.
         const sensBus = target && 'bus' in target ? target.bus : null;
-        c.closeStream = this.api.openSolveStream(c.id, c.deltas, sensBus, {
+        c.closeStream = api.openSolveStream(c.id, c.deltas, sensBus, {
             onsolution: (sol) => {
                 if (seq !== c.solveSeq)
                     return;
@@ -1366,6 +1694,7 @@ export class Controller {
         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 });
@@ -1373,7 +1702,7 @@ export class Controller {
     finishDemandInput = (value) => {
         if (this.sliderDisabled)
             return;
-        if (Math.abs(value - this.committedDelta) < 0.25) {
+        if (Math.abs(value - this.committedDelta) < DEAD_ZONE_MW) {
             if (!this.activeSolvable?.solving) {
                 this.app.previewActive = false;
                 this.app.previewDeltaMw = null;
@@ -1385,8 +1714,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;
@@ -1399,19 +1729,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);
@@ -1420,7 +1750,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;
@@ -1460,10 +1790,8 @@ export class Controller {
         }
     };
     ingestFileBatch = async (list) => {
+        const sidecarTarget = this.app.activeMulti ?? this.app.activeLocal ?? this.app.active;
         let parsedCaseCount = 0;
-        // True once a dropped balanced case took the geographic sidecars. When no
-        // case parses, the selected existing case may take them at the end.
-        let geoLayersConsumed = false;
         // 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
@@ -1475,9 +1803,7 @@ export class Controller {
         for (const file of list) {
             if (file.name.toLowerCase().endsWith('.json')) {
                 const route = await this.routeJsonDrop(file);
-                if (route.outcome === 'balanced' ||
-                    route.outcome === 'restored' ||
-                    route.outcome === 'multiconductor') {
+                if (route.outcome === 'balanced' || route.outcome === 'multiconductor') {
                     parsedCaseCount++;
                     routedJson.push({ file, route });
                     continue;
@@ -1499,7 +1825,7 @@ export class Controller {
                 geoLayers.push({
                     name: file.name,
                     layer: parsed.layer,
-                    warnings: parsed.warnings
+                    diagnostics: parsed.diagnostics
                 });
                 this.app.error = null;
             }
@@ -1543,16 +1869,21 @@ export class Controller {
         try {
             for (const { file, route } of routedJson) {
                 if (route.outcome === 'multiconductor') {
-                    this.addMultiCase(file.name, route.payload);
+                    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' && route.outcome !== 'restored')
+                if (route.outcome !== 'balanced')
                     continue;
-                const local = route.outcome === 'restored'
-                    ? this.localFromPackage(file.name, route.payload)
-                    : this.localFromBalancedPayload(file.name, route.payload);
+                const local = this.localFromBalancedPayload(file.name, route.payload);
                 const placement = await this.prepareDroppedLocal(local, geoLayers, displays);
-                geoLayersConsumed ||= placement.geoLayersConsumed;
                 this.addAndActivateLocal(local);
                 this.app.error = placement.error;
             }
@@ -1564,8 +1895,17 @@ export class Controller {
             // 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);
@@ -1576,7 +1916,7 @@ export class Controller {
             this.app.parsingFile = true;
             try {
                 const bytes = new Uint8Array(await file.arrayBuffer());
-                const { network_json, topology, view, ...summary } = await ingestCase(bytes, format);
+                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;
@@ -1590,13 +1930,12 @@ export class Controller {
                     label,
                     fileName: file.name,
                     summary,
-                    networkJson: network_json,
+                    studyInputJson: module_json,
                     topology,
                     coordsKind: summary.coords_kind,
                     view
                 });
                 const placement = await this.prepareDroppedLocal(local, geoLayers, displays);
-                geoLayersConsumed ||= placement.geoLayersConsumed;
                 this.addAndActivateLocal(local);
                 parsedCaseCount++;
                 this.app.error = placement.error; // a successful parse clears a prior file's error
@@ -1608,28 +1947,13 @@ 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 }
-            }));
-        }
-        // When the drop carried only sidecars, apply them to the selected existing
-        // case. Every balanced case parsed in this batch already took them above.
-        if (geoLayers.length > 0 && !geoLayersConsumed && 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`;
         }
     };
     /** Apply co-dropped geographic data before a local case becomes active and
@@ -1637,43 +1961,96 @@ export class Controller {
      * 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) => {
-        if (geoLayers.length > 0 && local.networkJson) {
+        let geoLayersConsumed = false;
+        let error = null;
+        if (geoLayers.length > 0 && local.studyInputJson) {
             try {
                 await this.applyGeoLayers(local, geoLayers);
-                return { geoLayersConsumed: true, error: null };
+                geoLayersConsumed = true;
             }
             catch (e) {
-                return {
-                    geoLayersConsumed: false,
-                    error: `${geoLayers.map((l) => l.name).join(' + ')}: ${errorText(e)}; use place on map for manual placement`
-                };
+                error = `${geoLayers.map((layer) => layer.name).join(' + ')}: ${errorText(e)}`;
             }
         }
-        if (local.coordsKind === 'synthetic_pending' && local.networkJson) {
+        if (local.studyInputJson && displays.length > 0) {
             await this.fillFromDisplaySibling(local, displays);
         }
-        return { geoLayersConsumed: false, error: null };
+        this.placeTopologyAsDiagram(local);
+        return { geoLayersConsumed, error };
     };
-    /** 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. */
+    /** A case that still has no geometry gets a connectivity layout as its
+     * diagram, so it can render and solve without a placement step. */
+    placeTopologyAsDiagram(local) {
+        if (local.view || local.diagram || !local.topology)
+            return;
+        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';
+    }
+    /** 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)];
             }
         }
     };
+    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. */
@@ -1694,15 +2071,20 @@ export class Controller {
                 this.app.error = `${file.name}: JSON markers name both transmission and distribution formats`;
                 return { outcome: 'failed' };
             }
-            if (result.kind === 'balanced-package') {
+            if (result.kind === 'transmission') {
                 this.app.error = null;
-                return { outcome: 'restored', payload: result.payload };
+                return { outcome: 'balanced', payload: result.payload };
             }
-            if (result.kind === 'model-json' || result.kind === 'transmission') {
+            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;
-                return { outcome: 'balanced', payload: result.payload };
+                const payload = result.payload;
+                if ('model' in payload)
+                    return { outcome: 'multiconductor', payload };
+                return { outcome: 'balanced', payload };
             }
-            if (result.kind === 'multiconductor-package' || result.kind === 'distribution') {
+            if (result.kind === 'distribution') {
                 this.app.error = null;
                 return { outcome: 'multiconductor', payload: result.payload };
             }
@@ -1734,14 +2116,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,
@@ -1751,12 +2133,352 @@ 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 fullResult = null;
+            let loadBranches = c.mcLoadBranches;
+            if (this.mcTransport.createMcPfSession) {
+                // The session answers with its summary; terminal and equipment
+                // detail is fetched only when a view asks for it.
+                nextSession = await this.mcTransport.createMcPfSession(input, options, abort.signal);
+                result = nextSession.initialSummary;
+                loadBranches = await nextSession.loadBranches();
+            }
+            else {
+                snapshot = this.mcTransport.solveMcStudy
+                    ? await this.mcTransport.solveMcStudy(input, crypto.randomUUID(), c.label, options, abort.signal)
+                    : null;
+                fullResult =
+                    snapshot?.result ?? (await this.mcTransport.solveMcModule(input, options, abort.signal));
+                result = summarizeMcPfResult(fullResult);
+            }
+            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.mcFullResult = fullResult;
+            c.mcTiming = null;
+            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;
+    };
+    /** One bus's terminals and a page of equipment ports for the displayed
+     * operating point, from the live session or the stored full result. Null
+     * when the operating point changed before the page arrived. */
+    multiResultDetail = async (c, query) => {
+        const summary = c.result;
+        if (!summary)
+            return null;
+        const session = c.mcSession;
+        if (session && !c.mcFullResult) {
+            const detail = await session.detail(query);
+            return session === c.mcSession && c.result?.solve_count === detail.solve_count
+                ? detail
+                : null;
+        }
+        const full = c.mcFullResult ?? c.mcSnapshot?.result ?? null;
+        return full ? mcPfResultDetail(full, query, summary.solve_count) : null;
+    };
+    /** Every terminal's identity, voltage, and injected current, as numeric
+     * arrays of interleaved `[re, im]` values. */
+    multiTerminalTable = async (c) => {
+        if (!c.result)
+            return null;
+        const session = c.mcSession;
+        if (session && !c.mcFullResult) {
+            // Arrays carry no solve count, and a running flush may discard its solve.
+            if (c.mcEditRunning)
+                return null;
+            const solve = c.result.solve_count;
+            const [ids, voltages, currents] = await Promise.all([
+                session.terminalIds(),
+                session.terminalVoltages(),
+                session.terminalCurrents()
+            ]);
+            return session === c.mcSession && c.result?.solve_count === solve
+                ? { ids, voltages, currents }
+                : null;
+        }
+        const full = c.mcFullResult ?? c.mcSnapshot?.result ?? null;
+        if (!full)
+            return null;
+        const voltages = new Float64Array(2 * full.terminals.length);
+        const currents = new Float64Array(2 * full.terminals.length);
+        full.terminals.forEach((terminal, k) => {
+            voltages[2 * k] = terminal.voltage.re;
+            voltages[2 * k + 1] = terminal.voltage.im;
+            currents[2 * k] = terminal.current_into_network.re;
+            currents[2 * k + 1] = terminal.current_into_network.im;
+        });
+        return {
+            ids: full.terminals.map((terminal) => [terminal.bus, terminal.terminal]),
+            voltages,
+            currents
+        };
+    };
+    /** 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;
+        // Without a session, result detail comes from the saved result.
+        c.mcFullResult = snapshot?.result ?? c.mcFullResult;
+        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 summary = await session.replaceLoadPowers(edits);
+                if (session !== c.mcSession || !this.app.multiCases.includes(c))
+                    return;
+                if (revision !== c.mcEditRevision)
+                    continue;
+                // One round trip: the queued edit already set the branch state
+                // this successful solve confirms. Only a failure refetches it.
+                c.result = summary;
+                c.mcFullResult = null;
+                c.mcSnapshot = null;
+                c.mcSavedAt = null;
+                const total = performance.now() - started;
+                c.solveMs = total;
+                c.mcTiming = session.lastTiming ? { ...session.lastTiming, total_ms: total } : null;
+                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;
@@ -1814,6 +2536,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;
@@ -1828,53 +2555,164 @@ export class Controller {
         else
             this.placeLocalCase(lon, lat);
     };
-    /** Build a local case from a bare balanced ingest payload without activating
+    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.');
+        }
+        const api = this.api;
+        if (c instanceof CaseState && c.solution && c.formulation === 'dcopf' && api?.getSavedCase) {
+            const snapshot = await 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 { network_json, topology, view, ...summary } = payload;
+        const { module_json, topology, view, formulation, ...summary } = payload;
         const label = summary.name && summary.name !== 'case' ? summary.name : fileName.replace(/\.[^.]+$/, '');
         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
         });
     };
-    /** Build a local case from a saved package, including its edit state and
-     * formulation, without activating it until sidecars have been applied. */
-    localFromPackage = (fileName, pkg) => {
-        const { network_json, topology, view, formulation, deltas, rates, ...summary } = pkg;
-        const id = `local-${++this.localSeq}`;
-        const label = summary.name && summary.name !== 'case' ? summary.name : fileName.replace(/\.[^.]+$/, '');
-        const local = new LocalCase({
-            id,
-            label,
-            fileName,
-            summary,
-            networkJson: network_json,
-            topology,
-            coordsKind: summary.coords_kind,
-            view
+    /** Ingest module text through the engine and require a balanced network. */
+    async ingestBalancedModule(name, moduleJson) {
+        if (moduleJson === undefined)
+            throw new Error(`${name}: openBalancedModule needs moduleJson or payload`);
+        const result = await ingestJsonDrop(new TextEncoder().encode(moduleJson));
+        if (result.kind === 'transmission')
+            return result.payload;
+        if (result.kind === 'module' && !('model' in result.payload))
+            return result.payload;
+        throw new Error(`${name}: not a balanced network module (${result.kind})`);
+    }
+    /** Open a balanced powerio module from memory, the programmatic twin of
+     * dropping a `.pio.json` file: ingest (unless `payload` is given), apply an
+     * optional geographic layer, lay out a module without coordinates as a
+     * diagram, then add and activate it. Resolves to the new case; throws when
+     * the module is not a balanced network or the geographic layer matches
+     * nothing. */
+    openBalancedModule = async (input) => {
+        this.app.parsingFile = true;
+        try {
+            const payload = input.payload ?? (await this.ingestBalancedModule(input.name, input.moduleJson));
+            const local = this.localFromBalancedPayload(`${input.name}.pio.json`, {
+                ...payload,
+                name: input.name
+            });
+            if (input.formulation)
+                local.formulation = input.formulation;
+            if (input.geoLayer) {
+                await this.applyGeoLayers(local, [
+                    { name: `${input.name}.geo.json`, layer: input.geoLayer, diagnostics: [] }
+                ]);
+            }
+            this.placeTopologyAsDiagram(local);
+            if (input.activate !== false)
+                this.addAndActivateLocal(local, { frame: input.frame });
+            return local;
+        }
+        finally {
+            this.app.parsingFile = false;
+        }
+    };
+    /** Swap a local case for a new module in place: same slot in the case list,
+     * same formulation unless `input.formulation` says otherwise, same display
+     * mode when the new case supports it, and the selected bus kept when the
+     * new case has it. The previous case's Study is freed. */
+    replaceLocalCase = async (previous, input) => {
+        const wasActive = this.app.activeLocalId === previous.id;
+        const selectedBus = wasActive ? this.app.selectedBus : null;
+        const displayMode = previous.displayMode;
+        const next = await this.openBalancedModule({
+            ...input,
+            formulation: input.formulation ?? previous.formulation,
+            activate: false
         });
-        local.deltas = deltas;
-        local.ratings = rates;
-        local.formulation = formulation;
-        return local;
+        if (displayMode === 'diagram' ? next.diagram : next.view)
+            next.displayMode = displayMode;
+        const slot = this.app.localCases.findIndex((c) => c.id === previous.id);
+        // A seq bump invalidates any in-flight browser solve of the old case.
+        previous.solveSeq = (previous.solveSeq ?? 0) + 1;
+        this.disposeStudy(previous);
+        if (wasActive) {
+            this.addAndActivateLocal(next, { frame: input.frame });
+        }
+        else {
+            this.app.localCases = [...this.app.localCases, next];
+            this.maybeStartLocalSolve(next.id);
+        }
+        const cases = this.app.localCases.filter((c) => c.id !== previous.id && c.id !== next.id);
+        cases.splice(slot < 0 ? cases.length : slot, 0, next);
+        this.app.localCases = cases;
+        if (this.app.placingLocalId === previous.id)
+            this.app.placingLocalId = null;
+        if (selectedBus !== null && localHasBus(next, selectedBus)) {
+            void this.selectLocalBus(next.id, selectedBus);
+        }
+        return next;
     };
     /** 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;
@@ -1882,31 +2720,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)}`;
@@ -1916,7 +2770,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;
@@ -1931,11 +2785,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
@@ -1943,16 +2799,25 @@ export class Controller {
         const col = c.sensitivity;
         if (col && col.bus === bus) {
             const committedAtBus = this.caseDeltas(c)[bus] ?? 0;
-            const step = (Math.abs(value) < 0.25 ? 0 : value) - committedAtBus;
+            const step = (Math.abs(value) < DEAD_ZONE_MW ? 0 : value) - committedAtBus;
             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
@@ -1983,21 +2848,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)
                         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;
                     }
                 }
@@ -2021,27 +2891,34 @@ export class Controller {
     // tiny nudge reads as "no change at this line".
     previewRatings(c, branch, value) {
         const ratings = { ...this.caseRatings(c) };
-        if (Math.abs(value) < 0.25)
+        if (Math.abs(value) < DEAD_ZONE_MW)
             delete ratings[branch];
         else
             ratings[branch] = value;
         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 step = (Math.abs(value) < DEAD_ZONE_MW ? 0 : value) - committedAtBranch;
         const col = c.sensitivity;
         if (col && col.branch === branch) {
             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) {
@@ -2126,6 +3003,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;
@@ -2133,7 +3011,7 @@ export class Controller {
         this.runSolve(c, this.selectionTarget);
     };
     finishRatingInput = (value) => {
-        if (Math.abs(value - this.committedRating) < 0.25) {
+        if (Math.abs(value - this.committedRating) < DEAD_ZONE_MW) {
             if (!this.activeSolvable?.solving) {
                 this.app.previewActive = false;
                 this.app.previewRatingMw = null;
@@ -2143,6 +3021,8 @@ export class Controller {
         this.commitRating(value);
     };
     restoreDefaultCases = () => {
+        if (!this.loadDefaultCases)
+            return;
         try {
             if (typeof localStorage !== 'undefined')
                 localStorage.removeItem(HIDDEN_DEFAULT_CASES_KEY);