@tellegen/svelte 0.4.2 → 0.4.4

package/dist/diagram/schematic-layout.js

@@ -0,0 +1,240 @@
+function segments(graph, positions, index, route) {
+    const src = [];
+    const dst = [];
+    const owner = [];
+    graph.edges.forEach((e, k) => {
+        const a = index(e.from);
+        const b = index(e.to);
+        if (a < 0 || b < 0)
+            return;
+        const points = route(k, a, b) ?? [
+            [positions[a * 3], positions[a * 3 + 1]],
+            [positions[b * 3], positions[b * 3 + 1]]
+        ];
+        for (let i = 1; i < points.length; i++) {
+            src.push(points[i - 1][0], points[i - 1][1], 0);
+            dst.push(points[i][0], points[i][1], 0);
+            owner.push(k);
+        }
+    });
+    return {
+        sources: Float32Array.from(src),
+        targets: Float32Array.from(dst),
+        segmentEdge: Int32Array.from(owner)
+    };
+}
+function bounds(positions) {
+    let [x0, y0, x1, y1] = [Infinity, Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < positions.length; i += 3) {
+        x0 = Math.min(x0, positions[i]);
+        x1 = Math.max(x1, positions[i]);
+        y0 = Math.min(y0, positions[i + 1]);
+        y1 = Math.max(y1, positions[i + 1]);
+    }
+    return Number.isFinite(x0) ? [x0, y0, x1, y1] : [0, 0, 1, 1];
+}
+const indexer = (graph) => {
+    const map = new Map(graph.buses.map((b, i) => [b.id.toLowerCase(), i]));
+    return (id) => map.get(id.toLowerCase()) ?? -1;
+};
+/** Engine schematic layout (`mcSchematicLayout`, computed in Rust) as GPU-ready arrays. */
+export function fromEngineLayout(layout) {
+    const n = layout.positions.length / 2;
+    const positions = new Float32Array(n * 3);
+    for (let i = 0; i < n; i++) {
+        positions[i * 3] = layout.positions[i * 2];
+        positions[i * 3 + 1] = layout.positions[i * 2 + 1];
+    }
+    const m = layout.segment_edge.length;
+    const sources = new Float32Array(m * 3);
+    const targets = new Float32Array(m * 3);
+    for (let s = 0; s < m; s++) {
+        sources[s * 3] = layout.segments[s * 4];
+        sources[s * 3 + 1] = layout.segments[s * 4 + 1];
+        targets[s * 3] = layout.segments[s * 4 + 2];
+        targets[s * 3 + 1] = layout.segments[s * 4 + 3];
+    }
+    return {
+        positions,
+        sources,
+        targets,
+        segmentEdge: Int32Array.from(layout.segment_edge),
+        role: Uint8Array.from(layout.role),
+        bounds: layout.bounds,
+        version: layout.version,
+        attachmentGap: layout.attachment_gap
+    };
+}
+/** An empty drawing, before the first layout arrives. */
+export const EMPTY_GEOMETRY = {
+    positions: new Float32Array(),
+    sources: new Float32Array(),
+    targets: new Float32Array(),
+    segmentEdge: new Int32Array(),
+    role: new Uint8Array(),
+    bounds: [0, 0, 1, 1]
+};
+/** Positions as placed in the source data: geographic longitude/latitude projected to Web Mercator
+ * metres (y down), or drawing coordinates as given (already y down, as `DiagramCanvas` draws them),
+ * relative to their centroid. Branches are drawn straight. */
+export function sourceLayout(graph, placed, geographic, tree, 
+/** Routed paths from the case (`MultiView.edges`), drawn in place of straight segments. */
+routes = []) {
+    const R = 6_378_137;
+    const byId = new Map(placed.map((b) => [b.id.toLowerCase(), b]));
+    const project = (lon, lat) => {
+        if (!geographic)
+            return [lon, lat];
+        const clamped = Math.max(-85, Math.min(85, lat));
+        return [
+            (R * lon * Math.PI) / 180,
+            -R * Math.log(Math.tan(Math.PI / 4 + (clamped * Math.PI) / 360))
+        ];
+    };
+    // Project in float64 and store relative to the centroid: absolute Web Mercator metres reach 1e7,
+    // where float32 resolves only to about a metre and neighbouring LV buses would collapse.
+    const xy = graph.buses.map((b) => {
+        const p = byId.get(b.id.toLowerCase());
+        return p ? project(p.lon, p.lat) : null;
+    });
+    const known = xy.filter((p) => p !== null);
+    const cx = known.reduce((s, p) => s + p[0], 0) / Math.max(1, known.length);
+    const cy = known.reduce((s, p) => s + p[1], 0) / Math.max(1, known.length);
+    const positions = new Float32Array(graph.buses.length * 3);
+    xy.forEach((p, i) => {
+        if (!p)
+            return;
+        positions[i * 3] = p[0] - cx;
+        positions[i * 3 + 1] = p[1] - cy;
+    });
+    const index = indexer(graph);
+    // A bus without a position (an LV stub behind a pole transformer, say) is drawn next to the
+    // nearest connected bus that has one, found breadth-first, rather than at the origin, where its
+    // branches would all run to one false point. The offset is a fraction of a typical branch.
+    const inferred = new Uint8Array(graph.buses.length);
+    if (known.length < graph.buses.length) {
+        const neighbours = graph.buses.map(() => []);
+        graph.edges.forEach((e) => {
+            const a = index(e.from);
+            const b = index(e.to);
+            if (a < 0 || b < 0 || a === b)
+                return;
+            neighbours[a].push(b);
+            neighbours[b].push(a);
+        });
+        const lengths = [];
+        graph.edges.forEach((e) => {
+            const a = index(e.from);
+            const b = index(e.to);
+            if (a >= 0 && b >= 0 && xy[a] && xy[b])
+                lengths.push(Math.hypot(xy[a][0] - xy[b][0], xy[a][1] - xy[b][1]));
+        });
+        const positive = lengths.filter((l) => l > 0).sort((p, q) => p - q);
+        const step = (positive.length ? positive[positive.length >> 1] : 1) * 0.5;
+        const placedAt = xy.map((p) => p !== null);
+        const queue = xy.flatMap((p, i) => (p ? [i] : []));
+        const children = new Int32Array(graph.buses.length);
+        for (let head = 0; head < queue.length; head++) {
+            const u = queue[head];
+            for (const v of neighbours[u]) {
+                if (placedAt[v])
+                    continue;
+                placedAt[v] = true;
+                inferred[v] = 1;
+                // Fan several unplaced neighbours of one bus around it.
+                const angle = Math.PI / 4 + children[u]++ * 2.399963;
+                positions[v * 3] = positions[u * 3] + step * Math.cos(angle);
+                positions[v * 3 + 1] = positions[u * 3 + 1] + step * Math.sin(angle);
+                queue.push(v);
+            }
+        }
+        placedAt.forEach((ok, i) => {
+            if (!ok)
+                inferred[i] = 2;
+        });
+    }
+    const role = new Uint8Array(graph.edges.length);
+    graph.edges.forEach((e, k) => {
+        const a = index(e.from);
+        const b = index(e.to);
+        role[k] =
+            !e.closed || a < 0 || b < 0
+                ? 2
+                : tree.parentEdge[a] === k || tree.parentEdge[b] === k
+                    ? 0
+                    : 1;
+    });
+    // Routes by id, so each edge looks only at its namesakes: a scan of every route per edge made
+    // this quadratic in the network size.
+    const routesById = new Map();
+    for (const r of routes) {
+        const key = r.id.toLowerCase();
+        const list = routesById.get(key);
+        if (list)
+            list.push(r);
+        else
+            routesById.set(key, [r]);
+    }
+    return {
+        positions,
+        ...segments(graph, positions, index, (k) => {
+            // A route belongs to one edge by id and endpoints; parallel edges keep their own paths.
+            const e = graph.edges[k];
+            const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+            const route = routesById
+                .get(e.id.toLowerCase())
+                ?.find((r) => (same(r.from, e.from) && same(r.to, e.to)) || (same(r.from, e.to) && same(r.to, e.from)));
+            if (!route || route.path.length < 2)
+                return null;
+            return route.path.map(([lon, lat]) => {
+                const [x, y] = project(lon, lat);
+                return [x - cx, y - cy];
+            });
+        }),
+        role,
+        bounds: bounds(positions),
+        ...(inferred.some((v) => v) ? { inferred } : {}),
+        ...(geographic ? { mercatorOrigin: [cx, cy] } : {})
+    };
+}
+/** The drawn schematic as a PowerIO diagram layer (GeoJSON with `powerio_geo.space = "diagram"`):
+ * one point per bus and one route per line, matched by line id, y down. `kind: "synthetic"` marks
+ * the positions as computed, and `tellegen_layout` records how. Load it with the case to reuse the
+ * layout, or hand it to PowerIO tooling. */
+export function diagramLayer(graph, geometry, provenance) {
+    const round = (v) => Math.round(v * 100) / 100;
+    const features = graph.buses.map((bus, i) => ({
+        type: 'Feature',
+        properties: { bus: bus.id },
+        geometry: {
+            type: 'Point',
+            coordinates: [round(geometry.positions[i * 3]), round(geometry.positions[i * 3 + 1])]
+        }
+    }));
+    const routes = new Map();
+    for (let s = 0; s < geometry.segmentEdge.length; s++) {
+        const k = geometry.segmentEdge[s];
+        const points = routes.get(k) ?? [
+            [round(geometry.sources[s * 3]), round(geometry.sources[s * 3 + 1])]
+        ];
+        points.push([round(geometry.targets[s * 3]), round(geometry.targets[s * 3 + 1])]);
+        routes.set(k, points);
+    }
+    graph.edges.forEach((edge, k) => {
+        const points = routes.get(k);
+        // Only lines carry routes in a PowerIO layer; switches and transformers follow their buses.
+        if (edge.kind !== 'line' || !points || points.length < 2)
+            return;
+        features.push({
+            type: 'Feature',
+            properties: { id: edge.id, bus_from: edge.from, bus_to: edge.to },
+            geometry: { type: 'LineString', coordinates: points }
+        });
+    });
+    return JSON.stringify({
+        type: 'FeatureCollection',
+        powerio_geo: { space: 'diagram', kind: 'synthetic' },
+        tellegen_layout: { algorithm: 'schematic', ...provenance },
+        features
+    });
+}

package/dist/diagram/search.d.ts

@@ -0,0 +1,36 @@
+/** One search over buses, branches and attachments by source identity. Linear scan, no fuzzy
+ * guessing: an engineer searching for `LV12` must not be offered `LV21`. */
+export type EntityKind = 'bus' | 'branch' | 'attachment';
+export interface SearchEntity {
+    kind: EntityKind;
+    index: number;
+    id: string;
+    /** `bus`, or the equipment family such as `line` or `transformer / 2w`. */
+    family: string;
+    /** Source label when a drawing combines several networks. */
+    source?: string;
+    /** `source/id` when a drawing combines several networks; equal to `id` otherwise. */
+    qualified: string;
+}
+export interface SearchIndex {
+    entries: (SearchEntity & {
+        idLower: string;
+        qualifiedLower: string;
+    })[];
+    byKey: Map<string, SearchEntity>;
+}
+export interface SearchMatch extends SearchEntity {
+    exact: boolean;
+}
+/** Readable URL identity, e.g. `branch:line:feeder/L1`, unique even when raw IDs repeat. */
+export declare function entityKey(e: Pick<SearchEntity, 'kind' | 'family' | 'qualified'>): string;
+export declare function buildSearchIndex(entities: SearchEntity[]): SearchIndex;
+/** Rank: exact ID, exact qualified ID, ID prefix, then substring; ties prefer buses, shorter IDs,
+ * then network order. */
+export declare function search(index: SearchIndex, query: string, { limit, kinds }?: {
+    limit?: number | undefined;
+    kinds?: EntityKind[] | null | undefined;
+}): {
+    matches: SearchMatch[];
+    total: number;
+};

package/dist/diagram/search.js

@@ -0,0 +1,48 @@
+const KIND_ORDER = { bus: 0, branch: 1, attachment: 2 };
+/** Readable URL identity, e.g. `branch:line:feeder/L1`, unique even when raw IDs repeat. */
+export function entityKey(e) {
+    const family = e.kind === 'bus' ? '' : `${e.family.replace(' / ', '.')}:`;
+    return `${e.kind}:${family}${e.qualified}`;
+}
+export function buildSearchIndex(entities) {
+    const entries = entities.map((e) => ({
+        ...e,
+        idLower: e.id.toLowerCase(),
+        qualifiedLower: e.qualified.toLowerCase()
+    }));
+    return { entries, byKey: new Map(entities.map((e) => [entityKey(e), e])) };
+}
+/** Rank: exact ID, exact qualified ID, ID prefix, then substring; ties prefer buses, shorter IDs,
+ * then network order. */
+export function search(index, query, { limit = 8, kinds = null } = {}) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return { matches: [], total: 0 };
+    const hits = [];
+    for (const e of index.entries) {
+        if (kinds && !kinds.includes(e.kind))
+            continue;
+        const rank = e.idLower === q
+            ? 0
+            : e.qualifiedLower === q
+                ? 1
+                : e.idLower.startsWith(q)
+                    ? 2
+                    : e.idLower.includes(q) || e.qualifiedLower.includes(q)
+                        ? 3
+                        : -1;
+        if (rank >= 0)
+            hits.push({ rank, e });
+    }
+    hits.sort((a, b) => a.rank - b.rank ||
+        KIND_ORDER[a.e.kind] - KIND_ORDER[b.e.kind] ||
+        a.e.id.length - b.e.id.length ||
+        a.e.index - b.e.index);
+    return {
+        matches: hits.slice(0, limit).map(({ rank, e }) => {
+            const { idLower: _i, qualifiedLower: _q, ...entity } = e;
+            return { ...entity, exact: rank <= 1 };
+        }),
+        total: hits.length
+    };
+}

package/dist/diagram/shared-routes.d.ts

@@ -0,0 +1,21 @@
+import type { SchematicGeometry } from './schematic-layout.js';
+/** One branch of a shared route, drawn spread out from the others. */
+export interface FannedBranch {
+    edge: number;
+    /** Polyline in drawing units: it starts and ends on the true route's ends and runs offset
+     * between them, so every branch still visibly meets its buses. */
+    path: [number, number][];
+    /** Where the branch's marks sit (the middle of the offset run) and its direction there. */
+    mid: [number, number];
+    dir: [number, number];
+}
+/** Lay the members of a shared route side by side: each is offset perpendicular to the route by a
+ * fixed screen distance (`spreadPx` between neighbours), tapering to zero at both ends over at most
+ * `taperPx` or a fifth of the route. `scale` is pixels per drawing unit. Members keep their order,
+ * centred on the true route. */
+export declare function fanRoute(members: number[], host: Int32Array, geometry: SchematicGeometry, scale: number, options?: {
+    spreadPx?: number;
+    taperPx?: number;
+}): FannedBranch[];
+/** The middle of a shared route, for its count badge and its member card. */
+export declare function routeMiddle(members: number[], host: Int32Array, geometry: SchematicGeometry): [number, number] | null;

package/dist/diagram/shared-routes.js

@@ -0,0 +1,40 @@
+/** Lay the members of a shared route side by side: each is offset perpendicular to the route by a
+ * fixed screen distance (`spreadPx` between neighbours), tapering to zero at both ends over at most
+ * `taperPx` or a fifth of the route. `scale` is pixels per drawing unit. Members keep their order,
+ * centred on the true route. */
+export function fanRoute(members, host, geometry, scale, options = {}) {
+    const spread = (options.spreadPx ?? 7) / scale;
+    const taperMax = (options.taperPx ?? 14) / scale;
+    const s = host[members[0]];
+    if (s < 0)
+        return [];
+    const a = [geometry.sources[s * 3], geometry.sources[s * 3 + 1]];
+    const b = [geometry.targets[s * 3], geometry.targets[s * 3 + 1]];
+    const len = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (!(len > 0))
+        return [];
+    const [ux, uy] = [(b[0] - a[0]) / len, (b[1] - a[1]) / len];
+    const [nx, ny] = [-uy, ux];
+    const taper = Math.min(taperMax, len / 5);
+    return members.map((edge, i) => {
+        const off = (i - (members.length - 1) / 2) * spread;
+        const p1 = [a[0] + ux * taper + nx * off, a[1] + uy * taper + ny * off];
+        const p2 = [b[0] - ux * taper + nx * off, b[1] - uy * taper + ny * off];
+        return {
+            edge,
+            path: [a, p1, p2, b],
+            mid: [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2],
+            dir: [ux, uy]
+        };
+    });
+}
+/** The middle of a shared route, for its count badge and its member card. */
+export function routeMiddle(members, host, geometry) {
+    const s = host[members[0]];
+    if (s < 0)
+        return null;
+    return [
+        (geometry.sources[s * 3] + geometry.targets[s * 3]) / 2,
+        (geometry.sources[s * 3 + 1] + geometry.targets[s * 3 + 1]) / 2
+    ];
+}

package/dist/diagram/short-names.d.ts

@@ -0,0 +1,11 @@
+/** The distinctive core of each id: parts (split at `_ - . : /` and spaces) that every id in the
+ * set shares at its start or end are dropped, so `75_MVLV060_Transformer` among other
+ * `75_…_Transformer` ids reads `MVLV060`. A single id, or a set where dropping would leave an id
+ * empty or make two equal, keeps its ids whole. */
+export declare function distinctiveCores(ids: string[]): string[];
+/** Short display names for long ids such as `lv_extension_02ad4cfa5ebe_0062383670bceb3c28d5`.
+ * Parts every id shares at its start or end are dropped first ({@link distinctiveCores}); cores up
+ * to `max` characters are kept, longer ones keep their head and tail around an ellipsis, with the
+ * tail lengthened past `max` only where needed to keep every short name unique. The full id stays
+ * in tooltips and panels. */
+export declare function shortNames(ids: string[], max?: number): string[];

package/dist/diagram/short-names.js

@@ -0,0 +1,54 @@
+/** The distinctive core of each id: parts (split at `_ - . : /` and spaces) that every id in the
+ * set shares at its start or end are dropped, so `75_MVLV060_Transformer` among other
+ * `75_…_Transformer` ids reads `MVLV060`. A single id, or a set where dropping would leave an id
+ * empty or make two equal, keeps its ids whole. */
+export function distinctiveCores(ids) {
+    if (ids.length < 2)
+        return [...ids];
+    const parts = ids.map((id) => [...id.matchAll(/[^_\-.:/\s]+/g)]);
+    const shortest = Math.min(...parts.map((p) => p.length));
+    const same = (pick) => {
+        const first = pick(parts[0])?.[0];
+        return first !== undefined && parts.every((p) => pick(p)?.[0] === first);
+    };
+    let lead = 0;
+    while (lead < shortest - 1 && same((p) => p[lead]))
+        lead++;
+    let trail = 0;
+    while (lead + trail < shortest - 1 && same((p) => p[p.length - 1 - trail]))
+        trail++;
+    if (!lead && !trail)
+        return [...ids];
+    const cores = ids.map((id, i) => {
+        const p = parts[i];
+        const start = p[lead].index;
+        const last = p[p.length - 1 - trail];
+        return id.slice(start, last.index + last[0].length);
+    });
+    return new Set(cores).size === cores.length ? cores : [...ids];
+}
+/** Short display names for long ids such as `lv_extension_02ad4cfa5ebe_0062383670bceb3c28d5`.
+ * Parts every id shares at its start or end are dropped first ({@link distinctiveCores}); cores up
+ * to `max` characters are kept, longer ones keep their head and tail around an ellipsis, with the
+ * tail lengthened past `max` only where needed to keep every short name unique. The full id stays
+ * in tooltips and panels. */
+export function shortNames(ids, max = 20) {
+    const cores = distinctiveCores(ids);
+    const out = [...cores];
+    const long = cores.flatMap((id, i) => (id.length > max ? [i] : []));
+    const head = max - 6;
+    let tail = 5;
+    let pending = long;
+    while (pending.length) {
+        for (const i of pending) {
+            const id = cores[i];
+            out[i] = id.length <= head + tail + 1 ? id : `${id.slice(0, head)}…${id.slice(-tail)}`;
+        }
+        const seen = new Map();
+        for (const name of out)
+            seen.set(name, (seen.get(name) ?? 0) + 1);
+        pending = pending.filter((i) => seen.get(out[i]) > 1 && out[i] !== cores[i]);
+        tail += 3;
+    }
+    return out;
+}

package/dist/diagram/snapshot.d.ts

@@ -0,0 +1,115 @@
+import type { McComplex, McPfResult } from '@tellegen/engine';
+/** Which reference a pair voltage is measured against. */
+export type PairZone = 'phase–neutral' | 'phase–phase' | 'phase–ground';
+/** The second member of a phase–ground pair. */
+export declare const GROUND = "ground";
+/** One declared terminal-pair voltage magnitude and, when declared, its limits. */
+export interface PairVoltage {
+    /** Two terminals, or a terminal and {@link GROUND}. */
+    pair: [string, string];
+    /** Set from the bus's declared neutral, whatever that terminal is named. */
+    zone: PairZone;
+    volts: number;
+    min: number | null;
+    max: number | null;
+}
+export interface UnbalanceValue {
+    percent: number;
+    /** `VUF` uses phasors (|V2| / |V1|); the magnitude-only fallbacks name their standard. */
+    definition: 'VUF' | 'IEEE PVUR' | 'NEMA LVUR';
+}
+export interface BusSnapshot {
+    pairs: PairVoltage[];
+    unbalance: UnbalanceValue | null;
+}
+export interface ConductorCurrent {
+    terminal: string;
+    amps: number;
+}
+/** End totals over every terminal of the element, positive into the equipment. */
+export interface BranchEnd {
+    p: number;
+    q: number;
+    currents: ConductorCurrent[];
+}
+export interface BranchSnapshot {
+    ends: [BranchEnd | null, BranchEnd | null];
+    /** Loading of the whole piece of equipment: every edge of a multi-winding transformer shows the
+     * same value. */
+    loading: number | null;
+    basis: string | null;
+    /** The first edge of its equipment. A multi-winding transformer projects to one edge per
+     * winding pair; only its first edge counts in totals and issue lists. */
+    primary: boolean;
+    /** Active and reactive power the equipment consumes (kW, kvar), summed once over every port;
+     * on the primary edge only, and null when a port is missing. */
+    loss: {
+        p: number;
+        q: number;
+    } | null;
+}
+/** A result snapshot indexed like the drawing: `buses[i]` and `branches[b]` follow the network order. */
+export interface ResultSnapshot {
+    kind: 'solved' | 'stress';
+    label: string;
+    iterations: number | null;
+    buses: BusSnapshot[];
+    branches: BranchSnapshot[];
+}
+/** Declared limits for one bus, by reference; a bus can declare several. Phase–neutral limits
+ * list one band per phase terminal, phase–ground limits one per bounded terminal in terminal
+ * order. A phase–phase band applies to its pair of terminals in either order, or to every pair
+ * when `pair` is null (a uniform band). */
+export interface BusLimits {
+    phaseNeutral?: {
+        min: number[];
+        max: number[];
+    };
+    phasePhase?: {
+        pair: [string, string] | null;
+        min: number;
+        max: number;
+    }[];
+    phaseGround?: {
+        terminal: string;
+        min: number;
+        max: number;
+    }[];
+}
+export interface SnapshotBus {
+    id: string;
+    terminals: string[];
+    /** The declared neutral; `null` when the model declares there is none, absent when it is silent
+     * (the familiar aliases then apply). */
+    neutral?: string | null;
+    limits?: BusLimits | null;
+}
+/** Ampacity per conductor, or a transformer's apparent-power rating (VA) at each bus it connects,
+ * keyed by bus id. */
+export type BranchRating = {
+    kind: 'current';
+    amps: number[];
+} | {
+    kind: 'apparent';
+    byBus: Record<string, number>;
+};
+export interface SnapshotBranch {
+    id: string;
+    from: string;
+    to: string;
+    fromTerminals: string[];
+    toTerminals: string[];
+    inService: boolean;
+    /** Element kind, matched against port kinds so a line and a switch sharing a name stay apart. */
+    kind?: string;
+    rating?: BranchRating | null;
+}
+/** Voltage unbalance factor |V2| / |V1| in percent, from three phasors in phase order. The ratio
+ * is the same for phase–neutral and phase–phase voltages, so either reference works. */
+export declare function sequenceUnbalance(a: McComplex, b: McComplex, c: McComplex): number | null;
+/** Project a full multiconductor power-flow result onto the drawing's bus and branch order.
+ * Missing ports leave an end `null`; nothing is interpolated. */
+export declare function snapshotFromMcPf(result: McPfResult, buses: SnapshotBus[], branches: SnapshotBranch[], label?: string): ResultSnapshot;
+/** Bus results from a live session's transferred terminal arrays (`[re, im]` interleaved), for when
+ * the full result with element ports has not been fetched. Branches are left without results. */
+export declare function snapshotBusesFromTerminals(ids: ArrayLike<[string, string]>, voltages: ArrayLike<number>, buses: SnapshotBus[]): BusSnapshot[];