@tellegen/svelte 0.2.0 → 0.4.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.d.ts

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

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,9 +23,21 @@ 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 const INFEASIBLE_DISPATCH = 'No feasible dispatch: demand cannot be served within line and generator limits';
+/** The message for a local case whose browser solve failed, and the
+ * technical detail to disclose behind it. An infeasible DC OPF means the
+ * network cannot carry the demand, which deserves plain words. The engine
+ * spells it `DC OPF solve infeasible`, and an unbounded one as `unbounded`. */
+export function browserSolveFailure(label, reason) {
+    const technical = `${label}: browser solve unavailable${reason ? `: ${reason}` : ''}`;
+    if (reason && /\binfeasible\b/i.test(reason)) {
+        return { message: INFEASIBLE_DISPATCH, detail: technical };
+    }
+    return { message: technical, detail: null };
+}
 export function rgbaCss([r, g, b, a]) {
     return `rgba(${r}, ${g}, ${b}, ${(a / 255).toFixed(3)})`;
 }
@@ -46,4 +59,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,19 +1,29 @@
+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';
 export { default as TellegenMap } from './TellegenMap.svelte';
 export { DEFAULT_TELLEGEN_UI_CONFIG, getAppState, getController, getUiConfig, resolveTellegenUiConfig, setAppState, setController, setUiConfig } from './context.svelte.js';
 export { ApiError, createApiClient } from './api.js';
+export { CARTO_STYLES, OPENFREEMAP_STYLES, attachBasemapFallback, cartoStyleUrl, defaultBasemap, isOpenFreeMapStyle, openFreeMapEdits, resolveBasemap } from './basemap.js';
+export { MAP_PALETTE } from './colors.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 { ControllerOptions, OpenBalancedModuleInput } from './controller.svelte.js';
+export type { BasemapFallbackReason, BasemapMapLike, BasemapProvider, BasemapSpec, BasemapStyle, BasemapSwitch, BasemapTheme, DefaultBasemap, MapProjection, MapTheme, ResolvedBasemap, StyleEdit } from './basemap.js';
+export type { MapPalette } from './colors.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,12 +1,19 @@
+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';
 export { default as TellegenMap } from './TellegenMap.svelte';
 export { DEFAULT_TELLEGEN_UI_CONFIG, getAppState, getController, getUiConfig, resolveTellegenUiConfig, setAppState, setController, setUiConfig } from './context.svelte.js';
 export { ApiError, createApiClient } from './api.js';
+export { CARTO_STYLES, OPENFREEMAP_STYLES, attachBasemapFallback, cartoStyleUrl, defaultBasemap, isOpenFreeMapStyle, openFreeMapEdits, resolveBasemap } from './basemap.js';
+export { MAP_PALETTE } from './colors.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,8 +1,10 @@
 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 { CARTO_STYLES, OPENFREEMAP_STYLES, attachBasemapFallback, cartoStyleUrl, defaultBasemap, isOpenFreeMapStyle, openFreeMapEdits, resolveBasemap } from './basemap.js';
+export type { BasemapFallbackReason, BasemapMapLike, BasemapProvider, BasemapSpec, BasemapStyle, BasemapSwitch, BasemapTheme, DefaultBasemap, MapProjection, MapTheme, ResolvedBasemap, StyleEdit } from './basemap.js';
+export { MAP_PALETTE, 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 { MapPalette, RGBA, SensitivityDomain } from './colors.js';
 export type { DisplayOption } from './display.js';
 export type TellegenMapProps = ComponentProps<typeof TellegenMap>;

package/dist/map.js

@@ -1,4 +1,5 @@
 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 { CARTO_STYLES, OPENFREEMAP_STYLES, attachBasemapFallback, cartoStyleUrl, defaultBasemap, isOpenFreeMapStyle, openFreeMapEdits, resolveBasemap } from './basemap.js';
+export { MAP_PALETTE, 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/maplibre-worker.d.ts

@@ -0,0 +1,5 @@
+/** The URL of MapLibre's worker, which the host's Vite build bundles with its
+ * shared chunk. `TellegenMap` hands it to `setWorkerUrl` before it creates a
+ * map. Reached through the `@tellegen/svelte/maplibre-worker` export; see
+ * `maplibre-worker.dev.ts` for the dev server. */
+export declare function maplibreWorkerUrl(): Promise<string>;

package/dist/maplibre-worker.dev.d.ts

@@ -0,0 +1,11 @@
+/** The dev server's `@tellegen/svelte/maplibre-worker`, chosen by the
+ * `development` export condition.
+ *
+ * Vite's dev server pre-bundles this package with Rolldown, which cannot load
+ * the `?worker&url` import in `maplibre-worker.ts`, so a static import of that
+ * module would stop the dev server at startup. Here it is imported at run time
+ * by URL instead, outside the pre-bundle, and the dev server resolves the
+ * query itself. Vite rewrites the `new URL` in a pre-bundled file to point at
+ * the original. A production build takes the default condition and imports
+ * `maplibre-worker.ts` directly. */
+export declare function maplibreWorkerUrl(): Promise<string>;

package/dist/maplibre-worker.dev.js

@@ -0,0 +1,15 @@
+/** The dev server's `@tellegen/svelte/maplibre-worker`, chosen by the
+ * `development` export condition.
+ *
+ * Vite's dev server pre-bundles this package with Rolldown, which cannot load
+ * the `?worker&url` import in `maplibre-worker.ts`, so a static import of that
+ * module would stop the dev server at startup. Here it is imported at run time
+ * by URL instead, outside the pre-bundle, and the dev server resolves the
+ * query itself. Vite rewrites the `new URL` in a pre-bundled file to point at
+ * the original. A production build takes the default condition and imports
+ * `maplibre-worker.ts` directly. */
+export async function maplibreWorkerUrl() {
+    const url = new URL('./maplibre-worker.js', import.meta.url).href;
+    const module = await import(/* @vite-ignore */ url);
+    return module.maplibreWorkerUrl();
+}

package/dist/maplibre-worker.js

@@ -0,0 +1,8 @@
+import workerUrl from 'maplibre-gl/dist/maplibre-gl-worker.mjs?worker&url';
+/** The URL of MapLibre's worker, which the host's Vite build bundles with its
+ * shared chunk. `TellegenMap` hands it to `setWorkerUrl` before it creates a
+ * map. Reached through the `@tellegen/svelte/maplibre-worker` export; see
+ * `maplibre-worker.dev.ts` for the dev server. */
+export async function maplibreWorkerUrl() {
+    return workerUrl;
+}

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;