@tellegen/svelte 0.4.7 → 0.5.1

package/README.md

@@ -231,6 +231,9 @@ The map switches to the fallback in three cases:
 - its tiles answer 401, 403 or 429;
 - tile fetches keep failing with nothing arriving.
 
+Only the basemap style's own sources count. A source the host adds to the map
+never triggers the switch, and its errors are logged to the console.
+
 Whenever an OpenFreeMap style renders, as primary or as fallback,
 `openFreeMapEdits` tunes it towards CARTO's look. Road lines start at zoom 8.
 In the dark theme, water and waterways take Dark Matter's colours and land
@@ -260,13 +263,34 @@ besides its click callbacks:
 - `onMapReady(map, overlay)`: called with the MapLibre map and the deck
   overlay once they exist. It may return a cleanup, and it fires again after
   a context-loss or basemap rebuild. If it throws, the map and its window
-  and document listeners are still released when the map is torn down.
+  and document listeners are still released when the map is torn down. A
+  switch to the fallback does not call it again (see below).
 - `onBasemapFallback(reason)`: the switch to the fallback happened.
   `reason.from` and `reason.to` name the two providers.
 - `onBasemapError(reason)`: no basemap can be shown. The network layers
   still draw. `reason.from` names the provider that failed last, and
   `reason.to` is `null`.
 
+The switch to the fallback replaces the whole MapLibre style, so sources and
+layers the host added to the map are gone after it. The network,
+`extraLayers` and `projection` carry over. A host that adds its own sources
+and layers adds them on every `style.load`, not once in `onMapReady`, which
+runs before the first style loads, so one listener covers the primary and the
+fallback:
+
+```ts
+import type { Map as MapLibreMap } from "maplibre-gl";
+
+function onMapReady(map: MapLibreMap) {
+  const addFeeders = () => {
+    map.addSource("feeders", { type: "geojson", data: "/feeders.geojson" });
+    map.addLayer({ id: "feeders", type: "line", source: "feeders" });
+  };
+  map.on("style.load", addFeeders);
+  return () => map.off("style.load", addFeeders);
+}
+```
+
 `TellegenProvider` and `TellegenViewer` also take `cartoApiKey`, and pass it,
 together with `theme`, to the default shell's map. Both follow their props:
 changing either rebuilds that map in place. A SvelteKit 3 host can

package/dist/TellegenMap.svelte

@@ -56,6 +56,7 @@
 	} from './transformer-icon.js';
 	import { createGlobeHorizon, withGlobeHorizon } from './globe-horizon.js';
 	import { foldMapBounds } from './map-bounds.js';
+	import { nearestLongitude, routeBounds, unwrapLongitudePath } from './antimeridian.js';
 	import { getAppState, getController } from './context.svelte.js';
 	import { displayFmt, fmt, rgbaCss } from './format.js';
 	import { getPanelLayout } from './panels.svelte.js';
@@ -126,7 +127,9 @@
 		attribution?: 'compact' | 'full';
 		/** Called once the map and overlay exist, with an optional cleanup. It
 		 * fires again after a context-loss or basemap remount, after the previous
-		 * cleanup ran. */
+		 * cleanup ran. It runs before the first style loads, and a switch to the
+		 * fallback basemap does not call it again: the new style drops every
+		 * source and layer the host added, so add those on each `style.load`. */
 		onMapReady?: (map: MapLibreMap, overlay: MapLibreOverlay) => void | (() => void);
 		/** The primary basemap failed and the fallback was requested. The
 		 * reason's `from` and `to` name the providers (`'carto'`,
@@ -473,7 +476,12 @@
 		const branch = displayedGeometry(caseId)?.branches.find((b) => b.id === branchId);
 		const path = branch?.path.filter(([lon, lat]) => Number.isFinite(lon) && Number.isFinite(lat));
 		return branch && path && path.length >= 2
-			? { key: `${app.studyView?.id ?? caseId}-${branch.id}`, caseId, branchId: branch.id, path }
+			? {
+					key: `${app.studyView?.id ?? caseId}-${branch.id}`,
+					caseId,
+					branchId: branch.id,
+					path: unwrapLongitudePath(path)
+				}
 			: null;
 	});
 	let selectedCueEl = $state.raw<HTMLDivElement | null>(null);
@@ -496,9 +504,16 @@
 	});
 	let multiDetailEl = $state.raw<SVGSVGElement | null>(null);
 
+	/** The screen point of a coordinate in the world copy nearest the camera.
+	 * MapLibre projects a longitude in the copy it names, so a point across the
+	 * antimeridian from the camera would land a whole world width away. */
+	function projectNear(m: MapLibreMap, [lon, lat]: [number, number]) {
+		return m.project([nearestLongitude(lon, m.getCenter().lng), lat]);
+	}
+
 	function syncSelectedCue() {
 		if (!map || !selectedCueEl || !selectedBusCue) return;
-		const point = map.project([selectedBusCue.lon, selectedBusCue.lat]);
+		const point = projectNear(map, [selectedBusCue.lon, selectedBusCue.lat]);
 		const { clientWidth, clientHeight } = map.getContainer();
 		const inRange =
 			point.x >= -40 &&
@@ -522,8 +537,12 @@
 		}
 		const activeMap = map;
 		const { clientWidth, clientHeight } = activeMap.getContainer();
+		// The path is unwrapped, so one shift by whole turns moves all of it to
+		// the world copy nearest the camera without breaking it at the seam.
+		const [lon0] = selectedBranchCue.path[0];
+		const shift = nearestLongitude(lon0, activeMap.getCenter().lng) - lon0;
 		const points = selectedBranchCue.path
-			.map(([lon, lat]) => activeMap.project([lon, lat]))
+			.map(([lon, lat]) => activeMap.project([lon + shift, lat]))
 			.filter((p) => Number.isFinite(p.x) && Number.isFinite(p.y));
 		if (clientWidth === 0 || clientHeight === 0 || points.length < 2) {
 			selectedBranchCueEl.style.display = 'none';
@@ -589,14 +608,14 @@
 			return;
 		}
 		const { bus, edges } = detail;
-		const busPt = m.project([bus.lon, bus.lat]);
+		const busPt = projectNear(m, [bus.lon, bus.lat]);
 
 		const STRAND_SPACING = 5;
 		let strands = '';
 		for (const e of edges) {
 			const selectedIsFrom = e.from === bus.id;
 			const other = selectedIsFrom ? e.path[e.path.length - 1] : e.path[0];
-			const b = m.project(other);
+			const b = projectNear(m, other);
 			const dx = b.x - busPt.x;
 			const dy = b.y - busPt.y;
 			const len = Math.hypot(dx, dy) || 1;
@@ -677,7 +696,7 @@
 	}
 
 	function branchBounds(path: [number, number][]): LngLatBoundsLike | null {
-		return foldMapBounds(path);
+		return routeBounds(path);
 	}
 
 	function prefersReducedMotion(): boolean {
@@ -1077,6 +1096,12 @@
 	// Sync deck.gl layers with app state. New layer instances diff cheaply;
 	// updateTriggers tell deck.gl when accessor outputs changed. Host layers
 	// (`extraLayers`) draw after tellegen's own at both exits.
+	//
+	// Stored routes keep longitudes in [-180, 180], so a route across the
+	// antimeridian is unwrapped before drawing and each segment takes the
+	// short way. On the globe deck.gl ignores `wrapLongitude` and needs the
+	// unwrapped path itself; on the flat map `wrapLongitude` cuts the path at
+	// ±180 so both halves draw in every world copy.
 	$effect(() => {
 		if (!overlay || !layerCtors) return;
 		const { PathLayer, ScatterplotLayer, IconLayer } = layerCtors;
@@ -1108,7 +1133,8 @@
 				new PathLayer<NetworkBranch>({
 					id: 'study-branches',
 					data: study.network.branches,
-					getPath: (b) => b.path,
+					getPath: (b) => unwrapLongitudePath(b.path),
+					wrapLongitude: true,
 					getColor: (b) => branchColor(flows.get(b.id) ?? 0, b.status === 1),
 					getWidth: (b) => branchWidth(flows.get(b.id) ?? 0),
 					widthUnits: 'pixels',
@@ -1163,7 +1189,8 @@
 				new PathLayer<NetworkBranch>({
 					id: `branches-${c.id}`,
 					data: c.network.branches,
-					getPath: (b) => b.path,
+					getPath: (b) => unwrapLongitudePath(b.path),
+					wrapLongitude: true,
 					// The selected branch draws in the selection blue of the bus halo cue,
 					// wider, so the price-rating source line reads at a glance.
 					getColor: (b) =>
@@ -1230,15 +1257,21 @@
 		}
 		// Local cases are grey until the browser solve returns. A .pwd display
 		// file contributes substation points only, in a cooler slate so they
-		// read as diagram derived positions.
+		// read as diagram derived positions. A generated grid's line taps draw
+		// no marker, as their lines show them, unless one is the selected bus.
 		for (const c of app.localCases) {
 			if (c.view) {
 				const d = display.get(c.id);
+				const selectedTap =
+					c.id === app.activeLocalId && app.selectedBus !== null && c.tapBuses.has(app.selectedBus)
+						? c.view.buses.find((b) => b.id === app.selectedBus)
+						: undefined;
 				layers.push(
 					new PathLayer<NetworkBranch>({
 						id: `local-branches-${c.id}`,
 						data: c.view.branches,
-						getPath: (b) => b.path,
+						getPath: (b) => unwrapLongitudePath(b.path),
+						wrapLongitude: true,
 						getColor: (b) =>
 							c.id === app.activeLocalId && b.id === app.selectedBranch
 								? [47, 111, 187, 255]
@@ -1272,7 +1305,7 @@
 					}),
 					new ScatterplotLayer<NetworkBus>({
 						id: `local-buses-${c.id}`,
-						data: c.view.buses,
+						data: selectedTap ? [...c.markerBuses, selectedTap] : c.markerBuses,
 						getPosition: (b) => [b.lon, b.lat],
 						getRadius: (b) => marker.radius(Math.max(b.demand_mw, b.gen_mw)),
 						radiusUnits: marker.radiusUnits,
@@ -1343,7 +1376,8 @@
 				new PathLayer<PlacedMultiEdge>({
 					id: `multi-edges-${c.id}`,
 					data: c.view.edges,
-					getPath: (e) => e.path,
+					getPath: (e) => unwrapLongitudePath(e.path),
+					wrapLongitude: true,
 					// The selected edge draws in the selection blue of the branch cue,
 					// wider, so its panel detail has an obvious source on the map.
 					getColor: (e) =>

package/dist/TellegenMap.svelte.d.ts

@@ -44,7 +44,9 @@ type $$ComponentProps = {
     attribution?: 'compact' | 'full';
     /** Called once the map and overlay exist, with an optional cleanup. It
      * fires again after a context-loss or basemap remount, after the previous
-     * cleanup ran. */
+     * cleanup ran. It runs before the first style loads, and a switch to the
+     * fallback basemap does not call it again: the new style drops every
+     * source and layer the host added, so add those on each `style.load`. */
     onMapReady?: (map: MapLibreMap, overlay: MapLibreOverlay) => void | (() => void);
     /** The primary basemap failed and the fallback was requested. The
      * reason's `from` and `to` name the providers (`'carto'`,

package/dist/antimeridian.d.ts

@@ -0,0 +1,21 @@
+/** Coordinate helpers for geographic paths drawn across the antimeridian.
+ *
+ * Stored longitudes stay in [-180, 180]. A drawn path is unwrapped so each
+ * vertex lies within 180° of the one before, and every segment takes the
+ * short way across ±180 instead of crossing the whole map.
+ */
+import { type MapBounds } from './map-bounds.js';
+export type LngLat = readonly [number, number];
+/** `lon` moved by whole turns of 360° to lie within 180° of `reference`.
+ * Returned unchanged when either value is not finite. */
+export declare function nearestLongitude(lon: number, reference: number): number;
+/** Return a display path whose consecutive longitudes differ by at most 180°.
+ * The returned longitudes may lie outside [-180, 180]; use only for drawing,
+ * never for serialization or exported GeoJSON. A vertex whose longitude is
+ * not finite is copied as it is and does not anchor the next one. */
+export declare function unwrapLongitudePath(path: readonly LngLat[]): [number, number][];
+/** Bounds of a stored route around its short arc, so a seam-crossing route
+ * frames the few degrees it spans rather than the whole world. West may lie
+ * below -180 or east above 180. Vertices `foldMapBounds` ignores are ignored
+ * here too. */
+export declare function routeBounds(path: readonly LngLat[]): MapBounds | null;

package/dist/antimeridian.js

@@ -0,0 +1,40 @@
+/** Coordinate helpers for geographic paths drawn across the antimeridian.
+ *
+ * Stored longitudes stay in [-180, 180]. A drawn path is unwrapped so each
+ * vertex lies within 180° of the one before, and every segment takes the
+ * short way across ±180 instead of crossing the whole map.
+ */
+import { isMapPoint, spanBounds } from './map-bounds.js';
+/** `lon` moved by whole turns of 360° to lie within 180° of `reference`.
+ * Returned unchanged when either value is not finite. */
+export function nearestLongitude(lon, reference) {
+    const delta = lon - reference;
+    if (!Number.isFinite(delta) || Math.abs(delta) <= 180)
+        return lon;
+    return lon - 360 * Math.round(delta / 360);
+}
+/** Return a display path whose consecutive longitudes differ by at most 180°.
+ * The returned longitudes may lie outside [-180, 180]; use only for drawing,
+ * never for serialization or exported GeoJSON. A vertex whose longitude is
+ * not finite is copied as it is and does not anchor the next one. */
+export function unwrapLongitudePath(path) {
+    const out = [];
+    let previous = null;
+    for (const [rawLongitude, latitude] of path) {
+        if (!Number.isFinite(rawLongitude)) {
+            out.push([rawLongitude, latitude]);
+            continue;
+        }
+        const longitude = previous === null ? rawLongitude : nearestLongitude(rawLongitude, previous);
+        out.push([longitude, latitude]);
+        previous = longitude;
+    }
+    return out;
+}
+/** Bounds of a stored route around its short arc, so a seam-crossing route
+ * frames the few degrees it spans rather than the whole world. West may lie
+ * below -180 or east above 180. Vertices `foldMapBounds` ignores are ignored
+ * here too. */
+export function routeBounds(path) {
+    return spanBounds(unwrapLongitudePath(path.filter(isMapPoint)));
+}

package/dist/basemap.d.ts

@@ -157,6 +157,10 @@ export interface BasemapMapLike {
     }): unknown;
     /** MapLibre types this `boolean | void`; only `true` counts as loaded. */
     isStyleLoaded(): boolean | void;
+    /** Read at every `style.load` to learn which sources the basemap style
+     * brings, before a host adds its own. Without it, every source counts as
+     * the basemap's. */
+    getStyle?(): StyleSpecification | undefined;
 }
 export interface BasemapFallbackHandlers {
     /** The primary failed and the fallback style was requested. `from` is the
@@ -185,6 +189,12 @@ export interface BasemapFallbackOptions {
  * 5. everything else is logged the way MapLibre logs an unhandled error,
  *    because registering this listener silences that default.
  *
+ * Rules 2 and 3 only count errors from the basemap style's own sources: the
+ * sources `map.getStyle()` lists when that style's `style.load` reaches this
+ * listener, so attach it before any listener that adds sources. A source the
+ * host adds later, through `onMapReady` for instance, falls under rule 5 and
+ * never switches the basemap.
+ *
  * After the switch the same rules report `onFailure` instead of switching
  * again, as they do when `spec.fallback` is `null`. Returns a detach
  * function. */

package/dist/basemap.js

@@ -169,6 +169,12 @@ function errorStatus(error) {
  * 5. everything else is logged the way MapLibre logs an unhandled error,
  *    because registering this listener silences that default.
  *
+ * Rules 2 and 3 only count errors from the basemap style's own sources: the
+ * sources `map.getStyle()` lists when that style's `style.load` reaches this
+ * listener, so attach it before any listener that adds sources. A source the
+ * host adds later, through `onMapReady` for instance, falls under rule 5 and
+ * never switches the basemap.
+ *
  * After the switch the same rules report `onFailure` instead of switching
  * again, as they do when `spec.fallback` is `null`. Returns a detach
  * function. */
@@ -176,7 +182,14 @@ export function attachBasemapFallback(map, spec, handlers = {}, options = {}) {
     const now = options.now ?? (() => Date.now());
     const primaryProvider = spec.primaryProvider ?? 'custom';
     const fallbackProvider = spec.fallback === null ? null : (spec.fallbackProvider ?? 'custom');
+    /** The source ids of the style on screen, or `null` while unknown, when
+     * every source counts as the basemap's. */
+    const styleSources = () => {
+        const style = map.getStyle?.();
+        return style ? new Set(Object.keys(style.sources ?? {})) : null;
+    };
     let styleLoaded = map.isStyleLoaded() === true;
+    let basemapSources = styleLoaded ? styleSources() : null;
     let fellBack = false;
     let failed = false;
     let tileFailures = 0;
@@ -196,6 +209,7 @@ export function attachBasemapFallback(map, spec, handlers = {}, options = {}) {
         }
         fellBack = true;
         styleLoaded = false;
+        basemapSources = null;
         tileFailures = 0;
         tileArrived = false;
         handlers.onFallback?.({ ...reason, from: primaryProvider, to: fallbackProvider });
@@ -206,6 +220,7 @@ export function attachBasemapFallback(map, spec, handlers = {}, options = {}) {
     };
     const onStyleLoad = () => {
         styleLoaded = true;
+        basemapSources = styleSources();
     };
     const onSourceData = (event) => {
         if (event?.tile || event?.isSourceLoaded === true)
@@ -227,6 +242,11 @@ export function attachBasemapFallback(map, spec, handlers = {}, options = {}) {
             passThrough(event);
             return;
         }
+        // A host's own source failing says nothing about the basemap.
+        if (basemapSources !== null && !basemapSources.has(sourceId)) {
+            passThrough(event);
+            return;
+        }
         if ((status !== undefined && FORBIDDEN_STATUSES.has(status)) ||
             FORBIDDEN_MESSAGE.test(message)) {
             fallBack({ kind: 'source-forbidden', message, status: status ?? 0, sourceId });

package/dist/bus-kinds.d.ts

@@ -0,0 +1,9 @@
+import type { NetworkBus } from './api.js';
+/** Ids of the buses a generated grid marks as line taps: points where a line
+ * is tapped, with no load or machine. tellegen-synth records the kind in
+ * each bus row's `extras.tellegen_synth.kind`; the map view does not carry
+ * it. Empty for any other module, and for text that does not parse. */
+export declare function tapBusIds(moduleJson: string | null | undefined): ReadonlySet<number>;
+/** `buses` less the taps, the ones the map draws as markers. The same array
+ * when there is no tap to drop, so the map layer keeps its data. */
+export declare function withoutTaps(buses: NetworkBus[], taps: ReadonlySet<number>): NetworkBus[];

package/dist/bus-kinds.js

@@ -0,0 +1,33 @@
+/** The `extras` key under which tellegen-synth records each element's
+ * annotation in the modules it writes. */
+const SYNTH_EXTRAS = 'tellegen_synth';
+/** Ids of the buses a generated grid marks as line taps: points where a line
+ * is tapped, with no load or machine. tellegen-synth records the kind in
+ * each bus row's `extras.tellegen_synth.kind`; the map view does not carry
+ * it. Empty for any other module, and for text that does not parse. */
+export function tapBusIds(moduleJson) {
+    const ids = new Set();
+    // Only a module tellegen-synth wrote is parsed a second time; a branch's
+    // `"tap"` ratio is in every transmission case.
+    if (!moduleJson?.includes(`"${SYNTH_EXTRAS}"`) || !moduleJson.includes('"tap"'))
+        return ids;
+    let buses;
+    try {
+        buses = JSON.parse(moduleJson)?.value?.data?.buses;
+    }
+    catch {
+        return ids;
+    }
+    if (!Array.isArray(buses))
+        return ids;
+    for (const bus of buses) {
+        if (typeof bus?.id === 'number' && bus.extras?.[SYNTH_EXTRAS]?.kind === 'tap')
+            ids.add(bus.id);
+    }
+    return ids;
+}
+/** `buses` less the taps, the ones the map draws as markers. The same array
+ * when there is no tap to drop, so the map layer keeps its data. */
+export function withoutTaps(buses, taps) {
+    return taps.size === 0 ? buses : buses.filter((b) => !taps.has(b.id));
+}

package/dist/components/DiagramCanvas.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { mcNetworkScopeLabel, mcLoadModelLabel } from '@tellegen/engine';
 	import { untrack } from 'svelte';
 	import { on } from 'svelte/events';
 	import type { Network, NetworkBus } from '../api.js';
@@ -395,7 +396,10 @@
 			>
 		</div>
 	</div>
-	<p class="coordinate-label">Diagram coordinates</p>
+	<p class="coordinate-label">
+		Diagram coordinates{#if multiconductor?.result}
+			· {mcLoadModelLabel(multiconductor.result.load_model)} · {mcNetworkScopeLabel(multiconductor.result.network_scope)}{/if}
+	</p>
 </div>
 
 <style>

package/dist/components/McModelQualification.svelte

@@ -0,0 +1,67 @@
+<script lang="ts">
+	import { mcLoadModelLabel, type McLoadModelAssessment } from '@tellegen/engine';
+	let { model, compact = false }: { model?: McLoadModelAssessment | null; compact?: boolean } =
+		$props();
+</script>
+
+<aside class:warning={model?.status !== 'original'} aria-label="Load-model qualification">
+	<strong>{mcLoadModelLabel(model)}</strong>
+	{#if model?.status === 'modified'}
+		<p>
+			The calculation converged using modified load equations on {model.modified_branch_count}
+			load {model.modified_branch_count === 1 ? 'branch' : 'branches'}. These values are not a
+			verified solution of the original load model. The qualification is retained when saving or
+			exporting.
+		</p>
+	{:else if model?.status !== 'original'}
+		<p>
+			These results have no verified solution of the original load equations. Rerun to assess the
+			load model.
+		</p>
+	{/if}
+	{#if model && !compact}
+		<details>
+			<summary>Model assessment and settings used</summary>
+			<p>
+				Original-model KCL residual: {model.original_kcl_residual === null
+					? 'undefined at this voltage'
+					: `${model.original_kcl_residual.toExponential(3)} A`}. Scaled residual: {model.original_scaled_kcl_residual ===
+				null
+					? 'unavailable'
+					: model.original_scaled_kcl_residual.toPrecision(4)} (at most 1 passes).
+			</p>
+			<p>
+				Load-model envelope {model.options.voltage_envelope ? 'enabled' : 'disabled'}; Vlow {model
+					.options.v_low_pu}, Vmin {model.options.v_min_pu}, Vmax {model.options.v_max_pu} pu. These thresholds
+				change load equations; they are not operating voltage limits.
+			</p>
+			<p>
+				Maximum iterations {model.options.max_iterations}; damping {model.options.damping};
+				voltage-change tolerance {model.options.tolerance} V; zero-voltage tolerance {model.options
+					.zero_voltage_tolerance} V; KCL tolerances {model.options.absolute_kcl_tolerance} A absolute
+				and {model.options.relative_kcl_tolerance} relative.
+			</p>
+		</details>
+	{/if}
+</aside>
+
+<style>
+	aside {
+		margin: 0.75rem 0;
+		padding: 0.65rem;
+		border: 1px solid var(--line);
+		border-radius: 4px;
+		font-size: 12px;
+	}
+	.warning {
+		border-left: 4px solid #b7791f;
+	}
+	p {
+		margin: 0.4rem 0;
+		line-height: 1.5;
+	}
+	summary {
+		cursor: pointer;
+		margin-top: 0.4rem;
+	}
+</style>

package/dist/components/McModelQualification.svelte.d.ts

@@ -0,0 +1,8 @@
+import { type McLoadModelAssessment } from '@tellegen/engine';
+type $$ComponentProps = {
+    model?: McLoadModelAssessment | null;
+    compact?: boolean;
+};
+declare const McModelQualification: import("svelte").Component<$$ComponentProps, {}, "">;
+type McModelQualification = ReturnType<typeof McModelQualification>;
+export default McModelQualification;

package/dist/components/McNetworkScope.svelte

@@ -0,0 +1,90 @@
+<script lang="ts">
+	import {
+		mcNetworkScopeLabel,
+		type McNetworkScope as NetworkScope,
+		type McExcludedIsland
+	} from '@tellegen/engine';
+	let {
+		scope,
+		islands = [],
+		preview = false
+	}: {
+		scope?: NetworkScope | null;
+		islands?: McExcludedIsland[];
+		preview?: boolean;
+	} = $props();
+</script>
+
+{#if scope}
+	<aside aria-label="Network calculation scope">
+		<strong>{preview ? 'Unpowered islands detected' : mcNetworkScopeLabel(scope)}</strong>
+		{#if preview}<p>
+				{scope.excluded_island_count}
+				{scope.excluded_island_count === 1 ? 'island has' : 'islands have'} no voltage source.
+			</p>{/if}
+		<p>
+			{scope.excluded_bus_count}
+			{scope.excluded_bus_count === 1 ? 'bus' : 'buses'} and {scope.excluded_equipment_count}
+			equipment
+			{scope.excluded_equipment_count === 1 ? 'record' : 'records'}
+			{preview
+				? 'will be excluded when you solve the energized network'
+				: 'are excluded from the calculation'}
+			because their {scope.excluded_island_count === 1 ? 'island has' : 'islands have'} no voltage source.
+			The full network remains available for inspection. Excluded equipment has no calculated result;
+			its voltage and power are not reported as zero.
+		</p>
+		{#if scope.excluded_load_count}<p>
+				{scope.excluded_load_count}
+				{scope.excluded_load_count === 1 ? 'load has' : 'loads have'} no voltage source and {preview
+					? 'will be omitted'
+					: scope.excluded_load_count === 1
+						? 'is absent'
+						: 'are absent'} from solved totals.
+			</p>{/if}
+		{#if islands.length}
+			<details>
+				<summary
+					>{preview
+						? 'Islands and equipment to exclude'
+						: 'Excluded islands and equipment'}</summary
+				>
+				{#each islands as island, i}
+					<h4>Island {i + 1}: no voltage source</h4>
+					<p>Buses: {island.buses.join(', ')}</p>
+					<ul>
+						{#each island.equipment as item}<li>
+								{item.kind}: {item.name}
+							</li>{/each}
+					</ul>
+				{/each}
+			</details>
+		{/if}
+	</aside>
+{/if}
+
+<style>
+	aside {
+		margin: 0.75rem 0;
+		padding: 0.65rem;
+		border: 1px solid var(--line);
+		border-left: 4px solid #b7791f;
+		border-radius: 4px;
+		font-size: 12px;
+		overflow-wrap: anywhere;
+	}
+	p {
+		margin: 0.4rem 0;
+		line-height: 1.5;
+	}
+	summary {
+		cursor: pointer;
+	}
+	details {
+		max-height: 20rem;
+		overflow: auto;
+	}
+	h4 {
+		margin: 0.75rem 0 0.25rem;
+	}
+</style>

package/dist/components/McNetworkScope.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type McNetworkScope as NetworkScope, type McExcludedIsland } from '@tellegen/engine';
+type $$ComponentProps = {
+    scope?: NetworkScope | null;
+    islands?: McExcludedIsland[];
+    preview?: boolean;
+};
+declare const McNetworkScope: import("svelte").Component<$$ComponentProps, {}, "">;
+type McNetworkScope = ReturnType<typeof McNetworkScope>;
+export default McNetworkScope;