@tellegen/svelte 0.4.3 → 0.4.4

package/dist/diagram/tree-walk.js

@@ -0,0 +1,83 @@
+import { ATTACHMENT_NAMES, ATTACHMENT_ORDER, neutralEarths } from './schematic-equipment.js';
+export function treeWalk(tree, positions, stride = 3) {
+    const n = tree.parent.length;
+    const y = (i) => positions[i * stride + 1];
+    const x = (i) => positions[i * stride];
+    const order = (a, b) => y(a) - y(b) || x(a) - x(b) || a - b;
+    const children = Array.from({ length: n }, () => []);
+    for (let i = 0; i < n; i++)
+        if (tree.parent[i] !== i)
+            children[tree.parent[i]].push(i);
+    for (const list of children)
+        list.sort(order);
+    const roots = [...tree.roots].sort(order);
+    const siblings = (i) => (tree.parent[i] === i ? roots : children[tree.parent[i]]);
+    return {
+        children,
+        step(from, key) {
+            if (from < 0 || from >= n)
+                return roots[0] ?? -1;
+            switch (key) {
+                case 'parent':
+                    return tree.parent[from];
+                case 'child': {
+                    // Straight ahead: the child drawn nearest this bus's row.
+                    const kids = children[from];
+                    if (!kids.length)
+                        return from;
+                    return kids.reduce((best, k) => Math.abs(y(k) - y(from)) < Math.abs(y(best) - y(from)) ? k : best);
+                }
+                case 'previous':
+                case 'next': {
+                    const list = siblings(from);
+                    const at = list.indexOf(from);
+                    const to = at + (key === 'next' ? 1 : -1);
+                    return to >= 0 && to < list.length ? list[to] : from;
+                }
+                case 'root': {
+                    let i = from;
+                    while (tree.parent[i] !== i)
+                        i = tree.parent[i];
+                    return i;
+                }
+            }
+        }
+    };
+}
+/** A spoken description of bus `i` for the keyboard cursor: where it sits in the tree, what hangs
+ * off it, and an optional result note (for example the worst voltage against its band). */
+export function describeBus(graph, tree, walk, i, note) {
+    const bus = graph.buses[i];
+    let root = i;
+    while (tree.parent[root] !== root)
+        root = tree.parent[root];
+    const depth = tree.depth[i];
+    const where = depth === 0
+        ? bus.has_source
+            ? 'source bus'
+            : 'not reached from a source'
+        : `${depth} step${depth === 1 ? '' : 's'} from ${graph.buses[root].id}`;
+    const via = tree.parentEdge[i] >= 0
+        ? `, fed by ${graph.edges[tree.parentEdge[i]].kind} ${graph.edges[tree.parentEdge[i]].id}`
+        : '';
+    const onward = walk.children[i].length;
+    const counts = new Map();
+    const earths = neutralEarths(bus);
+    for (const list of Object.values(bus.terminal_attachments ?? {}))
+        for (const a of list) {
+            const kind = a.kind === 'shunt' && earths.has(a.id) ? 'earth' : a.kind;
+            counts.set(kind, (counts.get(kind) ?? new Set()).add(a.id));
+        }
+    if (bus.grounded?.length)
+        counts.set('ground', new Set(bus.grounded));
+    const attached = ATTACHMENT_ORDER.filter((k) => counts.has(k)).map((k) => {
+        const c = counts.get(k).size;
+        return `${c} ${ATTACHMENT_NAMES[k]}${c === 1 ? '' : 's'}`;
+    });
+    return [
+        `${bus.id}: ${where}${via}`,
+        `${onward} branch${onward === 1 ? '' : 'es'} onward`,
+        ...(attached.length ? [attached.join(', ')] : []),
+        ...(note ? [note] : [])
+    ].join('. ');
+}

package/dist/diagram/value-labels.d.ts

@@ -0,0 +1,24 @@
+import type { ResultSnapshot } from './snapshot.js';
+export declare const VALUE_LABEL_BUDGET = 60;
+export declare const MIN_LABEL_ZOOM = -0.2;
+export type LabelState = 'violation' | 'warning' | 'normal';
+export interface LabelCandidate {
+    text: string;
+    state: LabelState;
+    priority: number;
+    /** Screen position in CSS pixels. */
+    screen: [number, number];
+    selected?: boolean;
+}
+/** Greedy placement by (selected, severity, priority) on a coarse collision grid. The selection is
+ * always placed; others must fit inside the canvas margins and the budget. */
+export declare function placeLabels<T extends LabelCandidate>(candidates: T[], { width, height, budget, box, margin }: {
+    width: number;
+    height: number;
+    budget?: number;
+    box?: [number, number];
+    margin?: [number, number, number, number];
+}): T[];
+/** The pair nearest a limit, shown in volts. Buses without declared limits rank last. */
+export declare function busLabel(result: ResultSnapshot, bus: number): Omit<LabelCandidate, 'screen'> | null;
+export declare function branchLabel(result: ResultSnapshot, branch: number, family: 'loading' | 'power'): Omit<LabelCandidate, 'screen'> | null;

package/dist/diagram/value-labels.js

@@ -0,0 +1,69 @@
+import { bandPosition } from './colour-modes.js';
+import { loadingState } from './summary.js';
+export const VALUE_LABEL_BUDGET = 60;
+export const MIN_LABEL_ZOOM = -0.2;
+const SEVERITY = { violation: 2, warning: 1, normal: 0 };
+/** Greedy placement by (selected, severity, priority) on a coarse collision grid. The selection is
+ * always placed; others must fit inside the canvas margins and the budget. */
+export function placeLabels(candidates, { width, height, budget = VALUE_LABEL_BUDGET, box = [64, 16], margin = [0, 40, 0, 24] }) {
+    const sorted = [...candidates].sort((a, b) => Number(!!b.selected) - Number(!!a.selected) ||
+        SEVERITY[b.state] - SEVERITY[a.state] ||
+        b.priority - a.priority);
+    const [cw, ch] = box;
+    const occupied = new Set();
+    const placed = [];
+    for (const c of sorted) {
+        if (placed.length >= budget)
+            break;
+        const [sx, sy] = c.screen;
+        const outside = sx < margin[3] ||
+            sx + cw > width - margin[1] ||
+            sy - ch < margin[0] ||
+            sy > height - margin[2];
+        if (!c.selected && outside)
+            continue;
+        const keys = [];
+        for (let gy = Math.floor((sy - ch) / ch); gy <= Math.floor(sy / ch); gy++)
+            for (let gx = Math.floor(sx / cw); gx <= Math.floor((sx + cw) / cw); gx++)
+                keys.push(`${gx},${gy}`);
+        if (!c.selected && keys.some((k) => occupied.has(k)))
+            continue;
+        for (const k of keys)
+            occupied.add(k);
+        placed.push(c);
+    }
+    return placed;
+}
+const short = (x) => Number(x.toPrecision(Math.abs(x) >= 1000 ? 5 : 4)).toLocaleString();
+/** The pair nearest a limit, shown in volts. Buses without declared limits rank last. */
+export function busLabel(result, bus) {
+    const pairs = result.buses[bus].pairs;
+    if (!pairs.length)
+        return null;
+    // Distance from mid-band; −1 without declared limits, so those pairs and buses rank last.
+    const rank = (p) => {
+        const band = bandPosition(p);
+        return band === null ? -1 : Math.abs(band);
+    };
+    let pick = pairs[0];
+    let t = rank(pick);
+    for (const p of pairs) {
+        const pt = rank(p);
+        if (pt > t)
+            [pick, t] = [p, pt];
+    }
+    return { text: `${short(pick.volts)} V`, state: t > 1 ? 'violation' : 'normal', priority: t };
+}
+export function branchLabel(result, branch, family) {
+    const row = result.branches[branch];
+    if (family === 'loading') {
+        const state = loadingState(row.loading);
+        return state === 'missing'
+            ? null
+            : { text: `${row.loading.toFixed(1)} %`, state, priority: row.loading };
+    }
+    const end = row.ends[0] ?? row.ends[1];
+    return end
+        ? { text: `${short(Math.abs(end.p))} kW`, state: 'normal', priority: Math.abs(end.p) }
+        : null;
+}

package/dist/diagram/view-state.d.ts

@@ -0,0 +1,12 @@
+/** Shareable view state. Selections travel as entity keys (source identities), never array offsets. */
+export interface CameraState {
+    target: [number, number, number];
+    zoom: number;
+}
+export declare function encodeCamera(c: {
+    target: ArrayLike<number>;
+    zoom: number;
+}): string;
+export declare function decodeCamera(text: string | null | undefined): CameraState | null;
+/** Merge state into a URL without dropping unrelated parameters; `null` or `''` removes a key. */
+export declare function withView(href: string | URL, state: Record<string, string | number | null | undefined>): URL;

package/dist/diagram/view-state.js

@@ -0,0 +1,22 @@
+export function encodeCamera(c) {
+    return [c.target[0].toFixed(1), c.target[1].toFixed(1), c.zoom.toFixed(2)].join(',');
+}
+export function decodeCamera(text) {
+    const parts = String(text ?? '')
+        .split(',')
+        .map(Number);
+    return parts.length === 3 && parts.every(Number.isFinite) && parts[2] >= -24 && parts[2] <= 5
+        ? { target: [parts[0], parts[1], 0], zoom: parts[2] }
+        : null;
+}
+/** Merge state into a URL without dropping unrelated parameters; `null` or `''` removes a key. */
+export function withView(href, state) {
+    const url = new URL(href);
+    for (const [k, v] of Object.entries(state)) {
+        if (v === null || v === undefined || v === '')
+            url.searchParams.delete(k);
+        else
+            url.searchParams.set(k, String(v));
+    }
+    return url;
+}

package/dist/diagram/voltage-levels.d.ts

@@ -0,0 +1,14 @@
+import type { GalvanicZone } from './galvanic-zones.js';
+/** Voltage classes for drawing, by a zone's level in volts. Wide bands, so a single-phase winding's
+ * own rating (7.2 kV of a 12.47 kV system, 19.1 kV SWER) lands where its system does. */
+export type VoltageClass = 'hv' | 'sub' | 'mv' | 'lv';
+export declare const VOLTAGE_CLASSES: {
+    cls: VoltageClass;
+    name: string;
+    from: number;
+}[];
+/** The class of a zone: by its level when known; otherwise the zone holding a source counts as MV
+ * and the others as LV, as for line weights. */
+export declare function voltageClass(zone: GalvanicZone, volts: number | null): VoltageClass;
+/** A level as engineers name it: "11 kV", "400 V", "19.1 kV". */
+export declare function levelLabel(volts: number): string;

package/dist/diagram/voltage-levels.js

@@ -0,0 +1,20 @@
+export const VOLTAGE_CLASSES = [
+    { cls: 'hv', name: 'transmission', from: 100_000 },
+    { cls: 'sub', name: 'subtransmission', from: 25_000 },
+    { cls: 'mv', name: 'MV', from: 1_000 },
+    { cls: 'lv', name: 'LV', from: 0 }
+];
+/** The class of a zone: by its level when known; otherwise the zone holding a source counts as MV
+ * and the others as LV, as for line weights. */
+export function voltageClass(zone, volts) {
+    if (volts === null)
+        return zone.hasSource ? 'mv' : 'lv';
+    return VOLTAGE_CLASSES.find((c) => volts >= c.from).cls;
+}
+/** A level as engineers name it: "11 kV", "400 V", "19.1 kV". */
+export function levelLabel(volts) {
+    const kv = volts / 1000;
+    if (kv < 1)
+        return `${Math.round(volts)} V`;
+    return `${Number(kv.toPrecision(4))} kV`;
+}

package/dist/index.d.ts

@@ -27,3 +27,4 @@ export type { BusSizing, CameraSnapshot, DiagramCameraSnapshot, DemandRangeMode,
 export type { MultiView, PlacedMultiBus, PlacedMultiEdge } from './multiconductor.js';
 export type { CaseFileSummary, DistAttachmentKind, DistEdgeKind, DistGraph, DistGraphAttachment, DistGraphBus, DistGraphEdge, DisplayPreview, Formulation, IngestedCase, IngestedDistCase, IngestedJsonDrop, JsonDropClassification, JsonDropKind, CapacityPlanBusWeightJson, CapacityPlanIterationJson, CapacityPlanOutcomeJson, CapacityPlanRatingChangeJson, CapacityPlanResultSummaryJson, CapacityPlanSpecJson, ImplicitObjectiveJson, SensTarget, Topology, TopologyBranch, TopologyBus } from '@tellegen/engine';
 export { default as McResults } from './components/McResults.svelte';
+export { default as McWorkbench } from './components/McWorkbench.svelte';

package/dist/index.js

@@ -17,3 +17,4 @@ 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, solveModule } from '@tellegen/engine';
 export { default as McResults } from './components/McResults.svelte';
+export { default as McWorkbench } from './components/McWorkbench.svelte';

package/dist/state.svelte.d.ts

@@ -1,7 +1,10 @@
 import type { CaseSummary, DemandDeltas, Network, NetworkBranch, NetworkBus, SensitivityColumn, Solution, SolveIteration } from './api.js';
 import { type StudyView, type BranchRatingDeltas, type BrowserMcPfSession, type CaseFileSummary, type DistGraph, type Formulation, type IngestedDistCase, type McPfCallTiming, type McPfResult, type McPfSummary, type McLoadBranchState, type McLoadPowerEdit, type McStudySnapshot, type SensTarget, type Topology } from '@tellegen/engine';
 import type { MultiView } from './multiconductor.js';
-export type SolveBackend = 'clarabel-wasm' | 'clarabel-wasm-server-sensitivity' | 'rust-server';
+import { type GraphInputs } from './diagram/graph-inputs.js';
+import { type SearchIndex } from './diagram/search.js';
+import { type ResultSnapshot } from './diagram/snapshot.js';
+export type SolveBackend = 'clarabel-wasm' | 'clarabel-wasm-server-sensitivity' | 'pounce-wasi' | 'rust-server';
 /** A map framing request: a case id, 'all', or one branch to center. */
 export type FrameTarget = string | 'all' | {
     caseId: string;
@@ -117,6 +120,8 @@ export declare class LocalCase {
     solving: boolean;
     solveMs: number | null;
     solveBackend: SolveBackend | null;
+    /** Short solver-specific diagnostic shown beside the elapsed time. */
+    solveDetail: string | null;
     solveFallbackReason: string | null;
     /** Monotone token: only the latest solve may write this case. */
     solveSeq: number;
@@ -155,6 +160,8 @@ export declare class CaseState {
     solving: boolean;
     solveMs: number | null;
     solveBackend: SolveBackend | null;
+    /** Short solver-specific diagnostic shown beside the elapsed time. */
+    solveDetail: string | null;
     solveFallbackReason: string | null;
     /** Monotone token: only the latest solve may write this case. */
     solveSeq: number;
@@ -231,6 +238,32 @@ export declare class MulticonductorCase {
     /** The selected edge id, whose conductor pairing expands in the panel;
      * mutually exclusive with selectedBusId. */
     selectedEdgeId: string | null;
+    /** What the pointer is over in any linked view (schematic, profile, tables); highlighted in
+     * the others. Transient: never saved or put in links. */
+    hovered: {
+        kind: "bus" | "branch";
+        id: string;
+    } | null;
+    /** Bumped to ask the views to bring the current selection into view again (an issue clicked
+     * that is already selected). */
+    revealSeq: number;
+    /** The full operating point read for whole-network views (overview, schematic); null until read,
+     * and cleared when a large case's operating point changes. */
+    overviewResult: McPfResult | null;
+    overviewLoading: boolean;
+    /** The graph's buses and branches as the overview and the diagram read them: rebuilt when the
+     * graph is replaced, never after a solve. Both views read this one copy. */
+    overviewInputs: GraphInputs | null;
+    /** Search over the graph's buses and branches, rebuilt with `overviewInputs`. */
+    overviewSearch: SearchIndex | null;
+    /** `overviewResult` projected onto the graph, built once per operating point and shared by the
+     * overview and the diagram; null while there is none. */
+    overviewSnapshot: ResultSnapshot | null;
+    /** Show this case as a schematic instead of the map. */
+    schematic: boolean;
+    /** The diagram's last geographic view as a map camera, for the map to continue from when the
+     * diagram closes. Plain, not reactive: it is read once, on close. */
+    lastGeoView: CameraSnapshot | null;
     constructor(init: {
         id: string;
         label: string;
@@ -264,6 +297,9 @@ export interface StudyDisplaySnapshot {
 export declare class AppState {
     #private;
     camera: CameraSnapshot | null;
+    /** Set when a view hands its camera to the map it returns to (the diagram closing from
+     * geographic positions): the re-created map starts at `camera` instead of framing the case. */
+    cameraHandoff: boolean;
     cameraRequest: CameraSnapshot | null;
     cameraSeq: number;
     diagramCamera: DiagramCameraSnapshot | null;

package/dist/state.svelte.js

@@ -1,4 +1,7 @@
 import { DEFAULT_FORMULATION } from '@tellegen/engine';
+import { graphInputs } from './diagram/graph-inputs.js';
+import { buildSearchIndex } from './diagram/search.js';
+import { snapshotFromMcPf } from './diagram/snapshot.js';
 /** A case is perturbed when any committed demand or rating delta is nonzero. Shared
  * by both solvable case classes so the "perturbed" rule stays single-sourced. */
 const hasPerturbation = (edits) => Object.values(edits).some((mw) => mw !== 0);
@@ -40,6 +43,8 @@ export class LocalCase {
     solving = $state(false);
     solveMs = $state(null);
     solveBackend = $state(null);
+    /** Short solver-specific diagnostic shown beside the elapsed time. */
+    solveDetail = $state(null);
     solveFallbackReason = $state(null);
     /** Monotone token: only the latest solve may write this case. */
     solveSeq = 0;
@@ -92,6 +97,8 @@ export class CaseState {
     solving = $state(false);
     solveMs = $state(null);
     solveBackend = $state(null);
+    /** Short solver-specific diagnostic shown beside the elapsed time. */
+    solveDetail = $state(null);
     solveFallbackReason = $state(null);
     /** Monotone token: only the latest solve may write this case. */
     solveSeq = 0;
@@ -158,6 +165,31 @@ export class MulticonductorCase {
     /** The selected edge id, whose conductor pairing expands in the panel;
      * mutually exclusive with selectedBusId. */
     selectedEdgeId = $state(null);
+    /** What the pointer is over in any linked view (schematic, profile, tables); highlighted in
+     * the others. Transient: never saved or put in links. */
+    hovered = $state(null);
+    /** Bumped to ask the views to bring the current selection into view again (an issue clicked
+     * that is already selected). */
+    revealSeq = $state(0);
+    /** The full operating point read for whole-network views (overview, schematic); null until read,
+     * and cleared when a large case's operating point changes. */
+    overviewResult = $state.raw(null);
+    overviewLoading = $state(false);
+    /** The graph's buses and branches as the overview and the diagram read them: rebuilt when the
+     * graph is replaced, never after a solve. Both views read this one copy. */
+    overviewInputs = $derived(this.graph ? graphInputs(this.graph) : null);
+    /** Search over the graph's buses and branches, rebuilt with `overviewInputs`. */
+    overviewSearch = $derived(this.overviewInputs ? buildSearchIndex(this.overviewInputs.entities) : null);
+    /** `overviewResult` projected onto the graph, built once per operating point and shared by the
+     * overview and the diagram; null while there is none. */
+    overviewSnapshot = $derived(this.overviewResult && this.overviewInputs
+        ? snapshotFromMcPf(this.overviewResult, this.overviewInputs.buses, this.overviewInputs.branches)
+        : null);
+    /** Show this case as a schematic instead of the map. */
+    schematic = $state(false);
+    /** The diagram's last geographic view as a map camera, for the map to continue from when the
+     * diagram closes. Plain, not reactive: it is read once, on close. */
+    lastGeoView = null;
     constructor(init) {
         this.id = init.id;
         this.label = init.label;
@@ -200,6 +232,9 @@ export class MulticonductorCase {
 }
 export class AppState {
     camera = $state.raw(null);
+    /** Set when a view hands its camera to the map it returns to (the diagram closing from
+     * geographic positions): the re-created map starts at `camera` instead of framing the case. */
+    cameraHandoff = false;
     cameraRequest = $state.raw(null);
     cameraSeq = $state(0);
     diagramCamera = $state.raw(null);

package/dist/transformer-icon.d.ts

@@ -1,15 +1,24 @@
-/** The IEC two-winding transformer symbol as a deck.gl icon: two overlapping
- * circles, rasterized once to a data URL. Drawn white on transparent with
- * `mask: true`, so the layer's getColor tints it. */
-export interface TransformerIcon {
-    url: string;
-    width: number;
-    height: number;
-    anchorX: number;
-    anchorY: number;
-    mask: true;
-}
+/** The IEC two-winding transformer symbol as a prepacked deck.gl icon atlas:
+ * two overlapping circles on a canvas that deck.gl uploads as a texture.
+ * Nothing is fetched, so the symbol needs no `data:` in a CSP's connect-src.
+ * Drawn white on transparent with `mask: true`, so the layer's getColor tints
+ * it. */
+/** The icon name for the layer's getIcon. */
+export declare const TRANSFORMER_ICON = "transformer";
+/** The atlas holds the one symbol, anchored at its center. */
+export declare const transformerIconMapping: {
+    transformer: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchorX: number;
+        anchorY: number;
+        mask: boolean;
+    };
+};
 /** Rasterize the glyph lazily; layers only build client-side, after the map
  * modules load, so document is always available here. The 128 px backing keeps
- * a ~16 px on-screen symbol crisp on 2x/3x displays. */
-export declare function transformerIcon(): TransformerIcon;
+ * a ~16 px on-screen symbol crisp on 2x/3x displays. Every call returns the
+ * same canvas, so deck.gl's prop diff keeps the texture it made from it. */
+export declare function transformerIconAtlas(): HTMLCanvasElement;

package/dist/transformer-icon.js

@@ -1,15 +1,32 @@
-/** The IEC two-winding transformer symbol as a deck.gl icon: two overlapping
- * circles, rasterized once to a data URL. Drawn white on transparent with
- * `mask: true`, so the layer's getColor tints it. */
+/** The IEC two-winding transformer symbol as a prepacked deck.gl icon atlas:
+ * two overlapping circles on a canvas that deck.gl uploads as a texture.
+ * Nothing is fetched, so the symbol needs no `data:` in a CSP's connect-src.
+ * Drawn white on transparent with `mask: true`, so the layer's getColor tints
+ * it. */
 const SIZE = 128;
 const RADIUS = 34;
 const OFFSET = 17;
 const STROKE = 9;
+/** The icon name for the layer's getIcon. */
+export const TRANSFORMER_ICON = 'transformer';
+/** The atlas holds the one symbol, anchored at its center. */
+export const transformerIconMapping = {
+    [TRANSFORMER_ICON]: {
+        x: 0,
+        y: 0,
+        width: SIZE,
+        height: SIZE,
+        anchorX: SIZE / 2,
+        anchorY: SIZE / 2,
+        mask: true
+    }
+};
 let cached = null;
 /** Rasterize the glyph lazily; layers only build client-side, after the map
  * modules load, so document is always available here. The 128 px backing keeps
- * a ~16 px on-screen symbol crisp on 2x/3x displays. */
-export function transformerIcon() {
+ * a ~16 px on-screen symbol crisp on 2x/3x displays. Every call returns the
+ * same canvas, so deck.gl's prop diff keeps the texture it made from it. */
+export function transformerIconAtlas() {
     if (cached)
         return cached;
     const canvas = document.createElement('canvas');
@@ -23,13 +40,6 @@ export function transformerIcon() {
         ctx.arc(SIZE / 2 + dx, SIZE / 2, RADIUS, 0, 2 * Math.PI);
         ctx.stroke();
     }
-    cached = {
-        url: canvas.toDataURL(),
-        width: SIZE,
-        height: SIZE,
-        anchorX: SIZE / 2,
-        anchorY: SIZE / 2,
-        mask: true
-    };
+    cached = canvas;
     return cached;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tellegen/svelte",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "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.4.1"
+    "@tellegen/engine": "^0.4.3"
   },
   "peerDependencies": {
     "@deck.gl/core": "^9.4.0",