@tellegen/svelte 0.1.2 → 0.2.0

package/dist/controller.svelte.js

@@ -4,9 +4,10 @@ import { caseDeltas as sharedCaseDeltas, caseRatings as sharedCaseRatings, displ
 import { CaseState, LocalCase, MulticonductorCase } from './state.svelte.js';
 import { placeSyntheticTopology } from './synthetic-layout.js';
 import { studyCommitIndex } from './study-package.js';
-import { classifyJson, distExtensionFormat, isGeoFileName } from './drop-classify.js';
+import { 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, ingestDistCase, isDisplayFile, isPermanentEngineFailure, loadPackage, parseDisplay, parseGeo } from '@tellegen/engine';
+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';
 const HIDDEN_DEFAULT_CASES_KEY = 'tellegen.hiddenDefaultCases.v1';
 // Open on South Carolina by default: it has the most interesting price action.
@@ -21,6 +22,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;
+/** A lowered analysis row is view-only only when a current producer says so;
+ * absence keeps payloads from older compatible engine/server versions editable. */
+export function isDisplayOnlyElement(element) {
+    return element?.editable === false;
+}
 function delayUntilFocusSettles(ms, signal) {
     if (ms <= 0 || signal.aborted)
         return Promise.resolve();
@@ -83,6 +89,9 @@ export class Controller {
     // In-flight initial case-list load, so a remount during the first fetch dedupes
     // instead of firing a second concurrent load().
     loading = null;
+    // File reads and worker messages retain whole buffers. Admit one validated
+    // batch at a time so repeated drops cannot multiply the aggregate byte cap.
+    dropBatchGate = new DropBatchGate();
     nearbyRangeAnchor = $state(null);
     // Default cases the user has closed; drives the restore affordance. Seeded in load().
     hiddenDefaults = $state(new Set());
@@ -270,7 +279,12 @@ export class Controller {
                     study.free();
                     return null;
                 }
-                this.caseStudies.set(c, { study, networkJson, formulation, baseSolution });
+                this.caseStudies.set(c, {
+                    study,
+                    networkJson,
+                    formulation,
+                    baseSolution
+                });
                 return study;
             }
             catch (e) {
@@ -288,7 +302,12 @@ export class Controller {
                     this.studyBuilds.delete(c);
             }
         })();
-        this.studyBuilds.set(c, { networkJson, formulation, token, promise: build });
+        this.studyBuilds.set(c, {
+            networkJson,
+            formulation,
+            token,
+            promise: build
+        });
         return build;
     }
     // The ∂LMP/∂parameter column at `target` for the case's active formulation, solved in
@@ -299,9 +318,7 @@ export class Controller {
     // error.
     async browserSensitivity(c, networkJson, target) {
         const study = await this.getStudy(c, networkJson);
-        return study
-            ? study.sensitivity(c.id, this.caseDeltas(c), this.caseRatings(c), target)
-            : null;
+        return study ? study.sensitivity(c.id, this.caseDeltas(c), this.caseRatings(c), target) : null;
     }
     // Release a case's Study (if any) when the case is removed.
     disposeStudy(c) {
@@ -376,7 +393,7 @@ export class Controller {
         return deltas;
     }
     demandBounds(mode, bus, center) {
-        if (!bus)
+        if (!bus || isDisplayOnlyElement(bus))
             return { min: 0, max: 0, span: 0 };
         // Floor, not ceil: -ceil(demand) can push base + delta below zero for
         // non-integer demand, which the server rejects (400) and which is
@@ -384,7 +401,11 @@ export class Controller {
         const physicalMin = -Math.floor(bus.demand_mw);
         const physicalMax = Math.max(Math.ceil(bus.demand_mw), 50);
         if (mode === 'full')
-            return { min: physicalMin, max: physicalMax, span: physicalMax - physicalMin };
+            return {
+                min: physicalMin,
+                max: physicalMax,
+                span: physicalMax - physicalMin
+            };
         const span = Math.max(5, Math.min(25, 0.1 * Math.max(bus.demand_mw, 50)));
         return {
             min: Math.max(physicalMin, center - span),
@@ -417,7 +438,10 @@ export class Controller {
         // Drive the values off the resolved mode, not app.displayMode, so the
         // displayOptions[0] fallback holds while displayMode is stale relative to the
         // formulation (e.g. leaving SOCWR before +page resets it to 'lmp').
-        return { ...activeMeta, values: displaySeriesFor(this.activeSolvable, activeMeta.mode) };
+        return {
+            ...activeMeta,
+            values: displaySeriesFor(this.activeSolvable, activeMeta.mode)
+        };
     });
     displayStats = $derived.by(() => {
         if (!this.activeDisplay)
@@ -471,6 +495,7 @@ export class Controller {
     sliderBounds = $derived.by(() => this.demandBounds(this.app.demandRangeMode, this.selectedBusData, this.nearbyRangeCenter));
     sliderMin = $derived(this.sliderBounds.min);
     sliderMax = $derived(this.sliderBounds.max);
+    sliderDisabled = $derived(!this.selectedBusData || isDisplayOnlyElement(this.selectedBusData));
     committedRating = $derived.by(() => this.activeSolvable && this.app.selectedBranch !== null
         ? (this.caseRatings(this.activeSolvable)[this.app.selectedBranch] ?? 0)
         : 0);
@@ -482,10 +507,14 @@ export class Controller {
     // to perturb.
     ratingBounds = $derived.by(() => {
         const b = this.selectedBranchData;
-        if (!b || b.rate_mw <= 0)
+        if (!b || isDisplayOnlyElement(b) || b.rate_mw <= 0)
             return { min: 0, max: 0, disabled: true };
         const span = Math.min(50, Math.max(5, 0.2 * b.rate_mw));
-        return { min: Math.max(-(b.rate_mw - 1), -span), max: span, disabled: false };
+        return {
+            min: Math.max(-(b.rate_mw - 1), -span),
+            max: span,
+            disabled: false
+        };
     });
     selectedSensitivity = $derived.by(() => {
         const c = this.activeSolvable;
@@ -838,8 +867,9 @@ export class Controller {
         c.coordsKind = 'geofile';
         c.syntheticCenter = undefined;
         c.geoSource = sourceLabel;
+        const placedCanonicalBuses = payload.view?.buses.filter((bus) => bus.editable !== false).length ?? 0;
         c.geoWarnings = [
-            `${payload.view?.buses.length ?? 0} of ${payload.n_bus} buses placed from ${placedFrom}`,
+            `${placedCanonicalBuses} of ${payload.n_bus} buses placed from ${placedFrom}`,
             ...extraWarnings,
             ...payload.warnings
         ];
@@ -1049,7 +1079,9 @@ export class Controller {
         this.app.placingLocalId = null;
         const { ac, sensitivitySeq } = this.beginBusSelection(c, busId);
         try {
-            const sensitivity = await this.browserSensitivity(c, c.networkJson, { bus: busId });
+            const sensitivity = await this.browserSensitivity(c, c.networkJson, {
+                bus: busId
+            });
             if (!ac.signal.aborted)
                 this.acceptSensitivity(c, sensitivity, { bus: busId }, sensitivitySeq);
             if (!ac.signal.aborted && !sensitivity) {
@@ -1102,7 +1134,9 @@ export class Controller {
                 if (ac.signal.aborted)
                     return;
             }
-            const sensitivity = await this.browserSensitivity(c, c.networkJson, { branch: branchId });
+            const sensitivity = await this.browserSensitivity(c, c.networkJson, {
+                branch: branchId
+            });
             if (ac.signal.aborted)
                 return;
             if (sensitivity) {
@@ -1325,7 +1359,7 @@ export class Controller {
     commitDelta = (value) => {
         const c = this.activeSolvable;
         const bus = this.app.selectedBus;
-        if (!c || bus === null)
+        if (!c || bus === null || this.sliderDisabled)
             return;
         // Refresh the engine preview at the commit value (a typed value may not have
         // driven a drag), then score the commit with the engine's predicted Δobjective.
@@ -1337,6 +1371,8 @@ export class Controller {
         this.runSolve(c, { bus });
     };
     finishDemandInput = (value) => {
+        if (this.sliderDisabled)
+            return;
         if (Math.abs(value - this.committedDelta) < 0.25) {
             if (!this.activeSolvable?.solving) {
                 this.app.previewActive = false;
@@ -1395,32 +1431,61 @@ export class Controller {
         this.runSolve(c, this.selectionTarget);
     };
     /** Parse dropped files in the browser via the powerio wasm module. Case
-     * files (.m, .raw, .aux) become local networks; geographic files can
+     * files (.m, .raw, .aux, .epc, .pwb) become local networks; geographic files can
      * place those networks; a PowerWorld .pwd becomes a substation point
      * preview. Files run serially; nothing uploads. */
     ingestFiles = async (files) => {
-        const list = Array.from(files);
+        const release = this.dropBatchGate.enter();
+        if (!release) {
+            this.app.error = 'another file batch is still being parsed';
+            return;
+        }
+        try {
+            let list;
+            try {
+                list = validateDropBatch(files);
+            }
+            catch (e) {
+                this.app.error = errorText(e);
+                return;
+            }
+            await this.ingestFileBatch(list);
+        }
+        catch (e) {
+            this.app.error = errorText(e);
+        }
+        finally {
+            this.app.parsingFile = false;
+            release();
+        }
+    };
+    ingestFileBatch = async (list) => {
         let parsedCaseCount = 0;
-        // True once a dropped case file took the geographic sidecars; a restored
-        // package or an existing case only takes them when no case file did.
+        // 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 (a saved study package, a multiconductor package,
-        // a BMOPF/PMD document) shares the `.json` extension with a geographic file,
-        // so classify and consume it up front: the geo/case split below sends every
-        // `.json` to the coordinate parser, which would misread these as coordinate
-        // data. Unroutable `.json` files fall through unchanged.
+        // Routable `.json` content (saved packages, model JSON, and transmission or
+        // distribution documents) shares the extension with geographic files. Route
+        // it up front, but stage recognized payloads until the geographic/display
+        // sidecars below have parsed. Unrouted JSON retains its first byte buffer so
+        // the geographic fallback does not read a potentially large file twice.
         const rest = [];
-        let restoredAnyPackage = false;
+        const routedJson = [];
+        const jsonBytes = new Map();
         for (const file of list) {
             if (file.name.toLowerCase().endsWith('.json')) {
-                const outcome = await this.ingestJsonDrop(file);
-                if (outcome === 'restored' || outcome === 'viewed') {
+                const route = await this.routeJsonDrop(file);
+                if (route.outcome === 'balanced' ||
+                    route.outcome === 'restored' ||
+                    route.outcome === 'multiconductor') {
                     parsedCaseCount++;
-                    restoredAnyPackage ||= outcome === 'restored';
+                    routedJson.push({ file, route });
                     continue;
                 }
-                if (outcome === 'failed')
+                if (route.outcome === 'failed')
                     continue;
+                if (route.bytes)
+                    jsonBytes.set(file, route.bytes);
             }
             rest.push(file);
         }
@@ -1428,8 +1493,14 @@ export class Controller {
         for (const file of rest.filter((f) => isGeoFileName(f.name))) {
             this.app.parsingFile = true;
             try {
-                const parsed = await parseGeo(new Uint8Array(await file.arrayBuffer()), file.name);
-                geoLayers.push({ name: file.name, layer: parsed.layer, warnings: parsed.warnings });
+                const bytes = await readDropFileBytes(file, jsonBytes.get(file));
+                jsonBytes.delete(file);
+                const parsed = await parseGeo(bytes, file.name);
+                geoLayers.push({
+                    name: file.name,
+                    layer: parsed.layer,
+                    warnings: parsed.warnings
+                });
                 this.app.error = null;
             }
             catch (e) {
@@ -1447,7 +1518,12 @@ export class Controller {
             this.app.parsingFile = true;
             try {
                 const bytes = new Uint8Array(await file.arrayBuffer());
-                displays.push({ file, bytes, preview: await parseDisplay(bytes), consumed: false });
+                displays.push({
+                    file,
+                    bytes,
+                    preview: await parseDisplay(bytes),
+                    consumed: false
+                });
                 this.app.error = null;
             }
             catch (e) {
@@ -1457,6 +1533,33 @@ export class Controller {
                 this.app.parsingFile = false;
             }
         }
+        // Materialize routed JSON cases only after sidecars are ready. This keeps
+        // placement ahead of the first solve and preserves the original JSON order.
+        // `prepareDroppedLocal` is a wasm call that takes seconds on a large case,
+        // and the drop gate refuses a second batch throughout, so the UI has to
+        // keep saying so.
+        if (routedJson.length > 0)
+            this.app.parsingFile = true;
+        try {
+            for (const { file, route } of routedJson) {
+                if (route.outcome === 'multiconductor') {
+                    this.addMultiCase(file.name, route.payload);
+                    continue;
+                }
+                if (route.outcome !== 'balanced' && route.outcome !== 'restored')
+                    continue;
+                const local = route.outcome === 'restored'
+                    ? this.localFromPackage(file.name, route.payload)
+                    : 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;
+            }
+        }
+        finally {
+            this.app.parsingFile = false;
+        }
         for (const file of rest.filter((f) => !isGeoFileName(f.name) && !isDisplayFile(f.name))) {
             // OpenDSS routes by extension into the multiconductor viewing path.
             const distFormat = distExtensionFormat(file.name);
@@ -1467,13 +1570,13 @@ export class Controller {
             }
             const format = formatOf(file.name);
             if (!format) {
-                this.app.error = `${file.name}: not a case or geographic file (.m, .raw, .aux, .dss, .pwd, .csv, .json, .geojson)`;
+                this.app.error = `${file.name}: not a case or geographic file (.m, .raw, .aux, .epc, .pwb, .dss, .pwd, .csv, .json, .geojson)`;
                 continue;
             }
             this.app.parsingFile = true;
             try {
-                const text = await file.text();
-                const { network_json, topology, view, ...summary } = await ingestCase(text, format);
+                const bytes = new Uint8Array(await file.arrayBuffer());
+                const { network_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;
@@ -1492,29 +1595,11 @@ export class Controller {
                     coordsKind: summary.coords_kind,
                     view
                 });
-                // A co-dropped geographic file places (or repositions) the network. Apply
-                // it for any parsed case, not just synthetic ones, so a geo overlay
-                // dropped alongside a case that already has coordinates takes effect
-                // instead of being silently discarded. A failed apply keeps the parsed
-                // case (placement still works) and surfaces the reason.
-                let geoError = null;
-                if (geoLayers.length > 0 && local.networkJson) {
-                    try {
-                        await this.applyGeoLayers(local, geoLayers);
-                        geoLayersConsumed = true;
-                    }
-                    catch (e) {
-                        geoError = `${geoLayers.map((l) => l.name).join(' + ')}: ${errorText(e)}; use place on map for manual placement`;
-                    }
-                }
-                else if (local.coordsKind === 'synthetic_pending' && local.networkJson) {
-                    // No sidecar: a coordinate-less case may still borrow a co-dropped
-                    // .pwd's substation points through the SubNum join.
-                    await this.fillFromDisplaySibling(local, displays);
-                }
+                const placement = await this.prepareDroppedLocal(local, geoLayers, displays);
+                geoLayersConsumed ||= placement.geoLayersConsumed;
                 this.addAndActivateLocal(local);
                 parsedCaseCount++;
-                this.app.error = geoError; // a successful parse clears a prior file's error
+                this.app.error = placement.error; // a successful parse clears a prior file's error
             }
             catch (e) {
                 this.app.error = `${file.name}: ${e instanceof Error ? e.message : e}`;
@@ -1541,13 +1626,34 @@ export class Controller {
                 substations: { points, approximate: true }
             }));
         }
-        // Unconsumed sidecars apply to the restored package (now the active local
-        // case) so a saved study co-dropped with its coordinates places, or to an
-        // existing case when nothing in the drop parsed at all.
-        if (geoLayers.length > 0 && !geoLayersConsumed && (restoredAnyPackage || parsedCaseCount === 0)) {
+        // 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);
         }
     };
+    /** Apply co-dropped geographic data before a local case becomes active and
+     * starts solving. Without geographic data, let a coordinate-less case borrow
+     * the first matching PowerWorld display. A failed geographic join keeps the
+     * parsed case and returns the user-facing placement error. */
+    prepareDroppedLocal = async (local, geoLayers, displays) => {
+        if (geoLayers.length > 0 && local.networkJson) {
+            try {
+                await this.applyGeoLayers(local, geoLayers);
+                return { geoLayersConsumed: true, error: null };
+            }
+            catch (e) {
+                return {
+                    geoLayersConsumed: false,
+                    error: `${geoLayers.map((l) => l.name).join(' + ')}: ${errorText(e)}; use place on map for manual placement`
+                };
+            }
+        }
+        if (local.coordsKind === 'synthetic_pending' && local.networkJson) {
+            await this.fillFromDisplaySibling(local, displays);
+        }
+        return { geoLayersConsumed: false, error: null };
+    };
     /** 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.
@@ -1568,47 +1674,43 @@ export class Controller {
             }
         }
     };
-    /** Route a dropped `.json` by its content: a saved study package restores
-     * (`restored`), a multiconductor package or a BMOPF/PMD distribution
-     * document views (`viewed`), `failed` means the content looked routable but
-     * the engine rejected it (a fail-closed message is set), and `not-package`
-     * falls through to the caller's geo/case handling. `drop-classify` is the
-     * single owner of the classification. */
-    ingestJsonDrop = async (file) => {
-        let text;
+    /** Route a dropped `.json` by its content. Recognized payloads return without
+     * mutating case state so co-dropped sidecars can be applied first; unrouted
+     * content returns the bytes already read for the geographic fallback. */
+    routeJsonDrop = async (file) => {
+        let bytes;
         try {
-            text = await file.text();
+            bytes = await readDropFileBytes(file);
         }
         catch {
-            return 'not-package';
+            return { outcome: 'unrouted', bytes: null };
         }
-        const kind = classifyJson(text);
-        if (kind === 'not-json')
-            return 'not-package';
         this.app.parsingFile = true;
         try {
-            if (kind === 'balanced-package') {
-                this.restoreLocalFromPackage(file.name, await loadPackage(text));
+            const result = await ingestJsonDrop(bytes);
+            if (result.kind === 'unknown')
+                return { outcome: 'unrouted', bytes };
+            if (result.kind === 'ambiguous') {
+                this.app.error = `${file.name}: JSON markers name both transmission and distribution formats`;
+                return { outcome: 'failed' };
+            }
+            if (result.kind === 'balanced-package') {
                 this.app.error = null;
-                return 'restored';
+                return { outcome: 'restored', payload: result.payload };
             }
-            const format = kind === 'multiconductor-package' ? 'pio' : kind;
-            const payload = await ingestDistCase(text, format);
-            // BMOPF is the classifier's catch-all and its reader is liberal: an
-            // arbitrary JSON object parses as an empty case (unknown fields land
-            // in extras). Zero buses means this was not a distribution document;
-            // leave the file to the geo sidecar path (which places coordinates
-            // or reports its own precise error) instead of adding a phantom
-            // empty multiconductor case.
-            if (kind === 'bmopf' && payload.n_bus === 0)
-                return 'not-package';
-            this.addMultiCase(file.name, payload);
-            this.app.error = null;
-            return 'viewed';
+            if (result.kind === 'model-json' || result.kind === 'transmission') {
+                this.app.error = null;
+                return { outcome: 'balanced', payload: result.payload };
+            }
+            if (result.kind === 'multiconductor-package' || result.kind === 'distribution') {
+                this.app.error = null;
+                return { outcome: 'multiconductor', payload: result.payload };
+            }
+            throw new Error('engine returned an unsupported JSON drop result');
         }
         catch (e) {
             this.app.error = `${file.name}: ${errorText(e)}`;
-            return 'failed';
+            return { outcome: 'failed' };
         }
         finally {
             this.app.parsingFile = false;
@@ -1619,7 +1721,8 @@ export class Controller {
     ingestDistFile = async (file, format) => {
         this.app.parsingFile = true;
         try {
-            this.addMultiCase(file.name, await ingestDistCase(await file.text(), format));
+            const bytes = new Uint8Array(await file.arrayBuffer());
+            this.addMultiCase(file.name, await ingestDistCaseBytes(bytes, format));
             this.app.error = null;
             return true;
         }
@@ -1725,9 +1828,25 @@ export class Controller {
         else
             this.placeLocalCase(lon, lat);
     };
-    /** Build a local case from a restored study package: the same shape a dropped case
-     * takes, with the saved demand/rating deltas and formulation pre-applied. */
-    restoreLocalFromPackage = (fileName, pkg) => {
+    /** Build a local case from a bare balanced 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 label = summary.name && summary.name !== 'case' ? summary.name : fileName.replace(/\.[^.]+$/, '');
+        return new LocalCase({
+            id: `local-${++this.localSeq}`,
+            label,
+            fileName,
+            summary,
+            networkJson: network_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(/\.[^.]+$/, '');
@@ -1744,7 +1863,7 @@ export class Controller {
         local.deltas = deltas;
         local.ratings = rates;
         local.formulation = formulation;
-        this.addAndActivateLocal(local);
+        return local;
     };
     /** Build (or reuse) the case's Study and commit it at the current edit state, so a
      * save or export captures exactly what is on screen. Null (with an error set) when no
@@ -1867,9 +1986,7 @@ export class Controller {
                     const { lmp, objectiveDelta } = await study.preview(this.previewDeltas(c, bus, value), this.caseRatings(c));
                     // Apply only while this point is still the live drag target: a
                     // preview that resolves after a re-selection or a commit is stale.
-                    if (!this.app.previewActive ||
-                        this.activeSolvable !== c ||
-                        this.app.selectedBus !== bus)
+                    if (!this.app.previewActive || this.activeSolvable !== c || this.app.selectedBus !== bus)
                         continue;
                     const delta = new Map();
                     for (const e of lmp)
@@ -1891,7 +2008,7 @@ export class Controller {
         }
     }
     setSliderPreview = (value) => {
-        if (value === undefined)
+        if (value === undefined || this.sliderDisabled)
             return;
         this.app.previewActive = true;
         this.app.previewDeltaMw = value;
@@ -1996,7 +2113,7 @@ export class Controller {
     commitRating = async (value) => {
         const c = this.activeSolvable;
         const branch = this.app.selectedBranch;
-        if (!c || branch === null)
+        if (!c || branch === null || isDisplayOnlyElement(this.selectedBranchData))
             return;
         // Refresh the engine preview at the commit value (a typed value may not have
         // driven a drag), then score the commit with the engine's predicted Δobjective.

package/dist/display.d.ts

@@ -28,4 +28,3 @@ export declare function caseDeltas(c: SolvableCase): DemandDeltas;
 /** The committed branch rating deltas for a case (MW from base, keyed by branch).
  * The rating counterpart of `caseDeltas`. */
 export declare function caseRatings(c: SolvableCase): BranchRatingDeltas;
-//# sourceMappingURL=display.d.ts.map

package/dist/drop-classify.d.ts

@@ -1,48 +1,11 @@
-/** The single owner of drop-file classification: given a file name or its JSON
- * content, decide which ingest path handles it. Extension routing (`.dss`, and
- * the balanced `.m`/`.raw`/`.aux` via `formatOf` in the engine) is name-based;
- * everything under `.json` is content-sniffed here so there is one place that
- * decides package-vs-case and balanced-vs-multiconductor.
- *
- * The rules mirror the readers they feed:
- *   - a `.pio.json` package is recognized by its `schema` envelope field, then
- *     split by the authoritative `model_kind` (balanced restores a study;
- *     multiconductor is viewed);
- *   - a non-package document is distribution JSON, PMD when it carries the
- *     `data_model` marker and BMOPF otherwise (the same split
- *     `powerio_dist` uses for `.json`), except a GeoJSON FeatureCollection,
- *     which stays unrouted so the geo sidecar path keeps accepting it.
- *
- * Every function is total: malformed, truncated, or non-JSON input classifies
- * as `not-json` rather than throwing. */
-/** The schema URL prefix every `.pio.json` package envelope carries. */
-export declare const PIO_PACKAGE_SCHEMA_PREFIX = "https://powerio.dev/schema/pio-package";
-/** How a dropped JSON file should be ingested. */
-export type JsonDropKind = 
-/** A saved balanced study package: restore the case, edits, and formulation. */
-'balanced-package'
-/** A package carrying a multiconductor payload: view it (no solve). */
- | 'multiconductor-package'
-/** A BMOPF JSON distribution case. */
- | 'bmopf'
-/** A PowerModelsDistribution ENGINEERING JSON case. */
- | 'pmd'
-/** Not JSON, or JSON we do not route (left to the generic error path). */
- | 'not-json';
+/** File name helpers for drop routing. JSON content classification lives in
+ * powerio's Rust/Wasm `classify_json_bytes` path, not in this TypeScript layer. */
 /** The distribution format for a file recognized by extension, or null. Only
- * `.dss` is name-routed; PMD and BMOPF share the `.json` extension and are
- * content-sniffed by {@link classifyJson}. */
+ * `.dss` is name routed; PMD and BMOPF share the `.json` extension and are
+ * classified by the engine. */
 export declare function distExtensionFormat(name: string): 'dss' | null;
 /** True for geographic sidecar files by extension (`.csv`, `.json`,
  * `.geojson`). Routable `.json` content (packages, distribution documents) is
- * consumed by {@link classifyJson} before this applies; what remains parses
+ * consumed by the engine classifier before this applies; what remains parses
  * through the engine's tolerant geo reader. */
 export declare function isGeoFileName(name: string): boolean;
-/** Whether `text` is a `.pio.json` package envelope, by its `schema` field. */
-export declare function isPackageEnvelope(obj: Record<string, unknown> | null): boolean;
-/** Classify a dropped JSON document into its ingest path. */
-export declare function classifyJson(text: string): JsonDropKind;
-/** Whether `text` is a saved study package (a balanced `.pio.json`). Kept for
- * the study-restore path; multiconductor packages are viewed, not restored. */
-export declare function isStudyPackageText(text: string): boolean;
-//# sourceMappingURL=drop-classify.d.ts.map