@tellegen/svelte 0.5.0 → 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/map-bounds.d.ts

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

package/dist/map-bounds.js

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

package/dist/state.svelte.d.ts

@@ -95,6 +95,11 @@ export declare class LocalCase {
     coordsKind: CoordsKind | undefined;
     /** Map geometry when the file carried or received coordinates. */
     view: LocalView | null;
+    /** Buses a generated grid marks as line taps. The map draws no marker for
+     * them; the bus picker and the selection still reach them. */
+    readonly tapBuses: ReadonlySet<number>;
+    /** `view.buses` less the line taps: the buses the map draws as markers. */
+    readonly markerBuses: NetworkBus[];
     syntheticCenter: {
         lon: number;
         lat: number;

package/dist/state.svelte.js

@@ -1,4 +1,5 @@
 import { DEFAULT_MC_PF_OPTIONS, summarizeMcExcludedIslands } from '@tellegen/engine';
+import { tapBusIds, withoutTaps } from './bus-kinds.js';
 import { DEFAULT_FORMULATION } from '@tellegen/engine';
 import { DiagnosticLog, errorEntry } from './log.svelte.js';
 import { graphInputs } from './diagram/graph-inputs.js';
@@ -27,6 +28,11 @@ export class LocalCase {
     coordsKind = $state.raw(undefined);
     /** Map geometry when the file carried or received coordinates. */
     view = $state.raw(null);
+    /** Buses a generated grid marks as line taps. The map draws no marker for
+     * them; the bus picker and the selection still reach them. */
+    tapBuses = $derived(tapBusIds(this.studyInputJson));
+    /** `view.buses` less the line taps: the buses the map draws as markers. */
+    markerBuses = $derived(withoutTaps(this.view?.buses ?? [], this.tapBuses));
     syntheticCenter = $state.raw(undefined);
     diagram = $state.raw(null);
     displayMode = $state('geographic');

package/package.json

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