@tellegen/svelte 0.4.3 → 0.4.5

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

@@ -1,4 +1,6 @@
 export { getNoticeCenter, errorNoticeTitle } from './notices.svelte.js';
+export { DiagnosticLog, LOG_SEVERITIES, errorEntry, errorStage, logSeverity, powerIoEntry, solveEntry } from './log.svelte.js';
+export type { LogDocument, LogEntry, LogEntryInput, LogSeverity } from './log.svelte.js';
 export { default as ModelDetails } from './components/ModelDetails.svelte';
 export { default as PanelFrame } from './components/PanelFrame.svelte';
 export { getPanelLayout } from './panels.svelte.js';
@@ -27,3 +29,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

@@ -1,4 +1,5 @@
 export { getNoticeCenter, errorNoticeTitle } from './notices.svelte.js';
+export { DiagnosticLog, LOG_SEVERITIES, errorEntry, errorStage, logSeverity, powerIoEntry, solveEntry } from './log.svelte.js';
 export { default as ModelDetails } from './components/ModelDetails.svelte';
 export { default as PanelFrame } from './components/PanelFrame.svelte';
 export { getPanelLayout } from './panels.svelte.js';
@@ -17,3 +18,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/log.svelte.d.ts

@@ -0,0 +1,77 @@
+import type { PowerIoDiagnostic, SolveDiagnostic } from '@tellegen/engine';
+/** How serious a finding is. PowerIO's `remark` and `note` both read as notes. */
+export type LogSeverity = 'error' | 'warning' | 'note';
+export declare const LOG_SEVERITIES: readonly LogSeverity[];
+/** One finding to record. `stage` names what was happening (`Open`, `Solve`,
+ * `Export`, or a host's own step such as `Generate`); `source` names who
+ * reported it (`PowerIO`, `tellegen`, or a host's data source). */
+export interface LogEntryInput {
+    severity: LogSeverity;
+    stage: string;
+    source: string;
+    message: string;
+    /** Stable machine code, such as `EMIT.MATPOWER.FIELD_DROPPED`. */
+    code?: string;
+    /** The case, file or download the finding belongs to. */
+    subject?: string;
+    /** The element the finding names, in PowerIO's spelling. */
+    target?: string;
+    buses?: number[];
+    /** What to do about it, when the reporter says. */
+    hint?: string;
+    details?: Record<string, unknown>;
+}
+export interface LogEntry extends LogEntryInput {
+    id: number;
+    /** How many times the same finding was reported. */
+    count: number;
+    /** Epoch milliseconds of the first and the latest report. */
+    first: number;
+    last: number;
+}
+/** The log as a file: what `DiagnosticLog.toJSON` returns and the log view downloads. */
+export interface LogDocument {
+    format: 'tellegen.log';
+    version: 1;
+    written_at: string;
+    counts: Record<LogSeverity, number>;
+    entries: (Omit<LogEntry, 'first' | 'last'> & {
+        first: string;
+        last: string;
+    })[];
+}
+/** Every finding the app reported, in the order it first appeared. A finding
+ * reported again counts up in place instead of adding a row, so a re-solve or a
+ * second export of the same case does not flood the log. */
+export declare class DiagnosticLog {
+    #private;
+    entries: LogEntry[];
+    /** Bumped on every write, including a repeat that only moves `last`. */
+    revision: number;
+    constructor(now?: () => number);
+    /** Record findings. With `repeat: false`, a finding already in the log keeps
+     * its count and takes the new details: use it for state that every solve
+     * restates, or to add the detail behind an error just recorded. */
+    record(input: LogEntryInput | readonly LogEntryInput[], options?: {
+        repeat?: boolean;
+    }): void;
+    clear(): void;
+    get counts(): Record<LogSeverity, number>;
+    toJSON(): LogDocument;
+}
+export declare function logSeverity(severity: PowerIoDiagnostic['severity']): LogSeverity;
+interface EntryContext {
+    stage: string;
+    subject?: string;
+}
+/** A PowerIO reader or writer finding as a log entry. */
+export declare function powerIoEntry(d: PowerIoDiagnostic, context: EntryContext): LogEntryInput;
+/** A solver finding (islands, HVDC transfers) as a log entry. */
+export declare function solveEntry(d: SolveDiagnostic, context: {
+    subject?: string;
+}): LogEntryInput;
+/** Which step an app error message comes from, by its wording. */
+export declare function errorStage(message: string): string;
+/** An app error as a log entry. */
+export declare function errorEntry(message: string, detail?: string | null): LogEntryInput;
+export {};

package/dist/log.svelte.js

@@ -0,0 +1,149 @@
+export const LOG_SEVERITIES = ['error', 'warning', 'note'];
+const MAX_ENTRIES = 500;
+const keyOf = (e) => JSON.stringify([e.severity, e.stage, e.source, e.code, e.subject, e.target, e.message]);
+/** Every finding the app reported, in the order it first appeared. A finding
+ * reported again counts up in place instead of adding a row, so a re-solve or a
+ * second export of the same case does not flood the log. */
+export class DiagnosticLog {
+    entries = $state.raw([]);
+    /** Bumped on every write, including a repeat that only moves `last`. */
+    revision = $state(0);
+    #nextId = 0;
+    #now;
+    constructor(now = Date.now) {
+        this.#now = now;
+    }
+    /** Record findings. With `repeat: false`, a finding already in the log keeps
+     * its count and takes the new details: use it for state that every solve
+     * restates, or to add the detail behind an error just recorded. */
+    record(input, options = {}) {
+        const inputs = Array.isArray(input) ? input : [input];
+        if (!inputs.length)
+            return;
+        const repeat = options.repeat ?? true;
+        const now = this.#now();
+        const next = [...this.entries];
+        const index = new Map(next.map((entry, i) => [keyOf(entry), i]));
+        for (const item of inputs) {
+            if (!item.message)
+                continue;
+            const key = keyOf(item);
+            const at = index.get(key);
+            if (at !== undefined) {
+                const previous = next[at];
+                next[at] = repeat
+                    ? { ...previous, count: previous.count + 1, last: now }
+                    : { ...previous, ...clean(item), last: now };
+                continue;
+            }
+            index.set(key, next.length);
+            next.push({
+                ...clean(item),
+                id: ++this.#nextId,
+                count: 1,
+                first: now,
+                last: now
+            });
+        }
+        this.entries = next.length > MAX_ENTRIES ? next.slice(next.length - MAX_ENTRIES) : next;
+        this.revision++;
+    }
+    clear() {
+        this.entries = [];
+        this.revision++;
+    }
+    get counts() {
+        const counts = { error: 0, warning: 0, note: 0 };
+        for (const entry of this.entries)
+            counts[entry.severity]++;
+        return counts;
+    }
+    toJSON() {
+        return {
+            format: 'tellegen.log',
+            version: 1,
+            written_at: new Date(this.#now()).toISOString(),
+            counts: this.counts,
+            entries: this.entries.map((entry) => ({
+                ...entry,
+                first: new Date(entry.first).toISOString(),
+                last: new Date(entry.last).toISOString()
+            }))
+        };
+    }
+}
+function clean(input) {
+    const out = {
+        severity: input.severity,
+        stage: input.stage,
+        source: input.source,
+        message: input.message
+    };
+    if (input.code)
+        out.code = input.code;
+    if (input.subject)
+        out.subject = input.subject;
+    if (input.target)
+        out.target = input.target;
+    if (input.buses?.length)
+        out.buses = [...input.buses];
+    if (input.hint)
+        out.hint = input.hint;
+    if (input.details && Object.keys(input.details).length)
+        out.details = input.details;
+    return out;
+}
+export function logSeverity(severity) {
+    return severity === 'error' ? 'error' : severity === 'warning' ? 'warning' : 'note';
+}
+/** A PowerIO reader or writer finding as a log entry. */
+export function powerIoEntry(d, context) {
+    return {
+        severity: logSeverity(d.severity),
+        stage: context.stage,
+        source: 'PowerIO',
+        code: d.code,
+        message: d.message,
+        subject: context.subject,
+        target: d.target,
+        hint: d.suggested_action,
+        details: d.details
+    };
+}
+// Solve findings that change what the numbers mean; the rest say how the
+// solver read the case.
+const SOLVE_WARNINGS = new Set(['island_deenergized', 'BUILD.HVDC.TERMINAL_INACTIVE']);
+/** A solver finding (islands, HVDC transfers) as a log entry. */
+export function solveEntry(d, context) {
+    return {
+        severity: SOLVE_WARNINGS.has(d.code) ? 'warning' : 'note',
+        stage: 'Solve',
+        source: 'tellegen',
+        code: d.code,
+        message: d.message,
+        subject: context.subject,
+        buses: d.buses
+    };
+}
+/** Which step an app error message comes from, by its wording. */
+export function errorStage(message) {
+    if (/export|could not save|download/i.test(message))
+        return 'Export';
+    if (/coordinat|geographic|layout|placement|placed/i.test(message))
+        return 'Coordinates';
+    if (/infeasib|converg|solv|OPF|power flow|calculation|sensitivity|webassembly|study/i.test(message))
+        return 'Solve';
+    if (/pars|read|file|format|module/i.test(message))
+        return 'Open';
+    return 'App';
+}
+/** An app error as a log entry. */
+export function errorEntry(message, detail) {
+    return {
+        severity: 'error',
+        stage: errorStage(message),
+        source: 'tellegen',
+        message,
+        details: detail ? { detail } : undefined
+    };
+}

package/dist/notices.svelte.d.ts

@@ -1,6 +1,9 @@
+import type { LogEntryInput } from './log.svelte.js';
 export interface NoticeInput {
     title: string;
     details: string;
+    /** Structured findings behind `details`; the notice lists them when present. */
+    entries?: LogEntryInput[];
     kind?: 'error' | 'warning';
     retry?: () => void;
     canRetry?: () => boolean;

package/dist/state.svelte.d.ts

@@ -1,7 +1,11 @@
 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 { DiagnosticLog } from './log.svelte.js';
+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 +121,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 +161,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 +239,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 +298,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;
@@ -303,12 +340,12 @@ export declare class AppState {
     /** Re-runs the operation behind the current `error`, when one applies. Every
      * write to `error` clears it, so a retry op can never outlive its message. */
     errorRetry: (() => void) | null;
-    /** Technical detail behind the current `error`, when the message itself is
-     * written for people; notices keep it in their disclosure. Every write to
-     * `error` clears it, as it clears `errorRetry`. */
-    errorDetail: string | null;
+    /** Every error and engine finding of this session, structured; see `DiagnosticLog`. */
+    readonly log: DiagnosticLog;
     get error(): string | null;
     set error(message: string | null);
+    get errorDetail(): string | null;
+    set errorDetail(detail: string | null);
     /** Case files parsed in the browser via the powerio wasm module. */
     localCases: LocalCase[];
     /** Local case the panel shows; clicking a bundled case or a bus clears it. */