@tellegen/svelte 0.4.3 → 0.4.4

package/dist/components/schematic/paint.d.ts

@@ -0,0 +1,28 @@
+import type { RGBA } from '../../colors.js';
+import type { Landmark, SchematicGeometry } from '../../diagram/index.js';
+/** Per-segment widths: MV heavier than LV. */
+export declare function segmentWidths(g: SchematicGeometry, edgeMv: Uint8Array, resultColours: boolean): Float32Array;
+/** Drawn segments replaced by their fanned path right now. */
+export interface FanState {
+    edges: Set<number>;
+    host: Int32Array | null;
+    geometry: SchematicGeometry;
+}
+export declare function hiddenUnderFan(d: SchematicGeometry, s: number, fan: FanState): boolean;
+/** Per-segment colours: the edge's colour, quieter for open or unreachable branches, hidden under
+ * a fanned route, and faded for LV when zoomed out. */
+export declare function segmentColours(g: SchematicGeometry, edgeColours: RGBA[], edgeMv: Uint8Array, zoomedOut: boolean, fan: FanState): Uint8Array;
+/** Per symbol stroke: ink, or faint when its bus or branch is not energised; hidden for a branch
+ * whose route is fanned (its marks are redrawn on the fanned path). An owner is an edge index, or
+ * `-bus - 1` for a bus. */
+export declare function strokeColours(owner: Int32Array, fannedEdges: Set<number>, live: {
+    edges: ArrayLike<boolean | number>;
+    buses: ArrayLike<boolean | number>;
+}): Uint8Array;
+/** Landmark strokes in ink; a transformer whose network has a problem takes that state's colour. */
+export declare function landmarkColours(m: {
+    placed: Landmark[];
+    strokes: {
+        owner: Int32Array;
+    };
+}): Uint8Array;

package/dist/components/schematic/paint.js

@@ -0,0 +1,69 @@
+import { DANGER, DEAD, HIDDEN, INK, SYMBOL_INK, WARNING, lineWidths } from './palette.js';
+/** Per-segment widths: MV heavier than LV. */
+export function segmentWidths(g, edgeMv, resultColours) {
+    const [mv, lv] = lineWidths(resultColours);
+    return Float32Array.from(g.segmentEdge, (k) => (edgeMv[k] ? mv : lv));
+}
+/** Whether drawn segment `s` of edge `k` lies on the edge's shared (host) segment of `geometry`,
+ * so it is replaced by the fanned path while its route is fanned. */
+function onHost(d, s, k, host, geometry) {
+    const h = host[k] ?? -1;
+    if (h < 0)
+        return false;
+    const [ax, ay, bx, by] = [
+        geometry.sources[h * 3],
+        geometry.sources[h * 3 + 1],
+        geometry.targets[h * 3],
+        geometry.targets[h * 3 + 1]
+    ];
+    const len = Math.hypot(bx - ax, by - ay) || 1;
+    const off = (x, y) => Math.abs((bx - ax) * (ay - y) - (ax - x) * (by - ay)) / len;
+    const tol = len * 1e-6 + 1e-9;
+    return (off(d.sources[s * 3], d.sources[s * 3 + 1]) <= tol &&
+        off(d.targets[s * 3], d.targets[s * 3 + 1]) <= tol);
+}
+export function hiddenUnderFan(d, s, fan) {
+    const k = d.segmentEdge[s];
+    return !!fan.host && fan.edges.has(k) && onHost(d, s, k, fan.host, fan.geometry);
+}
+/** Per-segment colours: the edge's colour, quieter for open or unreachable branches, hidden under
+ * a fanned route, and faded for LV when zoomed out. */
+export function segmentColours(g, edgeColours, edgeMv, zoomedOut, fan) {
+    const out = new Uint8Array(g.segmentEdge.length * 4);
+    for (let s = 0; s < g.segmentEdge.length; s++) {
+        const k = g.segmentEdge[s];
+        const c = edgeColours[k];
+        let a = g.role[k] === 2 ? Math.min(110, c[3]) : c[3];
+        if (hiddenUnderFan(g, s, fan))
+            a = 0;
+        if (zoomedOut && !edgeMv[k])
+            a *= 0.45;
+        out.set([c[0], c[1], c[2], a], s * 4);
+    }
+    return out;
+}
+/** Per symbol stroke: ink, or faint when its bus or branch is not energised; hidden for a branch
+ * whose route is fanned (its marks are redrawn on the fanned path). An owner is an edge index, or
+ * `-bus - 1` for a bus. */
+export function strokeColours(owner, fannedEdges, live) {
+    const out = new Uint8Array(owner.length * 4);
+    for (let s = 0; s < owner.length; s++) {
+        const o = owner[s];
+        if (o >= 0 && fannedEdges.has(o)) {
+            out.set(HIDDEN, s * 4);
+            continue;
+        }
+        const on = o >= 0 ? live.edges[o] : live.buses[-o - 1];
+        out.set(on ? SYMBOL_INK : DEAD, s * 4);
+    }
+    return out;
+}
+/** Landmark strokes in ink; a transformer whose network has a problem takes that state's colour. */
+export function landmarkColours(m) {
+    const out = new Uint8Array(m.strokes.owner.length * 4);
+    for (let s = 0; s < m.strokes.owner.length; s++) {
+        const l = m.placed[m.strokes.owner[s]];
+        out.set(l.state === 'violation' ? DANGER : l.state === 'warning' ? WARNING : INK, s * 4);
+    }
+    return out;
+}

package/dist/components/schematic/palette.d.ts

@@ -0,0 +1,34 @@
+import type { RGBA } from '../../colors.js';
+import type { VoltageClass, ZoneState } from '../../diagram/index.js';
+export declare const INK: RGBA;
+export declare const ACCENT: RGBA;
+export declare const PAPER: RGBA;
+export declare const DANGER: RGBA;
+export declare const WARNING: RGBA;
+export declare const SYMBOL_INK: RGBA;
+/** Not connected to any source through closed branches: drawn faint in every colour mode. */
+export declare const DEAD: RGBA;
+export declare const HIDDEN: RGBA;
+/** LV networks within limits: corridors, outlines and tags in the warm grey of LV lines, so blue
+ * stays the colour of MV and above. */
+export declare const ZONE_INK: RGBA;
+export declare const MONO = "IBM Plex Mono, ui-monospace, monospace";
+/** A colour at another opacity. */
+export declare const alpha: (c: RGBA, a: number) => RGBA;
+/** Ink for a label or mark by severity. */
+export declare const stateInk: (state: string | undefined) => RGBA;
+/** Screen width of a zone's corridor on geographic positions. */
+export declare const CORRIDOR_PX = 9;
+/** Line colour per voltage class in the topology view: shades of one blue, darker for higher
+ * levels, and LV in the quiet grey that carries most of a distribution drawing. Clear of the
+ * warning and violation colours and of the accent used for selection and flow. */
+export declare const LEVEL_COLOURS: Record<VoltageClass, RGBA>;
+/** Hover emphasis for a network and its feeder, beneath the lines, whatever the network's state. */
+export declare const HALO: RGBA;
+/** The hovered element's path back to the source: green, the one family no level, state or
+ * selection uses, so it reads over the halos. */
+export declare const PATH: RGBA;
+/** Fill and outline per zone state. */
+export declare const ZONE_COLOURS: Record<ZoneState, [RGBA, RGBA]>;
+/** MV and LV line widths in pixels: heavier when results colour the lines. */
+export declare const lineWidths: (resultColours: boolean) => [number, number];

package/dist/components/schematic/palette.js

@@ -0,0 +1,54 @@
+export const INK = [32, 36, 43, 255];
+export const ACCENT = [178, 94, 0, 255];
+export const PAPER = [252, 251, 247, 255];
+export const DANGER = [184, 50, 42, 255];
+export const WARNING = [178, 94, 0, 255];
+export const SYMBOL_INK = [52, 56, 62, 255];
+/** Not connected to any source through closed branches: drawn faint in every colour mode. */
+export const DEAD = [196, 191, 182, 110];
+export const HIDDEN = [0, 0, 0, 0];
+/** LV networks within limits: corridors, outlines and tags in the warm grey of LV lines, so blue
+ * stays the colour of MV and above. */
+export const ZONE_INK = [112, 104, 90, 255];
+export const MONO = 'IBM Plex Mono, ui-monospace, monospace';
+/** A colour at another opacity. */
+export const alpha = (c, a) => [c[0], c[1], c[2], a];
+/** Ink for a label or mark by severity. */
+export const stateInk = (state) => state === 'violation' ? DANGER : state === 'warning' ? WARNING : INK;
+/** Screen width of a zone's corridor on geographic positions. */
+export const CORRIDOR_PX = 9;
+/** Line colour per voltage class in the topology view: shades of one blue, darker for higher
+ * levels, and LV in the quiet grey that carries most of a distribution drawing. Clear of the
+ * warning and violation colours and of the accent used for selection and flow. */
+export const LEVEL_COLOURS = {
+    hv: [38, 44, 112, 240],
+    sub: [30, 76, 140, 240],
+    mv: [58, 118, 178, 235],
+    lv: [138, 131, 117, 210]
+};
+/** Hover emphasis for a network and its feeder, beneath the lines, whatever the network's state. */
+export const HALO = [64, 72, 92, 255];
+/** The hovered element's path back to the source: green, the one family no level, state or
+ * selection uses, so it reads over the halos. */
+export const PATH = [16, 138, 96, 245];
+/** Fill and outline per zone state. */
+export const ZONE_COLOURS = {
+    missing: [
+        [112, 104, 90, 16],
+        [112, 104, 90, 90]
+    ],
+    normal: [
+        [112, 104, 90, 16],
+        [112, 104, 90, 90]
+    ],
+    warning: [
+        [178, 94, 0, 30],
+        [178, 94, 0, 170]
+    ],
+    violation: [
+        [184, 50, 42, 34],
+        [184, 50, 42, 190]
+    ]
+};
+/** MV and LV line widths in pixels: heavier when results colour the lines. */
+export const lineWidths = (resultColours) => resultColours ? [3, 1.8] : [2.4, 1.1];

package/dist/components/schematic/text.d.ts

@@ -0,0 +1,83 @@
+import type { PickingInfo } from '@deck.gl/core';
+import type { DistGraph } from '@tellegen/engine';
+import { type DisplayTree, type EquipmentItem, type Feeders, type EquipmentSymbols, type GalvanicZone, type GalvanicZones, type Landmark, type ResultSnapshot, type ZoneState } from '../../diagram/index.js';
+/** What the diagram's words are made from: tooltips, announcements and the cards' rows. */
+export interface TextContext {
+    graph: DistGraph;
+    zones: GalvanicZones;
+    zoneStates: ZoneState[];
+    /** Whether a zone is drawn as a network of its own (an LV network). */
+    outlined: (zone: GalvanicZone) => boolean;
+    transformerNames: Map<number, string>;
+    live: {
+        edges: ArrayLike<number>;
+    };
+    equipment: EquipmentSymbols | null;
+    snapshot: ResultSnapshot | null;
+    powers: Map<string, {
+        p: number;
+        q: number;
+    }> | null;
+    valuesOn: boolean;
+    edgeMv: Uint8Array;
+    zoneMv: boolean[];
+    /** Per bus, for source positions: 1 drawn next to a connected bus, 2 left at the origin. */
+    inferred: Uint8Array | null;
+    feeders: Feeders;
+    tree: DisplayTree;
+    /** Short bus names, as drawn. */
+    busNames: string[];
+    /** Close enough for terminal and transformer labels beside the symbols. */
+    labelsOn: boolean;
+}
+export declare class SchematicText {
+    private readonly c;
+    constructor(c: TextContext);
+    /** What supplies a network at bus `s`: its feeding transformer, or the source bus itself. */
+    private supplyName;
+    /** "feeder 2 of TX 1234", "feeder 1 of SOURCEBUS": the same words on MV and LV. */
+    feederName(f: number): string;
+    /** Where a bus sits: on a feeder, or as the bus a network is supplied at. */
+    networkNote(i: number): string;
+    /** A bus's worst pair voltage against its band, for announcements and the stack card. */
+    voltageNote(i: number): string | null;
+    bus(i: number): string;
+    /** Whether a branch is drawn on a route shared with others. */
+    isShared(k: number): boolean;
+    branch(k: number): string;
+    item(d: EquipmentItem): string;
+    /** An attachment's text beside its symbol: its count when several, and its solved P and Q when
+     * values show. Generators, IBRs and sources read as output; loads and shunts as consumption. */
+    itemValue(d: EquipmentItem): string;
+    landmark(l: Landmark): string;
+    zone(z: number): string;
+    /** Rows of a shared route's card. */
+    routeRows(members: number[]): {
+        k: number;
+        id: string;
+        kind: import("@tellegen/engine").DistEdgeKind;
+        level: string;
+        wires: string;
+        loading: string | null;
+        state: "normal" | "warning" | "violation";
+    }[];
+    /** Rows of a bus stack's card. */
+    stackRows(members: number[]): {
+        i: number;
+        id: string;
+        level: string;
+        attached: string;
+        voltage: string;
+    }[];
+}
+/** Picks and how the canvas reads them, for the tooltip. */
+export interface TooltipPicks {
+    /** Whether this pick belongs to the stack whose card is open (the card names its buses). */
+    inOpenStack: (info: PickingInfo) => boolean;
+    /** Edge of a drawn branch segment. */
+    segmentEdge: (index: number) => number;
+    /** Whether symbols show, so shared routes are named by their card. */
+    symbolsOn: boolean;
+}
+/** The tooltip for a pick, or null where a card or nothing says it better. */
+export declare function tooltip(info: PickingInfo, text: SchematicText, picks: TooltipPicks): string | null;

package/dist/components/schematic/text.js

@@ -0,0 +1,190 @@
+import { ATTACHMENT_NAMES, bandPosition, conductorSet, formatPower, loadingState, terminalLabel } from '../../diagram/index.js';
+const list = (ids) => ids.slice(0, 4).join(', ') + (ids.length > 4 ? ` +${ids.length - 4}` : '');
+const counted = (n, name) => (n > 1 ? `${n} ${name}s` : name);
+const volts = (x, digits) => x >= 1000 ? `${(x / 1000).toFixed(digits)} kV` : `${x.toFixed(1)} V`;
+const attachmentKinds = (graph, i) => new Set(Object.values(graph.buses[i].terminal_attachments ?? {}).flatMap((l) => l.map((a) => a.kind)));
+export class SchematicText {
+    c;
+    constructor(c) {
+        this.c = c;
+    }
+    /** What supplies a network at bus `s`: its feeding transformer, or the source bus itself. */
+    supplyName(s) {
+        const { tree, graph, transformerNames, busNames } = this.c;
+        const k = tree.parentEdge[s];
+        return k >= 0 ? (transformerNames.get(k) ?? graph.edges[k].id) : busNames[s];
+    }
+    /** "feeder 2 of TX 1234", "feeder 1 of SOURCEBUS": the same words on MV and LV. */
+    feederName(f) {
+        const feeder = this.c.feeders.feeders[f];
+        return `feeder ${feeder.number} of ${this.supplyName(feeder.supply)}`;
+    }
+    /** Where a bus sits: on a feeder, or as the bus a network is supplied at. */
+    networkNote(i) {
+        const f = this.c.feeders.busFeeder[i];
+        if (f >= 0)
+            return ` · ${this.feederName(f)}`;
+        return this.c.tree.parentEdge[i] >= 0
+            ? ` · supply bus of the network fed by ${this.supplyName(i)}`
+            : ' · source bus';
+    }
+    /** A bus's worst pair voltage against its band, for announcements and the stack card. */
+    voltageNote(i) {
+        const pairs = this.c.snapshot?.buses[i]?.pairs ?? [];
+        if (!pairs.length)
+            return null;
+        const worst = pairs.reduce((a, b) => Math.abs(bandPosition(b) ?? 0) > Math.abs(bandPosition(a) ?? 0) ? b : a);
+        const t = bandPosition(worst);
+        const band = worst.min !== null && worst.max !== null
+            ? `, ${t !== null && Math.abs(t) > 1 ? 'outside' : 'within'} ${volts(worst.min, 3)} to ${volts(worst.max, 3)}`
+            : '';
+        return `Worst voltage ${worst.pair.join('–')} ${volts(worst.volts, 3)}${band}`;
+    }
+    bus(i) {
+        const how = this.c.inferred?.[i] ?? 0;
+        const id = this.c.graph.buses[i].id + this.networkNote(i);
+        return how === 1
+            ? `${id} · no position in the case data; drawn next to a connected bus`
+            : how === 2
+                ? `${id} · no position in the case data`
+                : id;
+    }
+    /** Whether a branch is drawn on a route shared with others. */
+    isShared(k) {
+        return (this.c.equipment?.routeOf[k] ?? -1) >= 0;
+    }
+    branch(k) {
+        const { graph, live, equipment } = this.c;
+        const e = graph.edges[k];
+        const { phases, neutral } = conductorSet(graph, k);
+        const wires = `${phases} phase${phases === 1 ? '' : 's'}${neutral ? ' + neutral' : ''}`;
+        const shared = equipment?.sharedRoute[k] ?? 1;
+        const route = shared > 1
+            ? ` · drawn on a route shared with ${shared - 1} other branch${shared > 2 ? 'es' : ''}`
+            : '';
+        const f = this.c.feeders.edgeFeeder[k];
+        const feeder = f >= 0 ? ` · ${this.feederName(f)}` : '';
+        return `${e.kind} ${e.id} · ${wires}${e.closed ? '' : ' · open'}${live.edges[k] ? '' : ' · not energised'}${feeder}${route}`;
+    }
+    item(d) {
+        const { graph } = this.c;
+        const name = d.kind in ATTACHMENT_NAMES ? ATTACHMENT_NAMES[d.kind] : d.kind;
+        if (d.kind === 'ground')
+            return `solid earth: terminal${d.ids.length > 1 ? 's' : ''} ${d.ids.join(', ')} of ${graph.buses[d.bus].id} perfectly grounded`;
+        const terminals = d.terminals ? ` · terminals ${terminalLabel(d.terminals, d.connection)}` : '';
+        const label = d.label ? ` · ${d.label}` : '';
+        return d.bus >= 0
+            ? `${counted(d.ids.length, name)} ${list(d.ids)} at ${graph.buses[d.bus].id}${terminals}${this.networkNote(d.bus)}`
+            : `${name} ${list(d.ids)}${label}${graph.edges[d.edge].closed ? '' : ' (open)'}`;
+    }
+    /** An attachment's text beside its symbol: its count when several, and its solved P and Q when
+     * values show. Generators, IBRs and sources read as output; loads and shunts as consumption. */
+    itemValue(d) {
+        const { valuesOn, powers, labelsOn } = this.c;
+        const parts = [];
+        if (labelsOn && d.terminals)
+            parts.push(terminalLabel(d.terminals, d.connection));
+        if (d.ids.length > 1)
+            parts.push(`×${d.ids.length}`);
+        if (valuesOn && powers) {
+            let p = 0;
+            let q = 0;
+            let found = false;
+            for (const id of d.ids) {
+                const row = powers.get(id);
+                if (!row)
+                    continue;
+                p += row.p;
+                q += row.q;
+                found = true;
+            }
+            const output = d.kind === 'generator' || d.kind === 'ibr' || d.kind === 'source';
+            // Below 1 VA (an earthing shunt, say) the value is noise, not information.
+            if (found && Math.hypot(p, q) >= 1)
+                parts.push(output ? formatPower(-p, -q) : formatPower(p, q));
+        }
+        return parts.join(' ');
+    }
+    landmark(l) {
+        const name = {
+            source: 'source',
+            generator: 'generator',
+            ibr: 'inverter-based resource',
+            transformer: 'transformer'
+        }[l.kind];
+        const where = l.bus >= 0 ? ` at ${this.c.graph.buses[l.bus].id}` : '';
+        return `${counted(l.ids.length, name)} ${list(l.ids)}${where}`;
+    }
+    zone(z) {
+        const { zones, zoneStates, graph } = this.c;
+        const zone = zones.zones[z];
+        const t = zone.transformers[0];
+        const verdict = {
+            violation: 'a limit is violated',
+            warning: 'a branch is near its rating',
+            normal: 'within limits',
+            missing: 'no result'
+        }[zoneStates[z]];
+        const fed = t === undefined ? 'Network' : `Network fed by ${graph.edges[t].kind} ${graph.edges[t].id}`;
+        return `${fed}: ${zone.buses.length} buses, ${verdict}`;
+    }
+    /** Rows of a shared route's card. */
+    routeRows(members) {
+        const { graph, snapshot, edgeMv } = this.c;
+        return members.map((k) => {
+            const e = graph.edges[k];
+            const { phases, neutral } = conductorSet(graph, k);
+            const loading = snapshot?.branches[k]?.loading ?? null;
+            const state = loadingState(loading);
+            return {
+                k,
+                id: e.id,
+                kind: e.kind,
+                level: edgeMv[k] ? 'MV' : 'LV',
+                wires: `${phases}${neutral ? '+N' : ''}`,
+                loading: loading === null ? null : `${loading.toFixed(0)} %`,
+                state: state === 'missing' ? 'normal' : state
+            };
+        });
+    }
+    /** Rows of a bus stack's card. */
+    stackRows(members) {
+        const { graph, zones, zoneMv } = this.c;
+        return members.map((i) => {
+            const note = this.voltageNote(i);
+            return {
+                i,
+                id: graph.buses[i].id,
+                level: zoneMv[zones.busZone[i]] ? 'MV' : 'LV',
+                attached: [...attachmentKinds(graph, i)].join(', '),
+                voltage: note ? note.replace(/^Worst voltage /, '').replace(/, (within|outside).*/, '') : ''
+            };
+        });
+    }
+}
+/** The tooltip for a pick, or null where a card or nothing says it better. */
+export function tooltip(info, text, picks) {
+    const id = info.layer?.id;
+    if (info.index < 0 || !id)
+        return null;
+    // A stack's ring opens its card, which says the rest; inside an open stack the card names the
+    // buses, and a tooltip would cover them. A fanned route's card names its branches.
+    if (id === 'stack-rings' || picks.inOpenStack(info) || id === 'fan-branches')
+        return null;
+    if (id === 'route-badges')
+        return `${info.object.n} branches share this route. Hover to separate them; click to keep them open.`;
+    if (id === 'landmark-halos')
+        return text.landmark(info.object);
+    if (id.startsWith('zones'))
+        return `${text.zone(info.object.z)}. Click to fit.`;
+    if (id.startsWith('buses-'))
+        return text.bus(info.object);
+    if (id.startsWith('branches-')) {
+        const k = picks.segmentEdge(info.index);
+        // A shared route's card names its branches; its hidden true route stays silent.
+        return picks.symbolsOn && text.isShared(k) ? null : text.branch(k);
+    }
+    if (id === 'equipment-hits')
+        return text.item(info.object);
+    return null;
+}

package/dist/components/schematic/view-prefs.svelte.d.ts

@@ -0,0 +1,30 @@
+/** A viewer preference remembered in local storage. Storage can be unavailable (private windows,
+ * blocked site data); the preference then still works for this view. */
+export declare class StoredFlag {
+    private readonly key;
+    /** Stored values for on and off. */
+    private readonly words;
+    value: boolean;
+    constructor(key: string, 
+    /** Stored values for on and off. */
+    words: [string, string], fallback: boolean);
+    set(on: boolean): void;
+}
+/** One of several hover targets whose card opens on hover and can be pinned open by a click:
+ * shared routes and stacked buses. Leaving starts a short grace period so the pointer can reach
+ * the card; while the card itself is hovered it stays open. */
+export declare class HoverPin {
+    hovered: number | null;
+    pinned: number | null;
+    private cardHovered;
+    private timer;
+    /** The target whose card shows: pinned, else hovered. */
+    get active(): number | null;
+    open(g: number): void;
+    leave(): void;
+    enterCard(): void;
+    leaveCard(): void;
+    close(): void;
+    dispose(): void;
+    private cancelLeave;
+}

package/dist/components/schematic/view-prefs.svelte.js

@@ -0,0 +1,77 @@
+/** A viewer preference remembered in local storage. Storage can be unavailable (private windows,
+ * blocked site data); the preference then still works for this view. */
+export class StoredFlag {
+    key;
+    words;
+    value = $state(false);
+    constructor(key, 
+    /** Stored values for on and off. */
+    words, fallback) {
+        this.key = key;
+        this.words = words;
+        let stored = null;
+        try {
+            stored = localStorage.getItem(key);
+        }
+        catch {
+            // Unavailable storage leaves the default.
+        }
+        this.value = stored === words[0] ? true : stored === words[1] ? false : fallback;
+    }
+    set(on) {
+        this.value = on;
+        try {
+            localStorage.setItem(this.key, this.words[on ? 0 : 1]);
+        }
+        catch {
+            // The preference still applies to this view.
+        }
+    }
+}
+/** One of several hover targets whose card opens on hover and can be pinned open by a click:
+ * shared routes and stacked buses. Leaving starts a short grace period so the pointer can reach
+ * the card; while the card itself is hovered it stays open. */
+export class HoverPin {
+    hovered = $state(null);
+    pinned = $state(null);
+    cardHovered = false;
+    timer = null;
+    /** The target whose card shows: pinned, else hovered. */
+    get active() {
+        return this.pinned ?? this.hovered;
+    }
+    open(g) {
+        this.cancelLeave();
+        if (this.hovered !== g)
+            this.hovered = g;
+    }
+    leave() {
+        if (this.hovered === null || this.timer || this.cardHovered)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            if (!this.cardHovered)
+                this.hovered = null;
+        }, 350);
+    }
+    enterCard() {
+        this.cardHovered = true;
+        this.cancelLeave();
+    }
+    leaveCard() {
+        this.cardHovered = false;
+        this.leave();
+    }
+    close() {
+        this.pinned = null;
+        this.hovered = null;
+    }
+    dispose() {
+        this.cancelLeave();
+    }
+    cancelLeave() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+}

package/dist/components.d.ts

@@ -21,3 +21,4 @@ export { default as SolveCard } from './components/SolveCard.svelte';
 export { default as TopMovers } from './components/TopMovers.svelte';
 export { default as Sparkline } from './Sparkline.svelte';
 export { default as McResults } from './components/McResults.svelte';
+export { default as McWorkbench } from './components/McWorkbench.svelte';

package/dist/components.js

@@ -21,3 +21,4 @@ export { default as SolveCard } from './components/SolveCard.svelte';
 export { default as TopMovers } from './components/TopMovers.svelte';
 export { default as Sparkline } from './Sparkline.svelte';
 export { default as McResults } from './components/McResults.svelte';
+export { default as McWorkbench } from './components/McWorkbench.svelte';

package/dist/context.svelte.d.ts

@@ -3,6 +3,8 @@ import type { Controller } from './controller.svelte.js';
 export interface TellegenUiConfig {
     /** Backend base path; `null` for a host with no backend at all. */
     apiBase: string | null;
+    /** URL of the separately built, development-only AC OPF WASI asset. */
+    acOpfWasmUrl: string | null;
     loadDefaultCases: boolean;
     docsHref: string;
     orgHref: string;

package/dist/context.svelte.js

@@ -5,6 +5,7 @@ const CTRL = Symbol('tellegen.controller');
 const CONFIG = Symbol('tellegen.config');
 export const DEFAULT_TELLEGEN_UI_CONFIG = {
     apiBase: '/api',
+    acOpfWasmUrl: null,
     loadDefaultCases: true,
     docsHref: 'https://eigenergy.github.io/tellegen/',
     orgHref: 'https://github.com/eigenergy',
@@ -17,6 +18,7 @@ export function resolveTellegenUiConfig(options = {}) {
     return {
         apiBase: options.apiBase === undefined ? DEFAULT_TELLEGEN_UI_CONFIG.apiBase : options.apiBase,
         loadDefaultCases: options.loadDefaultCases ?? DEFAULT_TELLEGEN_UI_CONFIG.loadDefaultCases,
+        acOpfWasmUrl: options.acOpfWasmUrl ?? DEFAULT_TELLEGEN_UI_CONFIG.acOpfWasmUrl,
         docsHref: options.docsHref ?? DEFAULT_TELLEGEN_UI_CONFIG.docsHref,
         orgHref: options.orgHref ?? DEFAULT_TELLEGEN_UI_CONFIG.orgHref,
         orgLabel: options.orgLabel ?? DEFAULT_TELLEGEN_UI_CONFIG.orgLabel,