@tellegen/svelte 0.3.0 → 0.4.1

package/dist/controller.svelte.js

@@ -6,11 +6,17 @@ import { placeSyntheticTopology } from './synthetic-layout.js';
 import { distExtensionFormat, isGeoFileName } from './drop-classify.js';
 import { DropBatchGate, readDropFileBytes, validateDropBatch } from './drop-limits.js';
 import { buildGeographicView, buildDiagramView, placeMultiView } from './multiconductor.js';
-import { browserWasmTransport, applyDisplayGeo, applyGeo, applyLayout, createStudy, extractGeo, FORMULATIONS, formatPowerIoDiagnostic, formatOf, ingestCase, ingestDistCaseBytes, ingestJsonDrop, isDisplayFile, isPermanentEngineFailure, parseDisplay, parseGeo } from '@tellegen/engine';
-import { errorText, extent, formulationLabel, rgbaCss } from './format.js';
+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;
@@ -64,7 +70,10 @@ 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
@@ -119,6 +128,7 @@ 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 =====
@@ -388,8 +398,13 @@ export class Controller {
             return c.studyInputJson;
         if (!this.isBackendCase(c))
             return null;
+        const api = this.api;
+        if (!api) {
+            c.solveFallbackReason = 'no API configured';
+            return null;
+        }
         try {
-            const moduleJson = await this.api.getCaseModuleJson(c.id);
+            const moduleJson = await api.getCaseModuleJson(c.id);
             c.studyInputJson = moduleJson;
             return moduleJson;
         }
@@ -403,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;
@@ -472,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 === 'price' ? 1 : 1e-5;
+        const flatThreshold = this.activeDisplay.mode === 'price' || this.activeDisplay.mode === 'demand' ? 1 : 1e-5;
         return {
             lo: { value: domain.lo, clamped: min < domain.lo - flatThreshold / 20 },
             hi: { value: domain.hi, clamped: max > domain.hi + flatThreshold / 20 },
@@ -621,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)
@@ -635,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
@@ -689,15 +713,20 @@ export class Controller {
                 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 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;
@@ -805,7 +834,9 @@ 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;
@@ -815,7 +846,7 @@ export class Controller {
             this.app.displayMode = 'voltage';
         if (c.diagram)
             this.app.placingLocalId = null;
-        if (c.view || c.diagram || c.substations)
+        if ((options.frame ?? true) && (c.view || c.diagram || c.substations))
             this.app.requestFrame(c.id);
         this.maybeStartLocalSolve(c.id);
     };
@@ -1291,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;
         }
@@ -1301,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.
@@ -1497,6 +1529,13 @@ export class Controller {
                 return;
             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);
@@ -1588,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;
@@ -1610,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;
@@ -1659,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;
@@ -1697,7 +1740,9 @@ export class Controller {
         if (FORMULATIONS.find((f) => f.id === next)?.disabled)
             return;
         c.formulation = next;
-        this.app.displayMode = next === 'acpf' ? 'voltage' : 'price';
+        // Demand does not depend on the calculation, so a demand colouring stays.
+        if (this.app.displayMode !== 'demand')
+            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`.
@@ -1932,42 +1977,47 @@ export class Controller {
         if (local.studyInputJson && displays.length > 0) {
             await this.fillFromDisplaySibling(local, displays);
         }
-        if (!local.view && !local.diagram && local.topology) {
-            const view = {
-                ...placeSyntheticTopology(local.topology, { lon: 0, lat: 0 }),
-                coordinate_space: 'diagram'
-            };
-            const layer = JSON.stringify({
-                type: 'FeatureCollection',
-                powerio_geo: { space: 'diagram', kind: 'synthetic' },
-                features: [
-                    ...view.buses.map((b) => ({
-                        type: 'Feature',
-                        properties: { target: 'bus', id: String(b.id) },
-                        geometry: { type: 'Point', coordinates: [b.lon, b.lat] }
-                    })),
-                    ...view.branches.map((b) => ({
-                        type: 'Feature',
-                        properties: {
-                            target: 'branch',
-                            branch_id: String(b.id),
-                            from: String(b.from),
-                            to: String(b.to)
-                        },
-                        geometry: { type: 'LineString', coordinates: b.path }
-                    }))
-                ]
-            });
-            local.diagram = {
-                view,
-                layer,
-                name: 'Network diagram',
-                warnings: ['No geographic coordinates; positions follow network connectivity.']
-            };
-            local.displayMode = 'diagram';
-        }
+        this.placeTopologyAsDiagram(local);
         return { geoLayersConsumed, error };
     };
+    /** 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.studyInputJson)
@@ -2120,20 +2170,22 @@ export class Controller {
                 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, loadBranches] = await Promise.all([
-                    nextSession.result(),
-                    nextSession.loadBranches()
-                ]);
+                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;
-                result =
+                fullResult =
                     snapshot?.result ?? (await this.mcTransport.solveMcModule(input, options, abort.signal));
+                result = summarizeMcPfResult(fullResult);
             }
             if (abort.signal.aborted)
                 throw new DOMException('Calculation cancelled', 'AbortError');
@@ -2157,6 +2209,8 @@ export class Controller {
             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;
@@ -2201,6 +2255,60 @@ export class Controller {
         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)
@@ -2251,6 +2359,8 @@ export class Controller {
         }
         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;
@@ -2320,19 +2430,20 @@ export class Controller {
                 const revision = c.mcEditRevision;
                 const edits = c.mcLoadEdits.map((edit) => ({ ...edit }));
                 const started = performance.now();
-                const result = await session.replaceLoadPowers(edits);
+                const summary = await session.replaceLoadPowers(edits);
                 if (session !== c.mcSession || !this.app.multiCases.includes(c))
                     return;
                 if (revision !== c.mcEditRevision)
                     continue;
-                const loadBranches = await session.loadBranches();
-                if (revision !== c.mcEditRevision)
-                    continue;
-                c.mcLoadBranches = loadBranches;
-                c.result = result;
+                // 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;
-                c.solveMs = performance.now() - started;
+                const total = performance.now() - started;
+                c.solveMs = total;
+                c.mcTiming = session.lastTiming ? { ...session.lastTiming, total_ms: total } : null;
                 c.revisionGeneration++;
                 break;
             }
@@ -2489,11 +2600,9 @@ export class Controller {
             Object.values(this.caseRatings(c)).some((v) => v !== 0)) {
             throw new Error('The displayed edits have no matching saved result. Finish solving before saving them.');
         }
-        if (c instanceof CaseState &&
-            c.solution &&
-            c.formulation === 'dcopf' &&
-            this.api.getSavedCase) {
-            const snapshot = await this.api.getSavedCase(c.id);
+        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.');
@@ -2519,6 +2628,83 @@ export class Controller {
             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
+        });
+        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
      * PowerIO module or Study is available. */
@@ -2615,7 +2801,7 @@ 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);
@@ -2707,7 +2893,7 @@ 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;
@@ -2723,7 +2909,7 @@ export class Controller {
         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();
@@ -2827,7 +3013,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;
@@ -2837,6 +3023,8 @@ export class Controller {
         this.commitRating(value);
     };
     restoreDefaultCases = () => {
+        if (!this.loadDefaultCases)
+            return;
         try {
             if (typeof localStorage !== 'undefined')
                 localStorage.removeItem(HIDDEN_DEFAULT_CASES_KEY);

package/dist/display.d.ts

@@ -12,8 +12,9 @@ export type DisplayOption = {
 };
 /** Variables present in the current result. Power flow has no LMP values. */
 export declare function displayMetaFor(c: SolvableCase | null): DisplayOption[];
-/** Bus LMPs, voltage angles in radians, or voltage magnitudes in per unit.
- * SOCWR supplies squared voltages, which are converted to magnitudes here. */
+/** Bus LMPs, voltage angles in radians, voltage magnitudes in per unit, or
+ * demand in MW with the case's committed changes. SOCWR supplies squared
+ * voltages, which are converted to magnitudes here. */
 export declare function displaySeriesFor(c: SolvableCase | null, mode: DisplayMode): {
     bus: number;
     value: number;

package/dist/display.js

@@ -1,4 +1,4 @@
-import { priceGradient } from './colors.js';
+import { demandGradient, priceGradient } from './colors.js';
 import { priceCopy } from './format.js';
 import { CaseState } from './state.svelte.js';
 /** Variables present in the current result. Power flow has no LMP values. */
@@ -35,14 +35,32 @@ export function displayMetaFor(c) {
             gradient: priceGradient
         });
     }
+    // Last, so a mode the result cannot show still falls back to a result variable.
+    if (c.network?.buses.length) {
+        options.push({
+            mode: 'demand',
+            label: 'demand',
+            unit: 'MW',
+            copy: 'Bus demand, including committed changes, on a square-root scale.',
+            gradient: demandGradient
+        });
+    }
     return options;
 }
-/** Bus LMPs, voltage angles in radians, or voltage magnitudes in per unit.
- * SOCWR supplies squared voltages, which are converted to magnitudes here. */
+/** Bus LMPs, voltage angles in radians, voltage magnitudes in per unit, or
+ * demand in MW with the case's committed changes. SOCWR supplies squared
+ * voltages, which are converted to magnitudes here. */
 export function displaySeriesFor(c, mode) {
     const sol = c?.solution;
-    if (!sol)
+    if (!c || !sol)
         return [];
+    if (mode === 'demand') {
+        const deltas = caseDeltas(c);
+        return (c.network?.buses ?? []).map((b) => ({
+            bus: b.id,
+            value: b.demand_mw + (deltas[b.id] ?? 0)
+        }));
+    }
     if (mode === 'angle')
         return sol.va;
     if (mode === 'voltage') {

package/dist/format.d.ts

@@ -14,6 +14,15 @@ type SolveMeta = {
     solveBackend: SolveBackend | null;
 };
 export declare function solveMetaLabel(c: SolveMeta): string;
+export declare const INFEASIBLE_DISPATCH = "No feasible dispatch: demand cannot be served within line and generator limits";
+/** The message for a local case whose browser solve failed, and the
+ * technical detail to disclose behind it. An infeasible DC OPF means the
+ * network cannot carry the demand, which deserves plain words. The engine
+ * spells it `DC OPF solve infeasible`, and an unbounded one as `unbounded`. */
+export declare function browserSolveFailure(label: string, reason: string | null): {
+    message: string;
+    detail: string | null;
+};
 export declare function rgbaCss([r, g, b, a]: RGBA): string;
 /** Min and max of a numeric array in one pass. Used instead of
  * `Math.min(...values)` / `Math.max(...values)`, which throw a RangeError once the