@tellegen/svelte 0.2.0 → 0.3.0

package/dist/diagram-labels.d.ts

@@ -0,0 +1,9 @@
+type PositionedLabel = {
+    id: number;
+    lon: number;
+    lat: number;
+    name?: string | null;
+};
+/** Place labels in screen pixels so zooming reveals equipment names as space opens. */
+export declare function diagramLabels(buses: PositionedLabel[], scale: number, x: number, y: number, width: number, height: number, selected: number | null): Set<number>;
+export {};

package/dist/diagram-labels.js

@@ -0,0 +1,40 @@
+/** Place labels in screen pixels so zooming reveals equipment names as space opens. */
+export function diagramLabels(buses, scale, x, y, width, height, selected) {
+    const visible = new Set();
+    const cells = new Map();
+    const order = selected === null
+        ? buses
+        : [
+            ...buses.filter((bus) => bus.id === selected),
+            ...buses.filter((bus) => bus.id !== selected)
+        ];
+    for (const bus of order) {
+        const label = bus.name || String(bus.id);
+        const left = bus.lon * scale + x + 8;
+        const bottom = bus.lat * scale + y - 7;
+        const box = { left, bottom, right: left + label.length * 7 + 6, top: bottom - 16 };
+        if (box.right < 0 || box.left > width || box.bottom < 0 || box.top > height)
+            continue;
+        const keys = [];
+        let overlaps = false;
+        for (let col = Math.floor(Math.max(0, box.left) / 64); col <= Math.floor(Math.min(width, box.right) / 64); col++) {
+            for (let row = Math.floor(Math.max(0, box.top) / 64); row <= Math.floor(Math.min(height, box.bottom) / 64); row++) {
+                const key = `${col},${row}`;
+                keys.push(key);
+                if (cells
+                    .get(key)
+                    ?.some((other) => box.left < other.right &&
+                    box.right > other.left &&
+                    box.top < other.bottom &&
+                    box.bottom > other.top))
+                    overlaps = true;
+            }
+        }
+        if (overlaps)
+            continue;
+        visible.add(bus.id);
+        for (const key of keys)
+            cells.set(key, [...(cells.get(key) ?? []), box]);
+    }
+    return visible;
+}

package/dist/display.d.ts

@@ -10,14 +10,10 @@ export type DisplayOption = {
     copy: string;
     gradient: string;
 };
-/** The display variables available for a case's current solution and formulation:
- * LMP always, the DC phase angle under DC OPF, the relaxed |V| under SOCWR. Metadata
- * only; call `displaySeriesFor` for one mode's per-bus values. Empty when unsolved. */
+/** Variables present in the current result. Power flow has no LMP values. */
 export declare function displayMetaFor(c: SolvableCase | null): DisplayOption[];
-/** Per-bus values for one display mode: LMP in $/MWh, the DC phase angle in rad, or
- * the SOCWR voltage magnitude (sqrt of the squared-voltage variable w, clamped at 0).
- * Empty when the case is unsolved. Single source for both the panel legend stats and
- * the map node coloring, so the |V| transform stays in one place. */
+/** Bus LMPs, voltage angles in radians, or voltage magnitudes in per unit.
+ * SOCWR supplies squared voltages, which are converted to magnitudes here. */
 export declare function displaySeriesFor(c: SolvableCase | null, mode: DisplayMode): {
     bus: number;
     value: number;

package/dist/display.js

@@ -1,45 +1,44 @@
-import { lmpGradient } from './colors.js';
+import { priceGradient } from './colors.js';
 import { priceCopy } from './format.js';
 import { CaseState } from './state.svelte.js';
-/** The display variables available for a case's current solution and formulation:
- * LMP always, the DC phase angle under DC OPF, the relaxed |V| under SOCWR. Metadata
- * only; call `displaySeriesFor` for one mode's per-bus values. Empty when unsolved. */
+/** Variables present in the current result. Power flow has no LMP values. */
 export function displayMetaFor(c) {
     if (!c?.solution)
         return [];
-    const options = [
-        {
-            mode: 'lmp',
+    const options = [];
+    if (c.formulation !== 'acpf' && c.solution.prices.length > 0) {
+        options.push({
+            mode: 'price',
             label: 'LMP',
-            unit: '$/MWh',
+            unit: 'objective units/MW',
             copy: priceCopy(c.formulation),
-            gradient: lmpGradient
-        }
-    ];
-    if (c.formulation === 'dcopf' && c.solution.va.length > 0) {
-        options.push({
-            mode: 'angle',
-            label: 'angle',
-            unit: 'rad',
-            copy: 'DC bus voltage phase angle from the current OPF solution.',
-            gradient: lmpGradient
+            gradient: priceGradient
         });
     }
-    if (c.formulation === 'socwr' && c.solution.w.length > 0) {
+    if (c.solution.vm?.length || c.solution.w.length > 0) {
         options.push({
             mode: 'voltage',
             label: '|V|',
             unit: 'pu',
-            copy: 'SOCWR voltage magnitude from the current relaxed solution.',
-            gradient: lmpGradient
+            copy: c.formulation === 'socwr'
+                ? 'SOCWR voltage magnitude from the current relaxed solution.'
+                : 'Bus voltage magnitude from the current power-flow result.',
+            gradient: priceGradient
+        });
+    }
+    if (c.solution.va.length > 0) {
+        options.push({
+            mode: 'angle',
+            label: 'angle',
+            unit: 'rad',
+            copy: 'Bus voltage angle from the current result.',
+            gradient: priceGradient
         });
     }
     return options;
 }
-/** Per-bus values for one display mode: LMP in $/MWh, the DC phase angle in rad, or
- * the SOCWR voltage magnitude (sqrt of the squared-voltage variable w, clamped at 0).
- * Empty when the case is unsolved. Single source for both the panel legend stats and
- * the map node coloring, so the |V| transform stays in one place. */
+/** Bus LMPs, voltage angles in radians, or voltage magnitudes in per unit.
+ * SOCWR supplies squared voltages, which are converted to magnitudes here. */
 export function displaySeriesFor(c, mode) {
     const sol = c?.solution;
     if (!sol)
@@ -47,9 +46,14 @@ export function displaySeriesFor(c, mode) {
     if (mode === 'angle')
         return sol.va;
     if (mode === 'voltage') {
-        return sol.w.map((s) => ({ bus: s.bus, value: Math.sqrt(Math.max(0, s.value)) }));
+        if (sol.vm?.length)
+            return sol.vm;
+        return sol.w.map((s) => ({
+            bus: s.bus,
+            value: Math.sqrt(Math.max(0, s.value))
+        }));
     }
-    return sol.lmp.map((s) => ({ bus: s.bus, value: s.usd_per_mwh }));
+    return sol.prices.map((s) => ({ bus: s.bus, value: s.value }));
 }
 /** The committed demand deltas for a case (MW from base, keyed by bus). A backend
  * case always carries a deltas map; a local case defaults to an empty one. */

package/dist/format.js

@@ -10,9 +10,10 @@ export function formulationHint(id) {
     return FORMULATIONS.find((f) => f.id === id)?.hint ?? id;
 }
 export function priceCopy(id) {
+    const definition = 'Locational marginal price (LMP): the change in the OPF objective for an additional MW at a bus, in objective units/MW.';
     return id === 'socwr'
-        ? 'Select a bus to see how relaxed prices change.'
-        : 'Select a bus to see how prices change.';
+        ? `${definition} Prices come from the SOCWR relaxation. Select a bus to see their sensitivity.`
+        : `${definition} Select a bus to see its demand sensitivity.`;
 }
 export function splitName(name) {
     const m = name.match(/^(.*?)\s*\((.*)\)$/);
@@ -22,7 +23,7 @@ export function solveMetaLabel(c) {
     if ((c.iterations ?? []).length > 1)
         return `${c.iterations?.length} iterations`;
     if (c.solveBackend === 'clarabel-wasm-server-sensitivity')
-        return 'server dLMP/dd';
+        return 'server price sensitivity';
     return c.solveBackend === 'rust-server' ? 'server solve' : 'browser solve';
 }
 export function rgbaCss([r, g, b, a]) {
@@ -46,4 +47,4 @@ export function extent(values) {
 export const fmt = new Intl.NumberFormat('en-US', { maximumFractionDigits: 1 });
 export const signed = (v) => `${v < 0 ? '−' : '+'}${fmt.format(Math.abs(v))}`;
 export const signedExp = (v) => `${v < 0 ? '−' : '+'}${Math.abs(v).toExponential(2)}`;
-export const displayFmt = (mode, value) => mode === 'lmp' ? fmt.format(value) : value.toFixed(3);
+export const displayFmt = (mode, value) => mode === 'price' ? fmt.format(value) : value.toFixed(3);

package/dist/index.d.ts

@@ -1,3 +1,8 @@
+export { getNoticeCenter, errorNoticeTitle } from './notices.svelte.js';
+export { default as ModelDetails } from './components/ModelDetails.svelte';
+export { default as PanelFrame } from './components/PanelFrame.svelte';
+export { getPanelLayout } from './panels.svelte.js';
+export type { PanelSide, PanelPosition, PanelBounds } from './panels.svelte.js';
 export { default as TellegenProvider } from './TellegenProvider.svelte';
 export { default as TellegenShell } from './TellegenShell.svelte';
 export { default as TellegenViewer } from './TellegenViewer.svelte';
@@ -6,14 +11,15 @@ export { DEFAULT_TELLEGEN_UI_CONFIG, getAppState, getController, getUiConfig, re
 export { ApiError, createApiClient } from './api.js';
 export { Controller, createController } from './controller.svelte.js';
 export { AppState, CaseState, LocalCase, MulticonductorCase, createAppState } from './state.svelte.js';
-export { attachmentColor, attachmentGlyph, edgeColor, edgeWidth, phaseColor, placeMultiView, buildGeographicView } from './multiconductor.js';
+export { attachmentColor, attachmentGlyph, edgeColor, edgeWidth, phaseColor, neutralTerminal, placeMultiView, buildGeographicView } from './multiconductor.js';
 export { distExtensionFormat } from './drop-classify.js';
 export { caseDeltas, caseRatings, displayMetaFor, displaySeriesFor } from './display.js';
-export { DEFAULT_FORMULATION, FORMULATIONS, BrowserStudy, Study, capabilities, createStudy, errorText, formatOf, classifyJson, ingestJsonDrop, ingestCase, isDisplayFile, isPermanentEngineFailure, parseDisplay, solveJson } from '@tellegen/engine';
+export { DEFAULT_FORMULATION, FORMULATIONS, BrowserStudy, Study, capabilities, createStudy, errorText, formatOf, classifyJson, ingestJsonDrop, ingestCase, isDisplayFile, isPermanentEngineFailure, parseDisplay, solveModule } from '@tellegen/engine';
 export type { BranchRatingDeltas, CaseSummary, DemandDeltas, Network, NetworkBranch, NetworkBus, SensitivityColumn, Solution, SolveIteration, SolveStreamHandlers, TellegenApiClient, TellegenApiClientOptions } from './api.js';
 export type { TellegenUiConfig, TellegenUiOptions } from './context.svelte.js';
 export type { ControllerOptions } from './controller.svelte.js';
 export type { DisplayOption } from './display.js';
-export type { DemandRangeMode, DisplayMode, FallbackTarget, LocalCaseInit, LocalSubstations, MultiCaseSummary, MultiCoordsKind, SolvableCase, SolveBackend } from './state.svelte.js';
+export type { CameraSnapshot, DiagramCameraSnapshot, DemandRangeMode, DisplayMode, FallbackTarget, LocalCaseInit, LocalSubstations, MultiCaseSummary, MultiCoordsKind, SolvableCase, StudyDisplaySnapshot, SolveBackend } from './state.svelte.js';
 export type { MultiView, PlacedMultiBus, PlacedMultiEdge } from './multiconductor.js';
-export type { CaseFileSummary, DistAttachmentKind, DistEdgeKind, DistGraph, DistGraphAttachment, DistGraphBus, DistGraphEdge, DisplayPreview, Formulation, IngestedCase, IngestedDistCase, IngestedJsonDrop, JsonDropClassification, JsonDropKind, SensTarget, Topology, TopologyBranch, TopologyBus } from '@tellegen/engine';
+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';

package/dist/index.js

@@ -1,3 +1,7 @@
+export { getNoticeCenter, errorNoticeTitle } from './notices.svelte.js';
+export { default as ModelDetails } from './components/ModelDetails.svelte';
+export { default as PanelFrame } from './components/PanelFrame.svelte';
+export { getPanelLayout } from './panels.svelte.js';
 export { default as TellegenProvider } from './TellegenProvider.svelte';
 export { default as TellegenShell } from './TellegenShell.svelte';
 export { default as TellegenViewer } from './TellegenViewer.svelte';
@@ -6,7 +10,8 @@ export { DEFAULT_TELLEGEN_UI_CONFIG, getAppState, getController, getUiConfig, re
 export { ApiError, createApiClient } from './api.js';
 export { Controller, createController } from './controller.svelte.js';
 export { AppState, CaseState, LocalCase, MulticonductorCase, createAppState } from './state.svelte.js';
-export { attachmentColor, attachmentGlyph, edgeColor, edgeWidth, phaseColor, placeMultiView, buildGeographicView } from './multiconductor.js';
+export { attachmentColor, attachmentGlyph, edgeColor, edgeWidth, phaseColor, neutralTerminal, placeMultiView, buildGeographicView } from './multiconductor.js';
 export { distExtensionFormat } from './drop-classify.js';
 export { caseDeltas, caseRatings, displayMetaFor, displaySeriesFor } from './display.js';
-export { DEFAULT_FORMULATION, FORMULATIONS, BrowserStudy, Study, capabilities, createStudy, errorText, formatOf, classifyJson, ingestJsonDrop, ingestCase, isDisplayFile, isPermanentEngineFailure, parseDisplay, solveJson } from '@tellegen/engine';
+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';

package/dist/map.d.ts

@@ -1,7 +1,7 @@
 import type { ComponentProps } from 'svelte';
 import TellegenMap from './TellegenMap.svelte';
 export { default as TellegenMap } from './TellegenMap.svelte';
-export { branchColor, branchWidth, busNeutral, busRadius, lmpColor, lmpDomain, lmpGradient, scalarDomain, sensColor, sensFlatColor, sensGradient, sensNeutral, sensitivityDomain } from './colors.js';
+export { branchColor, branchWidth, busNeutral, busRadius, priceColor, priceDomain, priceGradient, scalarDomain, sensColor, sensFlatColor, sensGradient, sensNeutral, sensitivityDomain } from './colors.js';
 export { caseDeltas, displayMetaFor, displaySeriesFor } from './display.js';
 export type { RGBA, SensitivityDomain } from './colors.js';
 export type { DisplayOption } from './display.js';

package/dist/map.js

@@ -1,4 +1,4 @@
 import TellegenMap from './TellegenMap.svelte';
 export { default as TellegenMap } from './TellegenMap.svelte';
-export { branchColor, branchWidth, busNeutral, busRadius, lmpColor, lmpDomain, lmpGradient, scalarDomain, sensColor, sensFlatColor, sensGradient, sensNeutral, sensitivityDomain } from './colors.js';
+export { branchColor, branchWidth, busNeutral, busRadius, priceColor, priceDomain, priceGradient, scalarDomain, sensColor, sensFlatColor, sensGradient, sensNeutral, sensitivityDomain } from './colors.js';
 export { caseDeltas, displayMetaFor, displaySeriesFor } from './display.js';

package/dist/multiconductor.d.ts

@@ -12,6 +12,7 @@ export interface PlacedMultiBus {
     lat: number;
     terminals: string[];
     grounded: string[];
+    neutral_terminal?: string | null;
     load_kw: number;
     gen_kw: number;
     has_source: boolean;
@@ -28,7 +29,7 @@ export interface PlacedMultiEdge {
     conductors: [string, string][];
     closed: boolean;
     n_phases: number;
-    path: [[number, number], [number, number]];
+    path: [number, number][];
 }
 /** The placed graph the map renders. */
 export interface MultiView {
@@ -37,7 +38,11 @@ export interface MultiView {
 }
 /** Place a geographic graph: each bus's `xy` is `[longitude, latitude]` and
  * drops straight onto the map. */
-export declare function buildGeographicView(graph: DistGraph): MultiView;
+export declare function buildGeographicView(graph: DistGraph, layer?: string): MultiView;
+/** Retain native drawing positions; unpositioned buses receive a separate generated layout. */
+export declare function buildDiagramView(graph: DistGraph, layer?: string): MultiView;
+/** Numeric indices address drawing objects only; source identities remain on each object. */
+export declare function multiDiagramNetwork(id: string, name: string, view: MultiView): import('./api.js').Network;
 /** Place a non-geographic graph at a map `center`: fit the provided planar
  * coordinates when the case carries them, otherwise fall back to the shared
  * synthetic force layout. */
@@ -48,6 +53,10 @@ export declare function placeMultiView(graph: DistGraph, center: PlacementCenter
 export declare function phaseColor(terminal: string): RGBA;
 /** True when a terminal is a phase conductor (not a neutral/ground return). */
 export declare function isPhaseTerminal(terminal: string): boolean;
+/** Return the explicit neutral conductor in a terminal map. Other non-phase
+ * labels are left alone: an arbitrary terminal name is not evidence that the
+ * network has a usable neutral reference. */
+export declare function neutralTerminal(terminals: string[], declared?: string | null): string | null;
 /** Base color for an edge by kind and state. Lines are the warm gray of the
  * single-phase branches; transformers are steel; a switch is amber when closed
  * and a faded red when open. */

package/dist/multiconductor.js

@@ -4,13 +4,7 @@
  * `MulticonductorCase` state and the map own those. */
 import { placeSyntheticTopology } from './synthetic-layout.js';
 import { extent } from './format.js';
-const ATTACHMENT_ORDER = [
-    'source',
-    'generator',
-    'ibr',
-    'load',
-    'shunt'
-];
+const ATTACHMENT_ORDER = ['source', 'generator', 'ibr', 'load', 'shunt'];
 /** Flatten a bus's per-terminal attachments to the distinct kinds present, in a
  * stable render order. */
 function attachmentKindsOf(bus) {
@@ -28,6 +22,7 @@ function placedBus(bus, lon, lat) {
         lat,
         terminals: bus.terminals,
         grounded: bus.grounded,
+        neutral_terminal: bus.neutral_terminal,
         load_kw: bus.load_kw,
         gen_kw: bus.gen_kw,
         has_source: bus.has_source,
@@ -75,13 +70,105 @@ function viewFrom(graph, coords) {
 }
 /** Place a geographic graph: each bus's `xy` is `[longitude, latitude]` and
  * drops straight onto the map. */
-export function buildGeographicView(graph) {
+export function buildGeographicView(graph, layer) {
     const coords = new Map();
     for (const bus of graph.buses) {
         if (bus.xy)
             coords.set(bus.id, bus.xy);
     }
-    return viewFrom(graph, coords);
+    return withRoutes(viewFrom(graph, coords), layer);
+}
+/** Retain native drawing positions; unpositioned buses receive a separate generated layout. */
+export function buildDiagramView(graph, layer) {
+    const generated = layoutSynthetic(graph, { lon: 0, lat: 0 });
+    const coords = new Map();
+    const positioned = graph.buses.filter((bus) => bus.xy?.every(Number.isFinite));
+    const offset = positioned.length ? Math.max(...positioned.map((bus) => bus.xy[0])) + 100 : 0;
+    for (const bus of graph.buses) {
+        if (bus.xy?.every(Number.isFinite))
+            coords.set(bus.id, bus.xy);
+        else {
+            const xy = generated.get(bus.id);
+            if (xy)
+                coords.set(bus.id, [offset + xy[0] * 100, xy[1] * 100]);
+        }
+    }
+    return withRoutes(viewFrom(graph, coords), layer);
+}
+/** Match canonical GeoLayer paths by equipment identity or an unambiguous endpoint pair. */
+function withRoutes(view, layer) {
+    if (!layer)
+        return view;
+    let features;
+    try {
+        features = JSON.parse(layer).features;
+    }
+    catch {
+        return view;
+    }
+    if (!Array.isArray(features))
+        return view;
+    const routes = new Map();
+    const same = (a, b) => typeof a === 'string' && a.toLowerCase() === b.toLowerCase();
+    for (const feature of features) {
+        const props = feature?.properties;
+        const geometry = feature?.geometry;
+        if (!props || geometry?.type !== 'LineString' || !Array.isArray(geometry.coordinates))
+            continue;
+        const points = geometry.coordinates
+            .filter((point) => Array.isArray(point) &&
+            point.length >= 2 &&
+            Number.isFinite(point[0]) &&
+            Number.isFinite(point[1]))
+            .map((point) => [point[0], point[1]]);
+        if (points.length < 2)
+            continue;
+        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)));
+        if (matches.length !== 1)
+            continue;
+        const edge = matches[0];
+        const reverse = same(from, edge.to) && same(to, edge.from);
+        routes.set(edge.id, reverse ? points.reverse() : points);
+    }
+    return {
+        ...view,
+        edges: view.edges.map((edge) => ({ ...edge, path: routes.get(edge.id) ?? edge.path }))
+    };
+}
+/** Numeric indices address drawing objects only; source identities remain on each object. */
+export function multiDiagramNetwork(id, name, view) {
+    const indexes = new Map(view.buses.map((bus, index) => [bus.id.toLowerCase(), index]));
+    return {
+        id,
+        name,
+        base_mva: 1,
+        coordinate_space: 'diagram',
+        synthetic_coords: false,
+        buses: view.buses.map((bus, index) => ({
+            id: index,
+            uid: bus.id,
+            name: bus.id,
+            lon: bus.lon,
+            lat: bus.lat,
+            demand_mw: bus.load_kw / 1000,
+            gen_mw: bus.gen_kw / 1000
+        })),
+        branches: view.edges.map((edge, index) => ({
+            id: index,
+            uid: edge.id,
+            from: indexes.get(edge.from.toLowerCase()),
+            to: indexes.get(edge.to.toLowerCase()),
+            path: edge.path,
+            rate_mw: 0,
+            status: edge.closed ? 1 : 0
+        }))
+    };
 }
 /** Whether at least two buses carry a planar `xy`, enough to fit a layout to. */
 function hasPlanarCoords(graph) {
@@ -116,10 +203,7 @@ function projectPlanar(graph, center) {
         // reads as further north.
         const nx = 0.5 + (bus.xy[0] - cx) * s;
         const ny = 0.5 + (bus.xy[1] - cy) * s;
-        coords.set(bus.id, [
-            center.lon + (nx - 0.5) * lonSpan,
-            center.lat + (ny - 0.5) * latSpan
-        ]);
+        coords.set(bus.id, [center.lon + (nx - 0.5) * lonSpan, center.lat + (ny - 0.5) * latSpan]);
     }
     return coords;
 }
@@ -188,7 +272,7 @@ export function placeMultiView(graph, center) {
 // ---------------------------------------------------------------------------
 /** Rust, green, and steel-blue for the three phases; a warm gray for the
  * neutral/ground return. Distinct in hue and lightness so they survive color
- * vision deficiency and never read as the LMP ramp. */
+ * vision deficiency and never read as the nodal value ramp. */
 const PHASE_A = [194, 86, 75, 255];
 const PHASE_B = [74, 143, 95, 255];
 const PHASE_C = [63, 111, 187, 255];
@@ -215,6 +299,15 @@ export function phaseColor(terminal) {
 export function isPhaseTerminal(terminal) {
     return ['1', '2', '3', 'a', 'b', 'c'].includes(terminal.trim().toLowerCase());
 }
+/** Return the explicit neutral conductor in a terminal map. Other non-phase
+ * labels are left alone: an arbitrary terminal name is not evidence that the
+ * network has a usable neutral reference. */
+export function neutralTerminal(terminals, declared) {
+    if (declared !== undefined)
+        return declared && terminals.includes(declared) ? declared : null;
+    return (terminals.find((terminal) => ['n', '4', 'neutral'].includes(terminal.trim().toLowerCase())) ??
+        null);
+}
 /** Base color for an edge by kind and state. Lines are the warm gray of the
  * single-phase branches; transformers are steel; a switch is amber when closed
  * and a faded red when open. */

package/dist/notices.svelte.d.ts

@@ -0,0 +1,29 @@
+export interface NoticeInput {
+    title: string;
+    details: string;
+    kind?: 'error' | 'warning';
+    retry?: () => void;
+    canRetry?: () => boolean;
+}
+export interface Notice extends NoticeInput {
+    id: number;
+    count: number;
+    updatedAt: number;
+}
+/** Recent messages stay in memory; dismissal hides the temporary notice only. */
+export declare class NoticeCenter {
+    #private;
+    entries: Notice[];
+    activeId: number | null;
+    expanded: boolean;
+    announcement: string;
+    get active(): Notice | null;
+    push(input: NoticeInput): void;
+    pause(value: boolean): void;
+    dismiss(): void;
+    clear(): void;
+    dispose(): void;
+}
+export declare const setNoticeCenter: (value: NoticeCenter) => NoticeCenter;
+export declare function getNoticeCenter(): NoticeCenter;
+export declare function errorNoticeTitle(details: string): string;

package/dist/notices.svelte.js

@@ -0,0 +1,82 @@
+import { getContext, setContext } from 'svelte';
+const KEY = Symbol('tellegen.notices');
+const LIFETIME_MS = 6500;
+const MAX_NOTICES = 30;
+/** Recent messages stay in memory; dismissal hides the temporary notice only. */
+export class NoticeCenter {
+    entries = $state.raw([]);
+    activeId = $state(null);
+    expanded = $state(false);
+    announcement = $state('');
+    #nextId = 0;
+    #timer;
+    #deadline = 0;
+    #remaining = LIFETIME_MS;
+    #paused = false;
+    get active() {
+        return this.entries.find((entry) => entry.id === this.activeId) ?? null;
+    }
+    push(input) {
+        if (!input.details)
+            return;
+        const previous = this.entries.find((entry) => entry.details === input.details && entry.kind === input.kind);
+        const entry = {
+            ...input,
+            id: previous?.id ?? ++this.#nextId,
+            count: (previous?.count ?? 0) + 1,
+            updatedAt: Date.now()
+        };
+        this.entries = [entry, ...this.entries.filter((item) => item.id !== entry.id)].slice(0, MAX_NOTICES);
+        this.activeId = entry.id;
+        this.announcement = `${entry.title}${entry.count > 1 ? `, repeated ${entry.count} times` : ''}`;
+        this.#remaining = LIFETIME_MS;
+        this.#schedule();
+    }
+    #schedule() {
+        clearTimeout(this.#timer);
+        if (this.#paused || this.activeId === null)
+            return;
+        this.#deadline = Date.now() + this.#remaining;
+        this.#timer = setTimeout(() => this.dismiss(), this.#remaining);
+    }
+    pause(value) {
+        if (value === this.#paused)
+            return;
+        if (value)
+            this.#remaining = Math.max(0, this.#deadline - Date.now());
+        this.#paused = value;
+        this.#schedule();
+    }
+    dismiss() {
+        clearTimeout(this.#timer);
+        this.activeId = null;
+    }
+    clear() {
+        this.dismiss();
+        this.entries = [];
+        this.expanded = false;
+    }
+    dispose() {
+        clearTimeout(this.#timer);
+    }
+}
+export const setNoticeCenter = (value) => setContext(KEY, value);
+export function getNoticeCenter() {
+    const value = getContext(KEY);
+    if (!value)
+        throw new Error('NoticeCenter requires a Tellegen provider');
+    return value;
+}
+export function errorNoticeTitle(details) {
+    if (/rate limit/i.test(details))
+        return 'Too many requests';
+    if (/storage|quota|space|indexeddb/i.test(details))
+        return 'Could not save locally';
+    if (/sensitivity|derivative|singular/i.test(details))
+        return 'Sensitivity unavailable';
+    if (/infeasib|converg|solver|solving|calculation|compute|webassembly/i.test(details))
+        return 'Calculation did not complete';
+    if (/parse|read|file|format/i.test(details))
+        return 'Could not read this file';
+    return 'Operation did not complete';
+}

package/dist/panels.svelte.d.ts

@@ -0,0 +1,65 @@
+import { type Snippet } from 'svelte';
+export type PanelSide = 'left' | 'right';
+export type PanelPosition = PanelSide | 'floating';
+export interface PanelBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface PanelRegistration {
+    id: string;
+    title: string;
+    side: PanelSide;
+    order: number;
+    width: number;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    children: Snippet;
+    headerActions?: Snippet;
+    onopen?: () => void;
+}
+interface SavedPanel extends PanelBounds {
+    position: PanelPosition;
+}
+export declare const PANEL_BREAKPOINT = 960;
+export declare const PANEL_MIN_DOCK_HEIGHT = 500;
+export declare const PANEL_COMPACT_QUERY = "(max-width: 960px), (max-height: 499px)";
+/** Layout belongs to one provider and stores presentation preferences only. */
+export declare class PanelLayout {
+    #private;
+    panels: PanelRegistration[];
+    placements: Record<string, SavedPanel>;
+    compact: boolean;
+    drawer: string | null;
+    lastActive: string;
+    dockActive: Record<PanelSide, string>;
+    viewportWidth: number;
+    viewportHeight: number;
+    top: number;
+    bottom: number;
+    storageError: string | null;
+    beginGesture(panel: PanelRegistration, kind: 'move' | 'resize', x: number, y: number, bounds: PanelBounds): void;
+    moveGesture(x: number, y: number): void;
+    finishGesture(): void;
+    register(panel: PanelRegistration): () => void;
+    update(id: string, open: boolean, title: string, width: number): void;
+    activate(panel: PanelRegistration): void;
+    preferred(panel: PanelRegistration): boolean;
+    position(panel: PanelRegistration): PanelPosition;
+    ordered(side?: PanelSide): PanelRegistration[];
+    toggle(panel: PanelRegistration): void;
+    close(panel: PanelRegistration): void;
+    dock(panel: PanelRegistration, side?: PanelSide): void;
+    float(panel: PanelRegistration, bounds?: PanelBounds): void;
+    bounds(panel: PanelRegistration): PanelBounds;
+    clamp(bounds: PanelBounds): PanelBounds;
+    resizeViewport(width: number, height: number, top: number): void;
+    dockWidth(side: PanelSide): number;
+    reset(): void;
+    initialize(storage?: Storage): void;
+    save(): void;
+}
+export declare const setPanelLayout: (layout: PanelLayout) => PanelLayout;
+export declare const getPanelLayout: () => PanelLayout;
+export {};