@tellegen/svelte 0.4.3 → 0.4.5

package/dist/diagram/galvanic-zones.js

@@ -0,0 +1,210 @@
+import { busState, loadingState } from './summary.js';
+/** Connected components over closed non-transformer branches. */
+export function galvanicZones(graph, tree) {
+    const n = graph.buses.length;
+    const index = new Map(graph.buses.map((b, i) => [b.id.toLowerCase(), i]));
+    const ends = graph.edges.map((e) => [index.get(e.from.toLowerCase()) ?? -1, index.get(e.to.toLowerCase()) ?? -1]);
+    const root = Int32Array.from({ length: n }, (_, i) => i);
+    const find = (i) => {
+        while (root[i] !== i)
+            i = root[i] = root[root[i]];
+        return i;
+    };
+    graph.edges.forEach((e, k) => {
+        const [a, b] = ends[k];
+        if (a < 0 || b < 0 || !e.closed || e.kind === 'transformer')
+            return;
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+            root[ra] = rb;
+    });
+    const busZone = new Int32Array(n).fill(-1);
+    const zones = [];
+    for (let i = 0; i < n; i++) {
+        const r = find(i);
+        if (busZone[r] < 0) {
+            busZone[r] = zones.length;
+            zones.push({ buses: [], edges: [], transformers: [], hasSource: false });
+        }
+        busZone[i] = busZone[r];
+        const z = zones[busZone[i]];
+        z.buses.push(i);
+        if (graph.buses[i].has_source)
+            z.hasSource = true;
+    }
+    graph.edges.forEach((e, k) => {
+        const [a, b] = ends[k];
+        if (a < 0 || b < 0)
+            return;
+        if (e.kind === 'transformer') {
+            for (const z of new Set([busZone[a], busZone[b]]))
+                zones[z].transformers.push(k);
+        }
+        else if (busZone[a] === busZone[b])
+            zones[busZone[a]].edges.push(k);
+    });
+    // The feeding transformer is the one the display tree enters the zone through.
+    if (tree)
+        for (const z of zones) {
+            const feed = z.buses
+                .map((i) => tree.parentEdge[i])
+                .find((k) => k >= 0 && graph.edges[k].kind === 'transformer');
+            if (feed !== undefined)
+                z.transformers = [feed, ...z.transformers.filter((k) => k !== feed)];
+        }
+    return { zones, busZone };
+}
+/** A zone's worst state: a voltage outside its band or a branch over its rating is a violation,
+ * loading at or above the warning threshold a warning. Its transformers count. */
+export function zoneState(zone, snapshot) {
+    if (!snapshot)
+        return 'missing';
+    const rank = { missing: 0, normal: 1, warning: 2, violation: 3 };
+    let state = 'missing';
+    const raise = (s) => {
+        if (rank[s] > rank[state])
+            state = s;
+    };
+    for (const i of zone.buses) {
+        const s = busState(snapshot.buses[i]);
+        raise(s === 'violation' ? 'violation' : s === 'normal' ? 'normal' : 'missing');
+    }
+    for (const k of [...zone.transformers, ...zone.edges]) {
+        const s = loadingState(snapshot.branches[k]?.loading ?? null);
+        if (s !== 'missing')
+            raise(s);
+    }
+    return state;
+}
+/** The outline of a zone in a schematic layout: one band per drawing column (depth), from the
+ * zone's highest bus to the lowest attachment symbol below it, joined into a staircase. Tidy and
+ * leaf-order layouts keep each subtree's rows contiguous per column, so neighbouring zones'
+ * outlines do not overlap; a zone nested inside another sits inside its outline. */
+export function zoneOutline(zone, positions, below, options) {
+    const columns = new Map();
+    for (const i of zone.buses) {
+        const x = positions[i * 3];
+        const y = positions[i * 3 + 1];
+        const c = columns.get(x);
+        if (c) {
+            c[0] = Math.min(c[0], y);
+            c[1] = Math.max(c[1], y + below[i]);
+        }
+        else
+            columns.set(x, [y, y + below[i]]);
+    }
+    const xs = [...columns.keys()].sort((a, b) => a - b);
+    const { dx, pad } = options;
+    // The first column starts just after the feeding transformer's symbol; the last leaves room
+    // for attachment symbols and their values to the right of the bus.
+    const left = (j) => (j === 0 ? xs[0] - 0.15 * dx : (xs[j - 1] + xs[j]) / 2);
+    const right = (j) => (j === xs.length - 1 ? xs[j] + 0.4 * dx : (xs[j] + xs[j + 1]) / 2);
+    const top = [];
+    const bottom = [];
+    xs.forEach((x, j) => {
+        const [lo, hi] = columns.get(x);
+        top.push([left(j), lo - pad], [right(j), lo - pad]);
+        bottom.push([left(j), hi + pad], [right(j), hi + pad]);
+    });
+    return [...top, ...bottom.reverse()];
+}
+export function zoneCorridors(zones, geometry, include) {
+    const edgeZone = new Map();
+    zones.zones.forEach((zone, z) => {
+        if (include(zone))
+            for (const k of zone.edges)
+                edgeZone.set(k, z);
+    });
+    const out = new Map();
+    zones.zones.forEach((zone, z) => {
+        if (!include(zone))
+            return;
+        let [x0, y0, x1, y1] = [Infinity, Infinity, -Infinity, -Infinity];
+        for (const i of zone.buses) {
+            const x = geometry.positions[i * 3];
+            const y = geometry.positions[i * 3 + 1];
+            [x0, y0, x1, y1] = [Math.min(x0, x), Math.min(y0, y), Math.max(x1, x), Math.max(y1, y)];
+        }
+        out.set(z, { z, segments: [], buses: zone.buses, bounds: [x0, y0, x1, y1] });
+    });
+    for (let s = 0; s < geometry.segmentEdge.length; s++) {
+        const z = edgeZone.get(geometry.segmentEdge[s]);
+        if (z !== undefined)
+            out.get(z).segments.push(s);
+    }
+    return [...out.values()];
+}
+/** A zone's voltage level in volts: the declared rating of a winding or source in it (the
+ * largest), else its declared limits (midpoint of the band; a phase–neutral or phase–ground band
+ * times √3), else its solved voltages, as the median over its buses. Null when none is known. */
+export function zoneVoltage(zone, graph, snapshot) {
+    let nominal = 0;
+    for (const i of zone.buses)
+        nominal = Math.max(nominal, graph.buses[i].nominal_voltage ?? 0);
+    if (nominal > 0)
+        return nominal;
+    const levels = [];
+    const mid = (lo, hi) => lo?.length && hi?.length ? (Math.min(...lo) + Math.max(...hi)) / 2 : null;
+    const values = (byTerminal) => byTerminal && Object.values(byTerminal);
+    for (const i of zone.buses) {
+        const l = graph.buses[i].voltage_limits;
+        const pp = mid(l?.vpp_min, l?.vpp_max);
+        // Phase–neutral or phase–ground: the phase voltage, √3 below line to line.
+        const phaseBand = mid(l?.vpn_min, l?.vpn_max) ??
+            mid(values(l?.v_min_by_terminal), values(l?.v_max_by_terminal));
+        let v = pp ?? (phaseBand === null ? null : phaseBand * Math.sqrt(3));
+        if (v === null && snapshot) {
+            const pairs = snapshot.buses[i]?.pairs ?? [];
+            const phase = pairs.filter((p) => p.zone === 'phase–phase');
+            const single = pairs.filter((p) => p.zone !== 'phase–phase');
+            if (phase.length)
+                v = Math.max(...phase.map((p) => p.volts));
+            else if (single.length)
+                v = Math.max(...single.map((p) => p.volts)) * Math.sqrt(3);
+        }
+        if (v !== null && Number.isFinite(v) && v > 0)
+            levels.push(v);
+    }
+    if (!levels.length)
+        return null;
+    levels.sort((a, b) => a - b);
+    return levels[levels.length >> 1];
+}
+/** `mv` from 1 kV phase–phase up (drawn heavier), else `lv`. Without a known voltage the source
+ * zone counts as `mv`, others as `lv`. */
+export function zoneLevel(zone, volts) {
+    if (volts === null)
+        return zone.hasSource ? 'mv' : 'lv';
+    return volts >= 1000 ? 'mv' : 'lv';
+}
+/** One-line zone summary for its label: lowest phase–neutral (else phase–ground, else
+ * phase–phase) voltage and highest loading among its branches and transformers, when solved. */
+export function zoneSummary(zone, snapshot) {
+    if (!snapshot)
+        return { minVolts: null, maxLoading: null };
+    let pn = Infinity;
+    let pg = Infinity;
+    let pp = Infinity;
+    for (const i of zone.buses)
+        for (const p of snapshot.buses[i]?.pairs ?? []) {
+            if (!Number.isFinite(p.volts))
+                continue;
+            if (p.zone === 'phase–neutral')
+                pn = Math.min(pn, p.volts);
+            else if (p.zone === 'phase–ground')
+                pg = Math.min(pg, p.volts);
+            else
+                pp = Math.min(pp, p.volts);
+        }
+    let loading = -Infinity;
+    for (const k of [...zone.transformers, ...zone.edges]) {
+        const l = snapshot.branches[k]?.loading;
+        if (l !== null && l !== undefined && Number.isFinite(l))
+            loading = Math.max(loading, l);
+    }
+    return {
+        minVolts: [pn, pg, pp].find(Number.isFinite) ?? null,
+        maxLoading: Number.isFinite(loading) ? loading : null
+    };
+}

package/dist/diagram/graph-inputs.d.ts

@@ -0,0 +1,18 @@
+import type { DistGraph, DistGraphBus, DistGraphEdge } from '@tellegen/engine';
+import type { SearchEntity } from './search.js';
+import type { BusLimits, BranchRating, SnapshotBranch, SnapshotBus } from './snapshot.js';
+import type { TableNames } from './results-table.js';
+/** Everything the workbench derives from one multiconductor graph, in graph order. */
+export interface GraphInputs {
+    buses: SnapshotBus[];
+    branches: SnapshotBranch[];
+    names: TableNames;
+    entities: SearchEntity[];
+}
+/** Declared bands only, each with both a minimum and a maximum. Phase–phase bounds are ordered by
+ * the pairs (1,2), (2,3), (3,1) of the phase terminals (BMOPF 0.2.0), which the engine names in
+ * `vpp_pairs`; without those names only a uniform band is taken, as there is nothing to place the
+ * others by. Sequence and neutral-to-ground bounds are not ranked. */
+export declare function busLimits(bus: Pick<DistGraphBus, 'voltage_limits' | 'terminals'>): BusLimits | null;
+export declare function edgeRating(edge: Pick<DistGraphEdge, 'rating'>): BranchRating | null;
+export declare function graphInputs(graph: DistGraph): GraphInputs;

package/dist/diagram/graph-inputs.js

@@ -0,0 +1,103 @@
+/** Declared bands only, each with both a minimum and a maximum. Phase–phase bounds are ordered by
+ * the pairs (1,2), (2,3), (3,1) of the phase terminals (BMOPF 0.2.0), which the engine names in
+ * `vpp_pairs`; without those names only a uniform band is taken, as there is nothing to place the
+ * others by. Sequence and neutral-to-ground bounds are not ranked. */
+export function busLimits(bus) {
+    const l = bus.voltage_limits;
+    if (!l)
+        return null;
+    const limits = {};
+    if (l.vpn_min?.length && l.vpn_max?.length === l.vpn_min.length)
+        limits.phaseNeutral = { min: l.vpn_min, max: l.vpn_max };
+    const [lo, hi, pairs] = [l.vpp_min, l.vpp_max, l.vpp_pairs];
+    if (pairs?.length && lo?.length === pairs.length && hi?.length === pairs.length) {
+        limits.phasePhase = pairs.map((pair, k) => ({ pair, min: lo[k], max: hi[k] }));
+    }
+    else {
+        const uniform = (v) => (v?.length && v.every((x) => x === v[0]) ? v[0] : null);
+        const min = uniform(lo);
+        const max = uniform(hi);
+        if (min !== null && max !== null)
+            limits.phasePhase = [{ pair: null, min, max }];
+    }
+    const below = l.v_min_by_terminal ?? {};
+    const above = l.v_max_by_terminal ?? {};
+    const ground = bus.terminals.flatMap((terminal) => Object.hasOwn(below, terminal) && Object.hasOwn(above, terminal)
+        ? [{ terminal, min: below[terminal], max: above[terminal] }]
+        : []);
+    if (ground.length)
+        limits.phaseGround = ground;
+    return limits.phaseNeutral || limits.phasePhase || limits.phaseGround ? limits : null;
+}
+export function edgeRating(edge) {
+    const r = edge.rating;
+    if (r?.i_max?.length)
+        return { kind: 'current', amps: r.i_max };
+    const byBus = r?.s_rating_by_bus;
+    if (byBus && Object.values(byBus).some((va) => va > 0))
+        return { kind: 'apparent', byBus };
+    return null;
+}
+export function graphInputs(graph) {
+    const index = new Map(graph.buses.map((b, i) => [b.id.toLowerCase(), i]));
+    const busIndex = (id) => index.get(id.toLowerCase()) ?? -1;
+    const buses = graph.buses.map((b) => ({
+        id: b.id,
+        terminals: b.terminals,
+        // Kept as given: `null` declares no neutral, absent leaves the aliases to decide.
+        neutral: b.neutral_terminal,
+        limits: busLimits(b)
+    }));
+    const branches = graph.edges.map((e) => ({
+        id: e.id,
+        kind: e.kind,
+        from: e.from,
+        to: e.to,
+        fromTerminals: e.conductors.map((c) => c[0]),
+        toTerminals: e.conductors.map((c) => c[1]),
+        inService: e.closed,
+        rating: edgeRating(e)
+    }));
+    return {
+        buses,
+        branches,
+        names: {
+            buses: graph.buses.map((b) => ({ id: b.id })),
+            branches: graph.edges.map((e) => ({
+                id: e.id,
+                family: e.kind,
+                from: busIndex(e.from),
+                to: busIndex(e.to),
+                inService: e.closed
+            }))
+        },
+        entities: [
+            ...graph.buses.map((b, i) => ({
+                kind: 'bus',
+                index: i,
+                id: b.id,
+                family: 'bus',
+                qualified: b.id
+            })),
+            // One entry per piece of equipment: a multi-winding transformer projects to one edge per
+            // winding pair, all sharing its id, and is found once, at its first edge.
+            ...firstEdges(graph).map((i) => {
+                const e = graph.edges[i];
+                return { kind: 'branch', index: i, id: e.id, family: e.kind, qualified: e.id };
+            })
+        ]
+    };
+}
+/** Index of the first edge of each kind and id, in graph order. */
+function firstEdges(graph) {
+    const seen = new Set();
+    const out = [];
+    graph.edges.forEach((e, i) => {
+        const key = `${e.kind}\u0000${e.id}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push(i);
+    });
+    return out;
+}

package/dist/diagram/index.d.ts

@@ -0,0 +1,28 @@
+/** Engineering diagram workbench logic, ported from the diagram-projection prototype in PR #177.
+ * Pure and renderer-independent: components and the deck.gl canvas build on these. */
+export * from './snapshot.js';
+export * from './summary.js';
+export * from './colour-modes.js';
+export * from './search.js';
+export * from './results-table.js';
+export * from './value-labels.js';
+export * from './svg-export.js';
+export * from './layout-morph.js';
+export * from './phase-bars.js';
+export * from './view-state.js';
+export * from './graph-inputs.js';
+export * from './display-tree.js';
+export * from './schematic-layout.js';
+export * from './multi-wire.js';
+export * from './schematic-equipment.js';
+export * from './energisation.js';
+export * from './short-names.js';
+export * from './tree-walk.js';
+export * from './galvanic-zones.js';
+export * from './voltage-levels.js';
+export * from './feeders.js';
+export * from './connections.js';
+export * from './landmarks.js';
+export * from './basemap.js';
+export * from './shared-routes.js';
+export * from './bus-stacks.js';

package/dist/diagram/index.js

@@ -0,0 +1,28 @@
+/** Engineering diagram workbench logic, ported from the diagram-projection prototype in PR #177.
+ * Pure and renderer-independent: components and the deck.gl canvas build on these. */
+export * from './snapshot.js';
+export * from './summary.js';
+export * from './colour-modes.js';
+export * from './search.js';
+export * from './results-table.js';
+export * from './value-labels.js';
+export * from './svg-export.js';
+export * from './layout-morph.js';
+export * from './phase-bars.js';
+export * from './view-state.js';
+export * from './graph-inputs.js';
+export * from './display-tree.js';
+export * from './schematic-layout.js';
+export * from './multi-wire.js';
+export * from './schematic-equipment.js';
+export * from './energisation.js';
+export * from './short-names.js';
+export * from './tree-walk.js';
+export * from './galvanic-zones.js';
+export * from './voltage-levels.js';
+export * from './feeders.js';
+export * from './connections.js';
+export * from './landmarks.js';
+export * from './basemap.js';
+export * from './shared-routes.js';
+export * from './bus-stacks.js';

package/dist/diagram/landmarks.d.ts

@@ -0,0 +1,50 @@
+import type { DistGraph } from '@tellegen/engine';
+import type { GalvanicZones, ZoneState } from './galvanic-zones.js';
+import { type EquipmentSymbols, type Glyph } from './schematic-equipment.js';
+import type { SchematicGeometry } from './schematic-layout.js';
+/** Equipment that should stay findable when the drawing is zoomed out: drawn at a fixed screen
+ * size, placed by priority so the overview never fills with markers. */
+export interface Landmark {
+    kind: 'source' | 'generator' | 'ibr' | 'transformer';
+    x: number;
+    y: number;
+    /** Direction along the branch, for transformers. */
+    cos: number;
+    sin: number;
+    /** Lower is placed first: 0 sources (always), 1 transformers whose network has a problem,
+     * 2 machines and large IBRs, 3 other transformers, 4 small IBRs. */
+    tier: number;
+    /** Within a tier, larger first: generation in W, or the fed network's bus count. */
+    weight: number;
+    state: ZoneState | null;
+    ids: string[];
+    bus: number;
+    edge: number;
+    /** The marker, when it differs by unit: a transformer's winding marks or centre tap. */
+    glyph?: Glyph;
+}
+/** An IBR counts as large from this share of all generation and IBR output upwards. */
+export declare const LARGE_IBR_SHARE = 0.01;
+/** Landmark candidates in priority order. Generators and IBRs are grouped per bus and kind, sized by
+ * solved output when `powers` is given, else by the bus's declared generation. */
+export declare function landmarkCandidates(graph: DistGraph, geometry: SchematicGeometry, symbols: EquipmentSymbols | null, zones: GalvanicZones, zoneStates: ZoneState[], powers: Map<string, {
+    p: number;
+    q: number;
+}> | null): Landmark[];
+/** Greedy placement on a coarse screen grid: sources always; others only inside the view, on a
+ * free cell (and its neighbours), up to `budget` markers. */
+export declare function placeLandmarks(candidates: Landmark[], toScreen: (x: number, y: number) => [number, number], view: {
+    width: number;
+    height: number;
+    cell?: number;
+    budget?: number;
+}): Landmark[];
+/** The marker glyph for a landmark, centred on the origin: the symbol itself without its lead. */
+export declare function landmarkGlyph(kind: Landmark['kind']): Glyph;
+/** Stroke segments for placed landmarks, `unit` drawing units per glyph unit (a fixed number of
+ * pixels at the current zoom), with the landmark index of each segment. */
+export declare function landmarkStrokes(placed: Landmark[], unit: number): {
+    sources: Float32Array;
+    targets: Float32Array;
+    owner: Int32Array;
+};

package/dist/diagram/landmarks.js

@@ -0,0 +1,153 @@
+import { attachmentGlyph, branchGlyph } from './schematic-equipment.js';
+import { transformerGlyph, transformerInfo } from './connections.js';
+/** An IBR counts as large from this share of all generation and IBR output upwards. */
+export const LARGE_IBR_SHARE = 0.01;
+/** Landmark candidates in priority order. Generators and IBRs are grouped per bus and kind, sized by
+ * solved output when `powers` is given, else by the bus's declared generation. */
+export function landmarkCandidates(graph, geometry, symbols, zones, zoneStates, powers) {
+    const out = [];
+    const at = (i) => [geometry.positions[i * 3], geometry.positions[i * 3 + 1]];
+    const gens = [];
+    graph.buses.forEach((bus, i) => {
+        const byKind = new Map();
+        for (const list of Object.values(bus.terminal_attachments ?? {}))
+            for (const a of list)
+                byKind.set(a.kind, (byKind.get(a.kind) ?? new Set()).add(a.id));
+        const [x, y] = at(i);
+        const base = { x, y, cos: 1, sin: 0, state: null, bus: i, edge: -1 };
+        if (bus.has_source || byKind.has('source'))
+            out.push({
+                ...base,
+                kind: 'source',
+                tier: 0,
+                weight: 0,
+                ids: [...(byKind.get('source') ?? [bus.id])]
+            });
+        for (const kind of ['generator', 'ibr']) {
+            const ids = [...(byKind.get(kind) ?? [])];
+            if (!ids.length)
+                continue;
+            const solved = powers
+                ? ids.reduce((sum, id) => sum + Math.max(0, -(powers.get(id)?.p ?? 0)), 0)
+                : 0;
+            const weight = solved || Math.max(0, bus.gen_kw * 1000);
+            gens.push({ ...base, kind, tier: 2, weight, ids });
+        }
+    });
+    const total = gens.reduce((sum, g) => sum + g.weight, 0);
+    for (const g of gens)
+        if (g.kind === 'ibr' && !(total > 0 && g.weight >= LARGE_IBR_SHARE * total))
+            g.tier = 4;
+    out.push(...gens);
+    // The network each transformer feeds, for its state and size.
+    const fed = new Map();
+    zones.zones.forEach((z, zi) => {
+        if (z.transformers.length && !z.hasSource)
+            fed.set(z.transformers[0], zi);
+    });
+    const index = new Map(graph.buses.map((b, i) => [b.id.toLowerCase(), i]));
+    // One marker per transformer, on its first winding-pair edge.
+    const seen = new Set();
+    graph.edges.forEach((edge, k) => {
+        if (edge.kind !== 'transformer' || seen.has(edge.id))
+            return;
+        seen.add(edge.id);
+        let x = symbols?.anchors[k * 2] ?? NaN;
+        let y = symbols?.anchors[k * 2 + 1] ?? NaN;
+        // A vertical branch has cos exactly 0, so test for a missing direction, not a falsy one.
+        const fx = symbols?.flowDir[k * 2] ?? 0;
+        const fy = symbols?.flowDir[k * 2 + 1] ?? 0;
+        const known = fx !== 0 || fy !== 0;
+        let cos = known ? fx : 1;
+        let sin = known ? fy : 0;
+        if (!Number.isFinite(x)) {
+            const a = index.get(edge.from.toLowerCase());
+            const b = index.get(edge.to.toLowerCase());
+            if (a === undefined || b === undefined)
+                return;
+            const [ax, ay] = at(a);
+            const [bx, by] = at(b);
+            [x, y] = [(ax + bx) / 2, (ay + by) / 2];
+            const len = Math.hypot(bx - ax, by - ay) || 1;
+            [cos, sin] = [(bx - ax) / len, (by - ay) / len];
+        }
+        const zi = fed.get(k);
+        const state = zi === undefined ? null : zoneStates[zi];
+        const problem = state === 'violation' || state === 'warning';
+        out.push({
+            kind: 'transformer',
+            x,
+            y,
+            cos,
+            sin,
+            tier: problem ? 1 : 3,
+            weight: zi === undefined ? 0 : zones.zones[zi].buses.length,
+            state,
+            ids: [edge.id],
+            bus: -1,
+            edge: k,
+            glyph: transformerGlyph(transformerInfo(graph, k), edge.n_phases, false)
+        });
+    });
+    return out.sort((a, b) => a.tier - b.tier || b.weight - a.weight);
+}
+/** Greedy placement on a coarse screen grid: sources always; others only inside the view, on a
+ * free cell (and its neighbours), up to `budget` markers. */
+export function placeLandmarks(candidates, toScreen, view) {
+    const cell = view.cell ?? 28;
+    const budget = view.budget ?? 60;
+    const taken = new Set();
+    const placed = [];
+    for (const c of candidates) {
+        const [sx, sy] = toScreen(c.x, c.y);
+        const inside = sx >= 0 && sx <= view.width && sy >= 0 && sy <= view.height;
+        if (!inside)
+            continue;
+        const gx = Math.floor(sx / cell);
+        const gy = Math.floor(sy / cell);
+        if (c.tier > 0) {
+            if (placed.length >= budget)
+                break;
+            let free = true;
+            for (let dx = -1; dx <= 1 && free; dx++)
+                for (let dy = -1; dy <= 1 && free; dy++)
+                    if (taken.has(`${gx + dx},${gy + dy}`))
+                        free = false;
+            if (!free)
+                continue;
+        }
+        taken.add(`${gx},${gy}`);
+        placed.push(c);
+    }
+    return placed;
+}
+/** The marker glyph for a landmark, centred on the origin: the symbol itself without its lead. */
+export function landmarkGlyph(kind) {
+    if (kind === 'transformer')
+        return branchGlyph('transformer', true).slice(1, 3);
+    return attachmentGlyph(kind)
+        .slice(1)
+        .map((line) => line.map(([x, y]) => [x - 1.3, y]));
+}
+/** Stroke segments for placed landmarks, `unit` drawing units per glyph unit (a fixed number of
+ * pixels at the current zoom), with the landmark index of each segment. */
+export function landmarkStrokes(placed, unit) {
+    const src = [];
+    const dst = [];
+    const owner = [];
+    placed.forEach((l, j) => {
+        for (const line of l.glyph ?? landmarkGlyph(l.kind))
+            for (let i = 1; i < line.length; i++) {
+                const [ax, ay] = line[i - 1];
+                const [bx, by] = line[i];
+                src.push(l.x + unit * (ax * l.cos - ay * l.sin), l.y + unit * (ax * l.sin + ay * l.cos), 0);
+                dst.push(l.x + unit * (bx * l.cos - by * l.sin), l.y + unit * (bx * l.sin + by * l.cos), 0);
+                owner.push(j);
+            }
+    });
+    return {
+        sources: Float32Array.from(src),
+        targets: Float32Array.from(dst),
+        owner: Int32Array.from(owner)
+    };
+}

package/dist/diagram/layout-morph.d.ts

@@ -0,0 +1,15 @@
+/** Animated transition between two layouts of the same buses, so the eye can follow a feeder. */
+export declare const MORPH_MS = 900;
+/** Measured smooth up to 98,633 buses on the reference machine (M4 Max, #177 M0 evidence, with a
+ * warm-up frame); larger drawings switch instantly until measured. */
+export declare const MORPH_MAX_BUSES = 100000;
+export interface Camera {
+    target: ArrayLike<number>;
+    zoom: number;
+}
+export declare const ease: (t: number) => number;
+/** Re-express layout A positions in layout B's world, so each bus starts where it is on screen. */
+export declare function screenAnchored(positions: ArrayLike<number>, from: Camera, to: Camera): Float32Array;
+export declare function lerpInto(out: Float32Array, a: ArrayLike<number>, b: ArrayLike<number>, t: number): Float32Array<ArrayBufferLike>;
+/** Straight bus-to-bus chords while moving; routed geometry returns when the transition ends. */
+export declare function chordsInto(sources: Float32Array, targets: Float32Array, endpoints: ArrayLike<number>, positions: ArrayLike<number>): void;

package/dist/diagram/layout-morph.js

@@ -0,0 +1,32 @@
+/** Animated transition between two layouts of the same buses, so the eye can follow a feeder. */
+export const MORPH_MS = 900;
+/** Measured smooth up to 98,633 buses on the reference machine (M4 Max, #177 M0 evidence, with a
+ * warm-up frame); larger drawings switch instantly until measured. */
+export const MORPH_MAX_BUSES = 100_000;
+export const ease = (t) => (t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2);
+/** Re-express layout A positions in layout B's world, so each bus starts where it is on screen. */
+export function screenAnchored(positions, from, to) {
+    const k = 2 ** from.zoom / 2 ** to.zoom;
+    const out = new Float32Array(positions.length);
+    for (let i = 0; i < positions.length; i += 3) {
+        out[i] = to.target[0] + (positions[i] - from.target[0]) * k;
+        out[i + 1] = to.target[1] + (positions[i + 1] - from.target[1]) * k;
+    }
+    return out;
+}
+export function lerpInto(out, a, b, t) {
+    for (let i = 0; i < out.length; i++)
+        out[i] = a[i] + (b[i] - a[i]) * t;
+    return out;
+}
+/** Straight bus-to-bus chords while moving; routed geometry returns when the transition ends. */
+export function chordsInto(sources, targets, endpoints, positions) {
+    for (let b = 0; b < endpoints.length / 2; b++) {
+        const u = endpoints[b * 2] * 3;
+        const v = endpoints[b * 2 + 1] * 3;
+        for (let k = 0; k < 3; k++) {
+            sources[b * 3 + k] = positions[u + k];
+            targets[b * 3 + k] = positions[v + k];
+        }
+    }
+}