@tellegen/svelte 0.4.7 → 0.5.0

package/dist/controller.svelte.js

@@ -7,7 +7,7 @@ import { powerIoEntry, solveEntry } from './log.svelte.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, probeAcOpfWorker, solveAcOpfModule, solveResponseToSolution, mcPfResultDetail, summarizeMcPfResult } from '@tellegen/engine';
+import { browserWasmTransport, applyDisplayGeo, applyGeo, applyLayout, createStudy, extractGeo, FORMULATIONS, formatPowerIoDiagnostic, formatOf, ingestCase, ingestDistCaseBytes, ingestJsonDrop, isDisplayFile, isPermanentEngineFailure, parseDisplay, parseGeo, probeAcOpfWorker, solveAcOpfModule, solveResponseToSolution, mcPfResultDetail, summarizeMcPfResult, validateMcPfOptions, DEFAULT_MC_PF_OPTIONS } 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';
@@ -18,6 +18,15 @@ function localHasBus(c, busId) {
     const buses = c.view?.buses ?? c.diagram?.view.buses ?? c.topology?.buses ?? [];
     return buses.some((b) => b.id === busId);
 }
+/** Free a case input the engine keeps; text needs no release. */
+function releaseMcInput(input) {
+    if (input && typeof input !== 'string')
+        input.free();
+}
+/** PowerIO IR text for a case input, built by the engine for a kept module. */
+function mcInputJson(input) {
+    return typeof input === 'string' ? Promise.resolve(input) : input.moduleJson();
+}
 /** 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. */
@@ -410,6 +419,8 @@ export class Controller {
             c.mcEditTimer = null;
             c.mcSession?.free();
             c.mcSession = null;
+            releaseMcInput(c.mcInput);
+            c.mcInput = null;
         }
     }
     // Release a case's Study (if any) when the case is removed.
@@ -2189,7 +2200,9 @@ export class Controller {
         }
         this.app.parsingFile = true;
         try {
-            const result = await ingestJsonDrop(bytes);
+            // A multiconductor module stays in the engine; only its handle
+            // comes back, never its IR text.
+            const result = await ingestJsonDrop(bytes, { retain: true });
             if (result.kind === 'unknown')
                 return { outcome: 'unrouted', bytes };
             if (result.kind === 'ambiguous') {
@@ -2229,7 +2242,7 @@ export class Controller {
         this.app.parsingFile = true;
         try {
             const bytes = new Uint8Array(await file.arrayBuffer());
-            this.addMultiCase(file.name, await ingestDistCaseBytes(bytes, format));
+            this.addMultiCase(file.name, await ingestDistCaseBytes(bytes, format, { retain: true }));
             this.app.error = null;
             return true;
         }
@@ -2243,7 +2256,7 @@ export class Controller {
     };
     /** Retain parsed electrical inputs and draw each declared coordinate space directly. */
     addMultiCase(fileName, payload) {
-        const { graph, ...summary } = payload;
+        const { graph, input, ...summary } = payload;
         const coordsKind = payload.coords_kind;
         const label = summary.name && summary.name !== 'case' ? summary.name : fileName.replace(/\.[^.]+$/, '');
         const view = coordsKind === 'geographic'
@@ -2255,6 +2268,7 @@ export class Controller {
             label,
             fileName,
             summary,
+            input,
             graph,
             coordsKind,
             view
@@ -2267,17 +2281,24 @@ export class Controller {
         return c;
     }
     /** Compute terminal quantities only for the retained input and current case revision. */
-    solveMultiCase = async (c, options = {}, signal) => {
+    solveMultiCase = async (c, options = c.mcOptions, signal, energizedOnly = c.mcEnergizedOnly) => {
         if (signal?.aborted || this.disposed)
             throw new DOMException('Calculation cancelled', 'AbortError');
         if (c.solving)
             throw new Error('A calculation is already running for this case');
+        options = { ...DEFAULT_MC_PF_OPTIONS, ...c.mcOptions, ...options };
+        const settingsError = validateMcPfOptions(options);
+        if (settingsError)
+            throw new Error(settingsError);
+        c.mcOptions = { ...options };
+        c.mcEnergizedOnly = energizedOnly;
         const unavailable = c.mcPfReason;
         if (unavailable) {
             this.app.error = unavailable;
             throw new Error(unavailable);
         }
-        let input = c.moduleJson;
+        const originalInput = c.mcInput;
+        let input = originalInput;
         const retainedAtStart = c.mcSession;
         const revision = c.revisionGeneration;
         const seq = ++c.solveSeq;
@@ -2289,9 +2310,27 @@ export class Controller {
         this.app.error = null;
         const started = performance.now();
         let nextSession = null;
+        // An input this call took from the live session; freed unless it
+        // becomes the case's input.
+        let editedInput = null;
         try {
+            // The edited operating point stays in the engine; it is never
+            // written out as IR text to be read back.
             if (retainedAtStart)
-                input = await retainedAtStart.inputModule();
+                input = editedInput = await retainedAtStart.input();
+            if (energizedOnly) {
+                if (!this.mcTransport.prepareMcEnergizedNetwork)
+                    throw new Error('Energized-network preparation is unavailable');
+                const prepared = await this.mcTransport.prepareMcEnergizedNetwork(input);
+                const selectedInput = 'input' in prepared ? prepared.input : prepared.module_json;
+                if (editedInput !== selectedInput)
+                    releaseMcInput(editedInput);
+                input = editedInput = selectedInput;
+                if (abort.signal.aborted || seq !== c.solveSeq || revision !== c.revisionGeneration)
+                    throw new DOMException('Calculation cancelled', 'AbortError');
+                c.mcExcludedIslands = prepared.excluded_islands;
+                c.mcPreparedScope = prepared.network_scope;
+            }
             let snapshot = null;
             let result;
             let fullResult = null;
@@ -2304,18 +2343,19 @@ export class Controller {
                 loadBranches = await nextSession.loadBranches();
             }
             else {
+                const text = typeof input === 'string' ? input : await input.moduleJson();
                 snapshot = this.mcTransport.solveMcStudy
-                    ? await this.mcTransport.solveMcStudy(input, crypto.randomUUID(), c.label, options, abort.signal)
+                    ? await this.mcTransport.solveMcStudy(text, crypto.randomUUID(), c.label, options, abort.signal)
                     : null;
                 fullResult =
-                    snapshot?.result ?? (await this.mcTransport.solveMcModule(input, options, abort.signal));
+                    snapshot?.result ?? (await this.mcTransport.solveMcModule(text, options, abort.signal));
                 result = summarizeMcPfResult(fullResult);
             }
             // dispose() aborts too; a session that arrives after it is freed below.
             if (abort.signal.aborted || this.disposed)
                 throw new DOMException('Calculation cancelled', 'AbortError');
             if (seq !== c.solveSeq ||
-                (retainedAtStart ? retainedAtStart !== c.mcSession : input !== c.moduleJson) ||
+                (retainedAtStart ? retainedAtStart !== c.mcSession : originalInput !== c.mcInput) ||
                 revision !== c.revisionGeneration ||
                 !this.app.multiCases.includes(c))
                 throw new Error('The case changed while calculating. Run AC power flow again');
@@ -2332,7 +2372,10 @@ export class Controller {
             nextSession = null;
             c.mcLoadBranches = loadBranches;
             c.mcLoadEdits = [];
-            c.moduleJson = input;
+            if (c.mcInput !== input)
+                releaseMcInput(c.mcInput);
+            c.mcInput = input;
+            editedInput = null;
             c.result = result;
             c.mcFullResult = fullResult;
             c.mcTiming = null;
@@ -2340,10 +2383,12 @@ export class Controller {
             c.mcSavedAt = null;
             c.solveMs = performance.now() - started;
             c.revisionGeneration++;
+            c.mcCompletedSolveSeq = seq;
             return result;
         }
         catch (error) {
             nextSession?.free();
+            releaseMcInput(editedInput);
             if (!abort.signal.aborted &&
                 !(error instanceof DOMException && error.name === 'AbortError')) {
                 this.app.error = errorText(error);
@@ -2398,7 +2443,7 @@ export class Controller {
         return full ? mcPfResultDetail(full, query, summary.solve_count) : null;
     };
     /** Above this many buses, reading and indexing the whole operating point takes a noticeable
-     * fraction of a second (evidence/diagram), so the overview is computed on request instead of
+     * fraction of a second (docs/evidence/diagram), so the overview is computed on request instead of
      * after every solve. */
     static AUTO_OVERVIEW_MAX_BUSES = 25_000;
     overviewSeq = 0;
@@ -2409,7 +2454,7 @@ export class Controller {
     readOverview = (c) => this.startOverviewRead(c, ++this.overviewSeq);
     startOverviewRead(c, seq) {
         c.overviewLoading = true;
-        this.multiFullResult(c).then((full) => {
+        this.multiOverviewResult(c).then((full) => {
             if (seq !== this.overviewSeq)
                 return;
             if (full)
@@ -2440,6 +2485,22 @@ export class Controller {
             c.overviewLoading = false;
         };
     };
+    /** The complete operating point in the form whole-network views read: the stored result, or
+     * the live session's as columns, which hold no object per terminal or port. Null when there is
+     * no result or it changed before the read finished. */
+    multiOverviewResult = async (c) => {
+        if (!c.result)
+            return null;
+        const stored = c.mcFullResult ?? c.mcSnapshot?.result ?? null;
+        const session = c.mcSession;
+        if (stored || !session)
+            return stored;
+        if (c.mcEditRunning)
+            return null;
+        const solve = c.result.solve_count;
+        const tables = await session.resultTables();
+        return session === c.mcSession && c.result?.solve_count === solve ? tables : null;
+    };
     /** The complete operating point for whole-network views: the stored result, or one read from
      * the live session. Null when there is no result or it changed before the read finished. */
     multiFullResult = async (c) => {
@@ -2500,14 +2561,15 @@ export class Controller {
             throw new Error('Select the matching case before attaching coordinates');
         if (c.solving)
             throw new Error('Wait for the calculation before attaching coordinates');
-        if (!c.moduleJson || !this.mcTransport.applyMcGeo)
+        if (!c.mcInput || !this.mcTransport.applyMcGeo)
             throw new Error('Coordinate attachment is unavailable for this case');
-        const baseInput = c.moduleJson;
+        const baseInput = c.mcInput;
         const retainedAtStart = c.mcSession;
         let snapshot = c.mcSnapshot;
         if (!snapshot && c.mcSession && c.result)
             snapshot = await this.snapshotMultiCase(c);
-        const input = snapshot?.input_module ?? c.moduleJson;
+        // Coordinates attach to IR text, so a kept module is written out here.
+        const input = snapshot?.input_module ?? (await mcInputJson(baseInput));
         const revision = c.revisionGeneration;
         let next = input;
         let payload;
@@ -2531,7 +2593,7 @@ export class Controller {
             throw new Error('No coordinates matched the selected case');
         if (this.app.studyView ||
             this.app.activeMulti !== c ||
-            c.moduleJson !== baseInput ||
+            c.mcInput !== baseInput ||
             c.mcSession !== retainedAtStart ||
             c.revisionGeneration !== revision ||
             c.solving)
@@ -2547,7 +2609,8 @@ export class Controller {
         c.mcFullResult = snapshot?.result ?? c.mcFullResult;
         c.mcLoadBranches = [];
         c.mcLoadEdits = [];
-        c.moduleJson = next;
+        releaseMcInput(c.mcInput);
+        c.mcInput = next;
         c.mcSnapshot = snapshot ? { ...snapshot, id: crypto.randomUUID() } : null;
         c.mcSavedAt = null;
         c.geoLayer = payload.geo_layer ?? null;
@@ -2727,6 +2790,8 @@ export class Controller {
             clearTimeout(c.mcEditTimer);
         c.mcSession?.free();
         c.mcSession = null;
+        releaseMcInput(c.mcInput);
+        c.mcInput = null;
         if (this.app.activeMultiId === c.id) {
             c.selectedBusId = null;
             c.selectedEdgeId = null;

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/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];