@tellegen/svelte 0.4.7 → 0.5.1

package/dist/diagram/schematic-equipment.d.ts

@@ -1,4 +1,4 @@
-import type { DistAttachmentKind, DistConnection, DistGraph } from '@tellegen/engine';
+import type { DistAttachmentKind, DistConnection, DistGraph, McPfResultTables } from '@tellegen/engine';
 import type { SchematicGeometry } from './schematic-layout.js';
 /** A stroked glyph: polylines in symbol units, x along the connection, y down. */
 export type Glyph = [number, number][][];
@@ -108,8 +108,9 @@ export declare function flowArrows(symbols: EquipmentSymbols, ends: ({
 /** Complex power into each element (loads, generators, IBRs, shunts) by element id, and for
  * sources the power they draw (the negative of what they inject), so every attachment reads with
  * the same convention: positive is consumption. Branch ports are left out: names are unique only
- * within a family, and a line sharing a load's name must not add to it. */
-export declare function elementPowers(result: {
+ * within a family, and a line sharing a load's name must not add to it. Reads a full result's
+ * objects or its columns. */
+export declare function elementPowers(result: McPfResultTables | {
     element_ports: {
         element: string;
         kind?: string;

package/dist/diagram/schematic-equipment.js

@@ -620,7 +620,8 @@ const BRANCH_PORT_KINDS = new Set(['line', 'switch', 'transformer']);
 /** Complex power into each element (loads, generators, IBRs, shunts) by element id, and for
  * sources the power they draw (the negative of what they inject), so every attachment reads with
  * the same convention: positive is consumption. Branch ports are left out: names are unique only
- * within a family, and a line sharing a load's name must not add to it. */
+ * within a family, and a line sharing a load's name must not add to it. Reads a full result's
+ * objects or its columns. */
 export function elementPowers(result) {
     const out = new Map();
     const add = (id, p, q) => {
@@ -629,6 +630,17 @@ export function elementPowers(result) {
         row.q += q;
         out.set(id, row);
     };
+    if ('strings' in result) {
+        const names = result.strings;
+        const power = result.portPower;
+        for (let k = 0; k < result.portElement.length; k++)
+            if (!BRANCH_PORT_KINDS.has(names[result.portKind[k]]))
+                add(names[result.portElement[k]], power[2 * k], power[2 * k + 1]);
+        const source = result.sourcePower;
+        for (let k = 0; k < result.sourceName.length; k++)
+            add(names[result.sourceName[k]], -source[2 * k], -source[2 * k + 1]);
+        return out;
+    }
     for (const port of result.element_ports)
         if (port.kind === undefined || !BRANCH_PORT_KINDS.has(port.kind))
             add(port.element, port.power_into_element.re, port.power_into_element.im);

package/dist/diagram/snapshot.d.ts

@@ -1,4 +1,4 @@
-import type { McComplex, McPfResult } from '@tellegen/engine';
+import { type McComplex, type McPfResult, type McPfResultTables } from '@tellegen/engine';
 /** Which reference a pair voltage is measured against. */
 export type PairZone = 'phase–neutral' | 'phase–phase' | 'phase–ground';
 /** The second member of a phase–ground pair. */
@@ -52,6 +52,8 @@ export interface BranchSnapshot {
 export interface ResultSnapshot {
     kind: 'solved' | 'stress';
     label: string;
+    /** Qualification and effective settings retained by CSV exports. */
+    provenance?: string[];
     iterations: number | null;
     buses: BusSnapshot[];
     branches: BranchSnapshot[];
@@ -107,9 +109,10 @@ export interface SnapshotBranch {
 /** Voltage unbalance factor |V2| / |V1| in percent, from three phasors in phase order. The ratio
  * is the same for phase–neutral and phase–phase voltages, so either reference works. */
 export declare function sequenceUnbalance(a: McComplex, b: McComplex, c: McComplex): number | null;
-/** Project a full multiconductor power-flow result onto the drawing's bus and branch order.
+/** Project a full multiconductor power-flow result onto the drawing's bus and branch order, from
+ * its object form or its columns (`McPfResultTables`, what a live session transfers).
  * Missing ports leave an end `null`; nothing is interpolated. */
-export declare function snapshotFromMcPf(result: McPfResult, buses: SnapshotBus[], branches: SnapshotBranch[], label?: string): ResultSnapshot;
+export declare function snapshotFromMcPf(result: McPfResult | McPfResultTables, buses: SnapshotBus[], branches: SnapshotBranch[], label?: string): ResultSnapshot;
 /** Bus results from a live session's transferred terminal arrays (`[re, im]` interleaved), for when
  * the full result with element ports has not been fetched. Branches are left without results. */
 export declare function snapshotBusesFromTerminals(ids: ArrayLike<[string, string]>, voltages: ArrayLike<number>, buses: SnapshotBus[]): BusSnapshot[];

package/dist/diagram/snapshot.js

@@ -1,3 +1,4 @@
+import { mcPfResultTables, mcLoadModelLabel, mcNetworkScopeLabel } from '@tellegen/engine';
 import { neutralTerminal } from '../multiconductor.js';
 /** The second member of a phase–ground pair. */
 export const GROUND = 'ground';
@@ -89,27 +90,34 @@ function busSnapshot(bus, voltage) {
     const vuf = phasors.length === 3 ? sequenceUnbalance(phasors[0], phasors[1], phasors[2]) : null;
     return { pairs, unbalance: vuf === null ? null : { percent: vuf, definition: 'VUF' } };
 }
-/** Project a full multiconductor power-flow result onto the drawing's bus and branch order.
+/** Project a full multiconductor power-flow result onto the drawing's bus and branch order, from
+ * its object form or its columns (`McPfResultTables`, what a live session transfers).
  * Missing ports leave an end `null`; nothing is interpolated. */
 export function snapshotFromMcPf(result, buses, branches, label = 'Tellegen multiconductor power flow') {
-    // Nested maps keyed by bus, then element: no composite string keys on a 100k-bus result.
+    const t = 'strings' in result ? result : mcPfResultTables(result);
+    const names = t.strings;
+    // Nested maps keyed by bus, then terminal or element, holding row numbers into the tables: no
+    // composite string keys and no object per row on a 100k-bus result.
     const voltages = new Map();
-    for (const t of result.terminals) {
-        let bus = voltages.get(t.bus);
+    for (let k = 0; k < t.terminalBus.length; k++) {
+        const id = names[t.terminalBus[k]];
+        let bus = voltages.get(id);
         if (!bus)
-            voltages.set(t.bus, (bus = new Map()));
-        bus.set(t.terminal, t.voltage);
+            voltages.set(id, (bus = new Map()));
+        bus.set(names[t.terminalName[k]], k);
     }
     const ports = new Map();
-    for (const p of result.element_ports) {
-        let element = ports.get(p.element);
+    for (let k = 0; k < t.portElement.length; k++) {
+        const id = names[t.portElement[k]];
+        let element = ports.get(id);
         if (!element)
-            ports.set(p.element, (element = new Map()));
-        const rows = element.get(p.bus);
+            ports.set(id, (element = new Map()));
+        const bus = names[t.portBus[k]];
+        const rows = element.get(bus);
         if (rows)
-            rows.push(p);
+            rows.push(k);
         else
-            element.set(p.bus, [p]);
+            element.set(bus, [k]);
     }
     /** The element's port rows, of its own kind when a line and a switch share a name. A closed
      * switch has no ports of its own (the solver merges its buses), so it must not borrow another
@@ -118,8 +126,10 @@ export function snapshotFromMcPf(result, buses, branches, label = 'Tellegen mult
         const all = ports.get(branch.id)?.get(bus);
         if (!all || branch.kind === undefined)
             return all;
-        return all.filter((r) => r.kind === branch.kind);
+        return all.filter((k) => names[t.portKind[k]] === branch.kind);
     };
+    const power = t.portPower;
+    const current = t.portCurrent;
     const seen = new Set();
     const branchSnapshots = branches.map((branch) => {
         const key = `${branch.kind ?? ''}\u0000${branch.id}`;
@@ -132,33 +142,44 @@ export function snapshotFromMcPf(result, buses, branches, label = 'Tellegen mult
             let p = 0;
             let q = 0;
             const byTerminal = new Map();
-            for (const r of rows) {
-                p += r.power_into_element.re;
-                q += r.power_into_element.im;
-                byTerminal.set(r.terminal, r);
+            for (const k of rows) {
+                p += power[2 * k];
+                q += power[2 * k + 1];
+                byTerminal.set(names[t.portTerminal[k]], k);
             }
             const currents = [];
             for (const terminal of side ? branch.toTerminals : branch.fromTerminals) {
-                const row = byTerminal.get(terminal);
-                if (row)
-                    currents.push({ terminal, amps: magnitude(row.current_into_element) });
+                const k = byTerminal.get(terminal);
+                if (k !== undefined)
+                    currents.push({ terminal, amps: Math.hypot(current[2 * k], current[2 * k + 1]) });
             }
             return { p: p / 1000, q: q / 1000, currents };
         });
         return {
             ends,
-            ...loadingOf(branch, ends, elementPorts),
+            ...loadingOf(branch, ends, elementPorts, power),
             primary,
-            loss: primary ? equipmentLoss(branch, elementPorts) : null
+            loss: primary ? equipmentLoss(branch, elementPorts, power) : null
         };
     });
+    const voltage = t.terminalVoltage;
     return {
         kind: 'solved',
-        label,
-        iterations: result.iterations,
+        label: `${label}: ${mcLoadModelLabel(t.load_model)}; ${mcNetworkScopeLabel(t.network_scope)}`,
+        provenance: [
+            JSON.stringify({
+                load_model: t.load_model ?? null,
+                network_scope: t.network_scope ?? null,
+                excluded_islands: t.excluded_islands ?? []
+            })
+        ],
+        iterations: t.iterations,
         buses: buses.map((bus) => {
             const terminals = voltages.get(bus.id);
-            return busSnapshot(bus, (t) => terminals?.get(t));
+            return busSnapshot(bus, (terminal) => {
+                const k = terminals?.get(terminal);
+                return k === undefined ? undefined : { re: voltage[2 * k], im: voltage[2 * k + 1] };
+            });
         }),
         branches: branchSnapshots
     };
@@ -175,18 +196,18 @@ export function snapshotBusesFromTerminals(ids, voltages, buses) {
     }));
 }
 /** Power summed over a set of port rows, in kW and kvar. */
-function portPower(rows) {
+function portPower(rows, power) {
     let p = 0;
     let q = 0;
-    for (const r of rows) {
-        p += r.power_into_element.re;
-        q += r.power_into_element.im;
+    for (const k of rows) {
+        p += power[2 * k];
+        q += power[2 * k + 1];
     }
     return { p: p / 1000, q: q / 1000 };
 }
 /** Both ends' ports are signed into the equipment, so their sum over every bus it connects is what
  * it consumes. Each bus counts once, however many winding pairs join it. */
-function equipmentLoss(branch, rows) {
+function equipmentLoss(branch, rows, power) {
     if (!branch.inService)
         return null;
     const buses = new Set([branch.from, branch.to]);
@@ -199,13 +220,13 @@ function equipmentLoss(branch, rows) {
         const at = rows(branch, bus);
         if (!at?.length)
             return null;
-        const power = portPower(at);
-        p += power.p;
-        q += power.q;
+        const sum = portPower(at, power);
+        p += sum.p;
+        q += sum.q;
     }
     return { p, q };
 }
-function loadingOf(branch, ends, rows) {
+function loadingOf(branch, ends, rows, power) {
     const rating = branch.rating;
     if (!rating || !ends[0] || !ends[1])
         return { loading: null, basis: null };
@@ -228,7 +249,7 @@ function loadingOf(branch, ends, rows) {
         const at = rows(branch, bus);
         if (!(va > 0) || !at?.length)
             continue;
-        const { p, q } = portPower(at);
+        const { p, q } = portPower(at, power);
         const percent = (100 * Math.hypot(p, q) * 1000) / va;
         if (loading === null || percent > loading)
             loading = percent;

package/dist/index.d.ts

@@ -30,3 +30,6 @@ export type { MultiView, PlacedMultiBus, PlacedMultiEdge } from './multiconducto
 export type { CaseFileSummary, DistAttachmentKind, DistEdgeKind, DistGraph, DistGraphAttachment, DistGraphBus, DistGraphEdge, DisplayPreview, Formulation, IngestedCase, IngestedDistCase, IngestedJsonDrop, JsonDropClassification, JsonDropKind, CapacityPlanBusWeightJson, CapacityPlanIterationJson, CapacityPlanOutcomeJson, CapacityPlanRatingChangeJson, CapacityPlanResultSummaryJson, CapacityPlanSpecJson, ImplicitObjectiveJson, SensTarget, Topology, TopologyBranch, TopologyBus } from '@tellegen/engine';
 export { default as McResults } from './components/McResults.svelte';
 export { default as McWorkbench } from './components/McWorkbench.svelte';
+export { default as McPfSettings } from './components/McPfSettings.svelte';
+export { default as McModelQualification } from './components/McModelQualification.svelte';
+export { default as McNetworkScope } from './components/McNetworkScope.svelte';

package/dist/index.js

@@ -19,3 +19,6 @@ export { caseDeltas, caseRatings, displayMetaFor, displaySeriesFor } from './dis
 export { DEFAULT_FORMULATION, FORMULATIONS, BrowserStudy, Study, capabilities, createStudy, errorText, formatOf, classifyJson, ingestJsonDrop, ingestCase, isDisplayFile, isPermanentEngineFailure, parseDisplay, solveModule } from '@tellegen/engine';
 export { default as McResults } from './components/McResults.svelte';
 export { default as McWorkbench } from './components/McWorkbench.svelte';
+export { default as McPfSettings } from './components/McPfSettings.svelte';
+export { default as McModelQualification } from './components/McModelQualification.svelte';
+export { default as McNetworkScope } from './components/McNetworkScope.svelte';

package/dist/map-bounds.d.ts

@@ -1,5 +1,13 @@
 export type MapBounds = [[number, number], [number, number]];
+/** Whether a point can be framed on a Web Mercator map: finite, longitude in
+ * [-180, 180], latitude inside the projection's ±85.05° limit. */
+export declare function isMapPoint([lon, lat]: readonly [number, number]): boolean;
 /** Fold finite Web Mercator coordinates into map bounds. Invalid points are
  * ignored so one malformed row cannot hide an otherwise usable network, and a
  * single surviving point still yields a box `fitBounds` can frame. */
 export declare function foldMapBounds(points: Iterable<readonly [number, number]>): MapBounds | null;
+/** The box around points already checked, or `null` when there are none. An
+ * axis that collapsed to a single value is padded so `fitBounds` can frame
+ * it. Longitudes are taken as they are, so an unwrapped route may give a west
+ * edge below -180 or an east edge above 180. */
+export declare function spanBounds(points: Iterable<readonly [number, number]>): MapBounds | null;

package/dist/map-bounds.js

@@ -2,23 +2,36 @@
  * zero-span box makes `fitBounds` divide by zero, clamp to the map's maximum
  * zoom, and slam the camera onto one point instead of framing it. */
 const DEGENERATE_PAD_DEGREES = 0.005;
+/** Whether a point can be framed on a Web Mercator map: finite, longitude in
+ * [-180, 180], latitude inside the projection's ±85.05° limit. */
+export function isMapPoint([lon, lat]) {
+    return (Number.isFinite(lon) &&
+        Number.isFinite(lat) &&
+        lon >= -180 &&
+        lon <= 180 &&
+        lat >= -85.05 &&
+        lat <= 85.05);
+}
 /** Fold finite Web Mercator coordinates into map bounds. Invalid points are
  * ignored so one malformed row cannot hide an otherwise usable network, and a
  * single surviving point still yields a box `fitBounds` can frame. */
 export function foldMapBounds(points) {
+    const kept = [];
+    for (const point of points)
+        if (isMapPoint(point))
+            kept.push(point);
+    return spanBounds(kept);
+}
+/** The box around points already checked, or `null` when there are none. An
+ * axis that collapsed to a single value is padded so `fitBounds` can frame
+ * it. Longitudes are taken as they are, so an unwrapped route may give a west
+ * edge below -180 or an east edge above 180. */
+export function spanBounds(points) {
     let minLon = Infinity;
     let minLat = Infinity;
     let maxLon = -Infinity;
     let maxLat = -Infinity;
     for (const [lon, lat] of points) {
-        if (!Number.isFinite(lon) ||
-            !Number.isFinite(lat) ||
-            lon < -180 ||
-            lon > 180 ||
-            lat < -85.05 ||
-            lat > 85.05) {
-            continue;
-        }
         minLon = Math.min(minLon, lon);
         minLat = Math.min(minLat, lat);
         maxLon = Math.max(maxLon, lon);

package/dist/multiconductor.js

@@ -110,6 +110,43 @@ function withRoutes(view, layer) {
         return view;
     const routes = new Map();
     const same = (a, b) => typeof a === 'string' && a.toLowerCase() === b.toLowerCase();
+    // Index the edges once by lowercased id and by lowercased directed endpoint
+    // pair. A city case carries tens of thousands of routes and edges, so a scan
+    // of every edge per feature is quadratic.
+    const byId = new Map();
+    const byEnds = new Map();
+    for (const edge of view.edges) {
+        const id = edge.id.toLowerCase();
+        const from = edge.from.toLowerCase();
+        const to = edge.to.toLowerCase();
+        const withId = byId.get(id);
+        if (withId)
+            withId.push(edge);
+        else
+            byId.set(id, [edge]);
+        let fromEnds = byEnds.get(from);
+        if (!fromEnds)
+            byEnds.set(from, (fromEnds = new Map()));
+        const between = fromEnds.get(to);
+        if (between)
+            between.push(edge);
+        else
+            fromEnds.set(to, [edge]);
+    }
+    const directed = (from, to) => byEnds.get(from)?.get(to) ?? [];
+    // The edges `same` would match: by id when the feature names one, otherwise
+    // by its endpoints in either direction. A self loop's two directions are one
+    // set, so it is not counted twice.
+    const matching = (id, from, to) => {
+        if (id !== undefined)
+            return typeof id === 'string' ? (byId.get(id.toLowerCase()) ?? []) : [];
+        if (typeof from !== 'string' || typeof to !== 'string')
+            return [];
+        const f = from.toLowerCase();
+        const t = to.toLowerCase();
+        const forward = directed(f, t);
+        return f === t ? forward : [...forward, ...directed(t, f)];
+    };
     for (const feature of features) {
         const props = feature?.properties;
         const geometry = feature?.geometry;
@@ -126,10 +163,7 @@ function withRoutes(view, layer) {
         const from = props.from ?? props.bus_from;
         const to = props.to ?? props.bus_to;
         const id = props.id ?? props.uid;
-        const matches = view.edges.filter((edge) => id !== undefined
-            ? same(id, edge.id)
-            : (same(from, edge.from) && same(to, edge.to)) ||
-                (same(from, edge.to) && same(to, edge.from)));
+        const matches = matching(id, from, to);
         if (matches.length !== 1)
             continue;
         const edge = matches[0];

package/dist/state.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { CaseSummary, DemandDeltas, Network, NetworkBranch, NetworkBus, SensitivityColumn, Solution, SolveIteration } from './api.js';
-import { type StudyView, type BranchRatingDeltas, type BrowserMcPfSession, type CaseFileSummary, type DistGraph, type Formulation, type IngestedDistCase, type McPfCallTiming, type McPfResult, type McPfSummary, type McLoadBranchState, type McLoadPowerEdit, type McStudySnapshot, type SensTarget, type Topology } from '@tellegen/engine';
+import { type StudyView, type BranchRatingDeltas, type BrowserMcPfSession, type CaseFileSummary, type DistGraph, type Formulation, type IngestedDistCase, type McPfCallTiming, type McPfOptions, type McPfResult, type McPfResultTables, type McPfSummary, type McLoadBranchState, type McLoadPowerEdit, type McModuleInput, type McStudySnapshot, type SensTarget, type Topology } from '@tellegen/engine';
 import type { MultiView } from './multiconductor.js';
 import { DiagnosticLog } from './log.svelte.js';
 import { type GraphInputs } from './diagram/graph-inputs.js';
@@ -95,6 +95,11 @@ export declare class LocalCase {
     coordsKind: CoordsKind | undefined;
     /** Map geometry when the file carried or received coordinates. */
     view: LocalView | null;
+    /** Buses a generated grid marks as line taps. The map draws no marker for
+     * them; the bus picker and the selection still reach them. */
+    readonly tapBuses: ReadonlySet<number>;
+    /** `view.buses` less the line taps: the buses the map draws as markers. */
+    readonly markerBuses: NetworkBus[];
     syntheticCenter: {
         lon: number;
         lat: number;
@@ -181,9 +186,10 @@ export declare class CaseState {
 }
 /** A case the solver can run: a server-backed case or a browser-parsed local case. */
 export type SolvableCase = CaseState | LocalCase;
-/** The multiconductor ingest payload without the graph: the summary counts,
- * connected load/generation, coordinate provenance, and diagnostics. */
-export type MultiCaseSummary = Omit<IngestedDistCase, 'graph'>;
+/** The multiconductor ingest payload without the graph or the retained
+ * input: the summary counts, connected load/generation, coordinate
+ * provenance, and diagnostics. */
+export type MultiCaseSummary = Omit<IngestedDistCase, 'graph' | 'input'>;
 /** Geographic coordinates use the map; other positions use the diagram canvas. */
 export type MultiCoordsKind = 'geographic' | 'planar' | 'synthetic';
 /** Where one interactive load edit spent its time, in milliseconds: engine
@@ -197,7 +203,10 @@ export declare class MulticonductorCase {
     readonly id: string;
     readonly label: string;
     readonly fileName: string;
-    moduleJson: string | null;
+    /** The electrical input calculations start from: the module the engine
+     * keeps from the import, or PowerIO IR text (a saved or re-placed module).
+     * A kept module is freed when it is replaced or the case is removed. */
+    mcInput: McModuleInput | null;
     geoLayer: string | null;
     geoWarnings: string[];
     /** Summary of the displayed operating point: from the live session after
@@ -208,6 +217,15 @@ export declare class MulticonductorCase {
     mcFullResult: McPfResult | null;
     /** Latency breakdown of the latest load-edit solve. */
     mcTiming: McEditTiming | null;
+    /** Explicit selection for the next solve. The graph and module retain every bus. */
+    mcEnergizedOnly: boolean;
+    /** Successful explicit solve to reveal in Studies; load edits do not advance it. */
+    mcCompletedSolveSeq: number;
+    /** Detected on import, revalidated when preparing a solve; never removed from the graph. */
+    mcExcludedIslands: import('@tellegen/engine').McExcludedIsland[];
+    mcPreparedScope: import('@tellegen/engine').McNetworkScope | null;
+    /** Selected settings for the next explicit solve; results carry their own effective settings. */
+    mcOptions: McPfOptions;
     mcSnapshot: McStudySnapshot | null;
     mcSession: BrowserMcPfSession | null;
     mcLoadBranches: McLoadBranchState[];
@@ -248,9 +266,10 @@ export declare class MulticonductorCase {
     /** Bumped to ask the views to bring the current selection into view again (an issue clicked
      * that is already selected). */
     revealSeq: number;
-    /** The full operating point read for whole-network views (overview, schematic); null until read,
-     * and cleared when a large case's operating point changes. */
-    overviewResult: McPfResult | null;
+    /** The full operating point read for whole-network views (overview, schematic): a stored
+     * result, or a live session's as columns. Null until read, and cleared when a large case's
+     * operating point changes. */
+    overviewResult: McPfResult | McPfResultTables | null;
     overviewLoading: boolean;
     /** The graph's buses and branches as the overview and the diagram read them: rebuilt when the
      * graph is replaced, never after a solve. Both views read this one copy. */
@@ -270,11 +289,17 @@ export declare class MulticonductorCase {
         label: string;
         fileName: string;
         summary: MultiCaseSummary;
+        /** The module the engine kept from the import, in place of the
+         * summary's `module_json`. */
+        input?: McModuleInput | null;
         graph: DistGraph;
         coordsKind: MultiCoordsKind;
         view?: MultiView | null;
     });
     get mcPfReason(): string | null;
+    /** Import detects scope; only a solve action opts into the selection. */
+    get mcRequiresEnergizedSolve(): boolean;
+    get mcSolveLabel(): string;
     get mcPfSupported(): boolean;
     /** Whether the case is placed and ready to render. */
     get placed(): boolean;

package/dist/state.svelte.js

@@ -1,3 +1,5 @@
+import { DEFAULT_MC_PF_OPTIONS, summarizeMcExcludedIslands } from '@tellegen/engine';
+import { tapBusIds, withoutTaps } from './bus-kinds.js';
 import { DEFAULT_FORMULATION } from '@tellegen/engine';
 import { DiagnosticLog, errorEntry } from './log.svelte.js';
 import { graphInputs } from './diagram/graph-inputs.js';
@@ -26,6 +28,11 @@ export class LocalCase {
     coordsKind = $state.raw(undefined);
     /** Map geometry when the file carried or received coordinates. */
     view = $state.raw(null);
+    /** Buses a generated grid marks as line taps. The map draws no marker for
+     * them; the bus picker and the selection still reach them. */
+    tapBuses = $derived(tapBusIds(this.studyInputJson));
+    /** `view.buses` less the line taps: the buses the map draws as markers. */
+    markerBuses = $derived(withoutTaps(this.view?.buses ?? [], this.tapBuses));
     syntheticCenter = $state.raw(undefined);
     diagram = $state.raw(null);
     displayMode = $state('geographic');
@@ -127,7 +134,10 @@ export class MulticonductorCase {
     id;
     label;
     fileName;
-    moduleJson = $state.raw(null);
+    /** The electrical input calculations start from: the module the engine
+     * keeps from the import, or PowerIO IR text (a saved or re-placed module).
+     * A kept module is freed when it is replaced or the case is removed. */
+    mcInput = $state.raw(null);
     geoLayer = $state.raw(null);
     geoWarnings = $state.raw([]);
     /** Summary of the displayed operating point: from the live session after
@@ -138,6 +148,15 @@ export class MulticonductorCase {
     mcFullResult = $state.raw(null);
     /** Latency breakdown of the latest load-edit solve. */
     mcTiming = $state.raw(null);
+    /** Explicit selection for the next solve. The graph and module retain every bus. */
+    mcEnergizedOnly = $state(false);
+    /** Successful explicit solve to reveal in Studies; load edits do not advance it. */
+    mcCompletedSolveSeq = $state(0);
+    /** Detected on import, revalidated when preparing a solve; never removed from the graph. */
+    mcExcludedIslands = $state.raw([]);
+    mcPreparedScope = $state.raw(null);
+    /** Selected settings for the next explicit solve; results carry their own effective settings. */
+    mcOptions = $state({ ...DEFAULT_MC_PF_OPTIONS });
     mcSnapshot = $state.raw(null);
     mcSession = $state.raw(null);
     mcLoadBranches = $state.raw([]);
@@ -172,8 +191,9 @@ export class MulticonductorCase {
     /** Bumped to ask the views to bring the current selection into view again (an issue clicked
      * that is already selected). */
     revealSeq = $state(0);
-    /** The full operating point read for whole-network views (overview, schematic); null until read,
-     * and cleared when a large case's operating point changes. */
+    /** The full operating point read for whole-network views (overview, schematic): a stored
+     * result, or a live session's as columns. Null until read, and cleared when a large case's
+     * operating point changes. */
     overviewResult = $state.raw(null);
     overviewLoading = $state(false);
     /** The graph's buses and branches as the overview and the diagram read them: rebuilt when the
@@ -196,14 +216,17 @@ export class MulticonductorCase {
         this.label = init.label;
         this.fileName = init.fileName;
         this.summary = init.summary;
-        this.moduleJson = init.summary.module_json ?? null;
+        this.mcInput = init.input ?? init.summary.module_json ?? null;
+        this.mcEnergizedOnly = init.summary.mc_energized_only ?? false;
+        this.mcExcludedIslands = init.summary.mc_excluded_islands ?? [];
+        this.mcPreparedScope = summarizeMcExcludedIslands(this.mcExcludedIslands);
         this.geoLayer = init.summary.geo_layer ?? null;
         this.graph = init.graph;
         this.coordsKind = init.coordsKind;
         this.view = init.view ?? null;
     }
     get mcPfReason() {
-        if (!this.moduleJson)
+        if (!this.mcInput)
             return 'This case has no retained electrical input';
         if (this.summary?.mc_pf_enabled !== true)
             return 'AC power flow is unavailable in this build';
@@ -211,6 +234,13 @@ export class MulticonductorCase {
             this.summary.mc_pf_unavailable_reason ??
             (this.summary.mc_pf_supported !== true ? 'AC power flow is unavailable for this case' : null));
     }
+    /** Import detects scope; only a solve action opts into the selection. */
+    get mcRequiresEnergizedSolve() {
+        return this.mcExcludedIslands.length > 0;
+    }
+    get mcSolveLabel() {
+        return this.mcRequiresEnergizedSolve ? 'Solve energized network' : 'Run power flow';
+    }
     get mcPfSupported() {
         return this.mcPfReason === null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tellegen/svelte",
-  "version": "0.4.7",
+  "version": "0.5.1",
   "description": "Svelte components for tellegen power system maps, local case files, and browser solves.",
   "keywords": [
     "svelte",
@@ -67,7 +67,7 @@
     "pack:dry-run": "npm pack --dry-run --cache ../../node_modules/.cache/npm-pack"
   },
   "dependencies": {
-    "@tellegen/engine": "^0.4.6"
+    "@tellegen/engine": "^0.5.1"
   },
   "peerDependencies": {
     "@deck.gl/core": "^9.4.0",
@@ -77,16 +77,16 @@
     "svelte": ">=5.30 <6"
   },
   "devDependencies": {
-    "@deck.gl/core": "^9.4.0",
-    "@deck.gl/layers": "^9.4.0",
-    "@deck.gl/maplibre": "^9.4.0",
-    "@sveltejs/package": "^3.0.1",
+    "@deck.gl/core": "^9.4.1",
+    "@deck.gl/layers": "^9.4.1",
+    "@deck.gl/maplibre": "^9.4.1",
+    "@sveltejs/package": "^3.0.2",
     "@sveltejs/vite-plugin-svelte": "^7.3.1",
-    "maplibre-gl": "^6.15.0",
-    "svelte": "^5.57.2",
-    "svelte-check": "^4.7.7",
+    "maplibre-gl": "^6.16.0",
+    "svelte": "^5.57.3",
+    "svelte-check": "^4.7.8",
     "typescript": "^6.0.3",
     "vite": "^8.3.1",
-    "vitest": "^5.0.2"
+    "vitest": "^5.1.0"
   }
 }