@tellegen/svelte 0.4.4 → 0.4.6

package/README.md

@@ -180,6 +180,31 @@ it is set, `app.error` is a message written for people, and the detail holds
 the technical text behind it. `NotificationCenter` shows that text in a
 collapsed disclosure.
 
+### Log
+
+`app.log` keeps every error and engine finding of the session as structured
+entries: severity (error, warning or note), the step (`Open`, `Coordinates`,
+`Solve`, `Export`), who reported it (`PowerIO` or `tellegen`), the code, the
+message, the file or case it belongs to, the element and buses it names, and
+PowerIO's suggested action and details. The controller records what PowerIO
+reported while reading a case or a geographic layer, what each solve reported
+(islands, HVDC transfers), what each export's writer reported, and every
+`app.error`. A finding reported again counts up in place.
+
+`DiagnosticLogView` (from `@tellegen/svelte/components`) shows the log grouped
+by step and file, with severity filters, Copy, Download (`tellegen.log` JSON)
+and Clear; pass `onbus` to make the named buses selectable. The default shell
+shows it in a "Log" panel (`LogPanel`). A host can add its own findings:
+
+```ts
+getAppState().log.record({
+	severity: 'warning',
+	stage: 'Fetch',
+	source: 'Overpass',
+	message: 'overpass-api.de answered 504; trying the next mirror'
+});
+```
+
 ## Basemap
 
 CARTO's vector styles suit a network overlay best: quiet roads, flat land and

package/dist/TellegenMap.svelte

@@ -844,17 +844,26 @@
 	// maplibre's own WebGL2 context instead of a second canvas, so the page
 	// holds one GL context rather than two. Safari evicts WebGL contexts under
 	// memory and tab pressure, and one context survives that far better; the
-	// deck layers also inherit maplibre's 4096 canvas clamp. The flat positron
-	// basemap writes no depth, so the overlay always draws on top.
-	function buildOverlay(MapLibreOverlay: MapModules['MapLibreOverlay']): MapLibreOverlay {
+	// deck layers also inherit maplibre's 4096 canvas clamp. The flat basemap
+	// writes no depth, so on the flat map the overlay always draws on top. On
+	// the globe it tests against the depth maplibre writes for the earth, so a
+	// network on the far hemisphere hides behind it instead of showing through.
+	function overlayParameters(type: MapProjection) {
+		return {
+			depthWriteEnabled: false,
+			depthCompare: type === 'globe' ? ('less-equal' as const) : ('always' as const)
+		};
+	}
+
+	function buildOverlay(
+		MapLibreOverlay: MapModules['MapLibreOverlay'],
+		type: MapProjection
+	): MapLibreOverlay {
 		const touch = coarsePointer();
 		return new MapLibreOverlay({
 			interleaved: true,
 			layers: [],
-			parameters: {
-				depthWriteEnabled: false,
-				depthCompare: 'always'
-			},
+			parameters: overlayParameters(type),
 			// a small bus draws ~9px across, well under a fingertip
 			pickingRadius: touch ? 12 : 0,
 			onClick: (info: PickingInfo) => {
@@ -915,7 +924,10 @@
 					onFallback: (reason) => onBasemapFallback?.(reason),
 					onFailure: (reason) => onBasemapError?.(reason)
 				});
-				const o = buildOverlay(MapLibreOverlay);
+				const o = buildOverlay(
+					MapLibreOverlay,
+					untrack(() => projection)
+				);
 				m.addControl(o);
 				m.on('click', (e) => {
 					if (app.placingId) onplacecase(e.lngLat.lng, e.lngLat.lat);
@@ -1057,6 +1069,7 @@
 	// MapLibre throws, and the `style.load` handler above applies it instead.
 	$effect(() => {
 		const type = projection;
+		overlay?.setProps({ parameters: overlayParameters(type) });
 		const m = map;
 		if (!m) return;
 		try {

package/dist/TellegenShell.svelte

@@ -9,6 +9,7 @@
 	import RestoreDefaultsButton from './components/RestoreDefaultsButton.svelte';
 	import SolveCard from './components/SolveCard.svelte';
 	import PanelHost from './components/PanelHost.svelte';
+	import LogPanel from './components/LogPanel.svelte';
 	import ShellEnvironment from './components/ShellEnvironment.svelte';
 	import { getAppState, getController, getUiConfig } from './context.svelte.js';
 	import TellegenMap from './TellegenMap.svelte';
@@ -120,6 +121,7 @@
 	<NotificationCenter />
 	<ControlPanel />
 	<SolveCard />
+	<LogPanel />
 	{#if !app.studyView}
 		<DropZone />
 		<PlacementCue />

package/dist/components/DiagnosticLogView.svelte

@@ -0,0 +1,176 @@
+<script lang="ts">
+	import { getAppState } from '../context.svelte.js';
+	import { downloadText } from '../controller.svelte.js';
+	import {
+		LOG_SEVERITIES,
+		type DiagnosticLog,
+		type LogEntry,
+		type LogEntryInput,
+		type LogSeverity
+	} from '../log.svelte.js';
+	import LogEntryView from './LogEntryView.svelte';
+	let {
+		log = getAppState().log,
+		onbus,
+		filename = 'tellegen-log.json',
+		empty = 'Nothing to report. Findings from opening, solving and exporting a case appear here.'
+	}: {
+		log?: DiagnosticLog;
+		/** Makes each named bus a button, for a host that can select it. */
+		onbus?: (bus: number, entry: LogEntryInput) => void;
+		filename?: string;
+		empty?: string;
+	} = $props();
+	const PLURAL = { error: 'Errors', warning: 'Warnings', note: 'Notes' } as const;
+	let filter = $state<LogSeverity | 'all'>('all');
+	let copied = $state(false);
+	const counts = $derived(log.counts);
+	const shown = $derived(
+		filter === 'all' ? log.entries : log.entries.filter((e) => e.severity === filter)
+	);
+	// One group per step and subject, in the order each first appeared.
+	const groups = $derived.by(() => {
+		const out = new Map<string, { stage: string; subject?: string; entries: LogEntry[] }>();
+		for (const entry of shown) {
+			const key = `${entry.stage}\u0000${entry.subject ?? ''}`;
+			let group = out.get(key);
+			if (!group)
+				out.set(key, (group = { stage: entry.stage, subject: entry.subject, entries: [] }));
+			group.entries.push(entry);
+		}
+		return [...out.values()];
+	});
+	$effect(() => {
+		if (filter !== 'all' && counts[filter] === 0) filter = 'all';
+	});
+	const text = () => JSON.stringify(log.toJSON(), null, 2);
+	async function copy() {
+		try {
+			await navigator.clipboard.writeText(text());
+			copied = true;
+			setTimeout(() => (copied = false), 1600);
+		} catch {
+			copied = false;
+		}
+	}
+</script>
+
+<section class="log" aria-label="Log" data-testid="diagnostic-log">
+	{#if log.entries.length}
+		<div class="toolbar">
+			<div class="filters" role="group" aria-label="Show">
+				<button type="button" aria-pressed={filter === 'all'} onclick={() => (filter = 'all')}
+					>All <span class="n">{log.entries.length}</span></button
+				>
+				{#each LOG_SEVERITIES as severity (severity)}
+					{#if counts[severity]}
+						<button
+							type="button"
+							data-severity={severity}
+							aria-pressed={filter === severity}
+							onclick={() => (filter = severity)}
+							>{PLURAL[severity]} <span class="n">{counts[severity]}</span></button
+						>
+					{/if}
+				{/each}
+			</div>
+			<div class="actions">
+				<button type="button" onclick={copy}>{copied ? 'Copied' : 'Copy'}</button>
+				<button type="button" onclick={() => downloadText(text(), filename, 'application/json')}
+					>Download</button
+				>
+				<button type="button" onclick={() => log.clear()}>Clear</button>
+			</div>
+		</div>
+		{#each groups as group (`${group.stage}\u0000${group.subject ?? ''}`)}
+			<section class="group" data-stage={group.stage}>
+				<h4>
+					<span class="stage">{group.stage}</span>{#if group.subject}<span class="subject"
+							>{group.subject}</span
+						>{/if}
+				</h4>
+				<ol>
+					{#each group.entries as entry (entry.id)}
+						<li><LogEntryView {entry} showSubject={false} {onbus} /></li>
+					{/each}
+				</ol>
+			</section>
+		{/each}
+	{:else}
+		<p class="empty">{empty}</p>
+	{/if}
+</section>
+
+<style>
+	.log {
+		font: var(--fs-meta, 12px) / 1.45 var(--font-display);
+		color: var(--text-primary, var(--ink));
+	}
+	.toolbar {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: center;
+		justify-content: space-between;
+		gap: 6px;
+		margin-bottom: 8px;
+	}
+	.filters,
+	.actions {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 4px;
+	}
+	button {
+		font: inherit;
+		color: var(--ink);
+		border: 1px solid var(--line);
+		background: transparent;
+		padding: 3px 8px;
+		border-radius: 3px;
+		cursor: pointer;
+	}
+	button:hover {
+		background: var(--accent-soft);
+	}
+	button[aria-pressed='true'] {
+		background: var(--accent-soft);
+		border-color: var(--border-strong, var(--line));
+	}
+	button:focus-visible {
+		outline: 2px solid var(--focus-ring);
+		outline-offset: 2px;
+	}
+	.n {
+		font: 10px var(--font-mono);
+		color: var(--text-secondary);
+	}
+	.group + .group {
+		margin-top: 10px;
+	}
+	h4 {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 6px;
+		align-items: baseline;
+		margin: 0 0 4px;
+		font: 600 var(--fs-meta, 12px) / 1.4 var(--font-display);
+	}
+	.subject {
+		font-weight: 400;
+		color: var(--text-secondary);
+		overflow-wrap: anywhere;
+	}
+	ol {
+		list-style: none;
+		margin: 0;
+		padding: 0;
+	}
+	li {
+		padding: 6px 0;
+		border-top: 1px solid var(--line);
+	}
+	.empty {
+		margin: 0;
+		color: var(--text-secondary);
+	}
+</style>

package/dist/components/DiagnosticLogView.svelte.d.ts

@@ -0,0 +1,11 @@
+import { type DiagnosticLog, type LogEntryInput } from '../log.svelte.js';
+type $$ComponentProps = {
+    log?: DiagnosticLog;
+    /** Makes each named bus a button, for a host that can select it. */
+    onbus?: (bus: number, entry: LogEntryInput) => void;
+    filename?: string;
+    empty?: string;
+};
+declare const DiagnosticLogView: import("svelte").Component<$$ComponentProps, {}, "">;
+type DiagnosticLogView = ReturnType<typeof DiagnosticLogView>;
+export default DiagnosticLogView;

package/dist/components/LogEntryView.svelte

@@ -0,0 +1,188 @@
+<script lang="ts">
+	import type { LogEntry, LogEntryInput } from '../log.svelte.js';
+	let {
+		entry,
+		showSubject = true,
+		onbus
+	}: {
+		entry: LogEntryInput | LogEntry;
+		/** Off inside a group that already names the subject. */
+		showSubject?: boolean;
+		/** Makes each named bus a button, for a host that can select it. */
+		onbus?: (bus: number, entry: LogEntryInput) => void;
+	} = $props();
+	const LABEL = { error: 'Error', warning: 'Warning', note: 'Note' } as const;
+	const MAX_BUSES = 12;
+	const count = $derived('count' in entry ? entry.count : 1);
+	const buses = $derived(entry.buses ?? []);
+	const details = $derived(
+		Object.entries(entry.details ?? {}).map(
+			([key, value]) => [key, typeof value === 'string' ? value : JSON.stringify(value)] as const
+		)
+	);
+</script>
+
+<div class="entry" data-severity={entry.severity} data-testid="log-entry">
+	<span class="severity">{LABEL[entry.severity]}</span>
+	<div class="body">
+		<p class="message">
+			{entry.message}{#if count > 1}<span class="count" aria-label={`reported ${count} times`}
+					>{count}×</span
+				>{/if}
+		</p>
+		<dl class="meta">
+			<div>
+				<dt>From</dt>
+				<dd>{entry.source}</dd>
+			</div>
+			{#if entry.code}<div>
+					<dt>Code</dt>
+					<dd class="mono">{entry.code}</dd>
+				</div>{/if}
+			{#if showSubject && entry.subject}<div>
+					<dt>In</dt>
+					<dd>{entry.subject}</dd>
+				</div>{/if}
+			{#if entry.target}<div>
+					<dt>Element</dt>
+					<dd class="mono">{entry.target}</dd>
+				</div>{/if}
+		</dl>
+		{#if buses.length}
+			<p class="buses">
+				<span class="label">{buses.length === 1 ? 'Bus' : 'Buses'}</span>
+				{#each buses.slice(0, MAX_BUSES) as bus (bus)}
+					{#if onbus}<button type="button" onclick={() => onbus(bus, entry)}>{bus}</button
+						>{:else}<span class="bus">{bus}</span>{/if}
+				{/each}
+				{#if buses.length > MAX_BUSES}<span class="more">and {buses.length - MAX_BUSES} more</span
+					>{/if}
+			</p>
+		{/if}
+		{#if entry.hint}<p class="hint">{entry.hint}</p>{/if}
+		{#if details.length}
+			<details>
+				<summary>Details</summary>
+				<dl class="details">
+					{#each details as [key, value] (key)}
+						<div>
+							<dt class="mono">{key}</dt>
+							<dd class="mono">{value}</dd>
+						</div>
+					{/each}
+				</dl>
+			</details>
+		{/if}
+	</div>
+</div>
+
+<style>
+	.entry {
+		--log-warning: #8a5300;
+		display: grid;
+		grid-template-columns: 62px minmax(0, 1fr);
+		gap: 8px;
+		font: var(--fs-meta, 12px) / 1.45 var(--font-display);
+		color: var(--text-primary, var(--ink));
+	}
+	:global(:root[data-theme='dark']) .entry {
+		--log-warning: #f0c36d;
+	}
+	.severity {
+		font: 600 10px/1.9 var(--font-mono);
+		text-transform: uppercase;
+		letter-spacing: 0.04em;
+		color: var(--text-secondary);
+	}
+	[data-severity='error'] .severity {
+		color: var(--text-danger, var(--red));
+	}
+	[data-severity='warning'] .severity {
+		color: var(--log-warning);
+	}
+	.body {
+		min-width: 0;
+	}
+	p {
+		margin: 0;
+	}
+	.message {
+		overflow-wrap: anywhere;
+	}
+	.count {
+		margin-left: 6px;
+		font: 10px var(--font-mono);
+		color: var(--text-secondary);
+	}
+	.meta {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 2px 12px;
+		margin: 3px 0 0;
+		color: var(--text-secondary);
+	}
+	.meta div,
+	.details div {
+		display: flex;
+		gap: 4px;
+		min-width: 0;
+	}
+	dt {
+		color: var(--text-tertiary, var(--text-secondary));
+	}
+	dd {
+		margin: 0;
+		overflow-wrap: anywhere;
+	}
+	.mono {
+		font-family: var(--font-mono);
+		font-size: 11px;
+	}
+	.buses {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: center;
+		gap: 4px;
+		margin-top: 4px;
+	}
+	.label,
+	.more {
+		color: var(--text-secondary);
+	}
+	.bus,
+	.buses button {
+		font: 11px var(--font-mono);
+		padding: 1px 6px;
+		border-radius: 3px;
+		background: var(--surface-chip, var(--accent-soft));
+		color: inherit;
+		border: 0;
+	}
+	.buses button {
+		cursor: pointer;
+	}
+	.buses button:hover {
+		background: var(--accent-soft);
+	}
+	.buses button:focus-visible,
+	summary:focus-visible {
+		outline: 2px solid var(--focus-ring);
+		outline-offset: 2px;
+	}
+	.hint {
+		margin-top: 4px;
+		color: var(--text-secondary);
+	}
+	details {
+		margin-top: 4px;
+	}
+	summary {
+		cursor: pointer;
+		color: var(--text-secondary);
+	}
+	.details {
+		display: grid;
+		gap: 2px;
+		margin: 4px 0 0;
+	}
+</style>

package/dist/components/LogEntryView.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { LogEntry, LogEntryInput } from '../log.svelte.js';
+type $$ComponentProps = {
+    entry: LogEntryInput | LogEntry;
+    /** Off inside a group that already names the subject. */
+    showSubject?: boolean;
+    /** Makes each named bus a button, for a host that can select it. */
+    onbus?: (bus: number, entry: LogEntryInput) => void;
+};
+declare const LogEntryView: import("svelte").Component<$$ComponentProps, {}, "">;
+type LogEntryView = ReturnType<typeof LogEntryView>;
+export default LogEntryView;

package/dist/components/LogPanel.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	import { getAppState, getController } from '../context.svelte.js';
+	import DiagnosticLogView from './DiagnosticLogView.svelte';
+	import PanelFrame from './PanelFrame.svelte';
+	const app = getAppState();
+	const ctrl = getController();
+	let open = $state(false);
+	// A bus named in a finding selects that bus on the case on screen.
+	function selectBus(bus: number) {
+		if (app.activeLocal) void ctrl.selectLocalBus(app.activeLocal.id, bus);
+		else if (app.activeCaseId) ctrl.selectBus(app.activeCaseId, bus);
+	}
+</script>
+
+<PanelFrame id="log" title="Log" side="right" order={40} width={360} bind:open>
+	<div class="log-body">
+		<DiagnosticLogView onbus={selectBus} />
+	</div>
+</PanelFrame>
+
+<style>
+	.log-body {
+		padding: 12px 14px;
+	}
+</style>

package/dist/components/LogPanel.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const LogPanel: import("svelte").Component<Record<string, never>, {}, "">;
+type LogPanel = ReturnType<typeof LogPanel>;
+export default LogPanel;

package/dist/components/NotificationCenter.svelte

@@ -2,7 +2,9 @@
 	import { onDestroy, untrack } from 'svelte';
 	import { formatPowerIoDiagnostic } from '@tellegen/engine';
 	import { getAppState, getController } from '../context.svelte.js';
+	import { powerIoEntry, type LogEntryInput } from '../log.svelte.js';
 	import { getNoticeCenter, errorNoticeTitle } from '../notices.svelte.js';
+	import LogEntryView from './LogEntryView.svelte';
 	const app = getAppState();
 	const ctrl = getController();
 	const notices = getNoticeCenter();
@@ -33,7 +35,20 @@
 		const multi = app.activeMulti;
 		const summary = local?.summary ?? multi?.summary;
 		const geo = local?.geoWarnings ?? multi?.geoWarnings;
-		for (const [identity, title, details] of [
+		const subject = local?.fileName ?? multi?.fileName;
+		const entries: LogEntryInput[] = summary
+			? [
+					...summary.diagnostics.map((d) => powerIoEntry(d, { stage: 'Open', subject })),
+					...('warnings' in summary ? summary.warnings : []).map((message) => ({
+						severity: 'note' as const,
+						stage: 'Open',
+						source: 'tellegen',
+						subject,
+						message
+					}))
+				]
+			: [];
+		for (const [identity, title, details, items] of [
 			[
 				summary,
 				'Case import notes',
@@ -42,13 +57,15 @@
 							...summary.diagnostics.map(formatPowerIoDiagnostic),
 							...('warnings' in summary ? summary.warnings : [])
 						].join('\n\n')
-					: ''
+					: '',
+				entries
 			],
-			[geo, 'Coordinate import notes', geo?.join('\n\n') ?? '']
-		] as Array<[object | undefined, string, string]>) {
+			[geo, 'Coordinate import notes', geo?.join('\n\n') ?? '', undefined]
+		] as Array<[object | undefined, string, string, LogEntryInput[] | undefined]>) {
 			if (identity && !observed.has(identity)) {
 				observed.add(identity);
-				if (details) untrack(() => notices.push({ kind: 'warning', title, details }));
+				if (details)
+					untrack(() => notices.push({ kind: 'warning', title, details, entries: items }));
 			}
 		}
 	});
@@ -92,7 +109,15 @@
 									>{entry.title}{#if entry.count > 1}<span class="count">{entry.count}</span
 										>{/if}</summary
 								>
-								<pre data-testid="notification-details">{entry.details}</pre>
+								{#if entry.entries?.length}
+									<ol class="entries" data-testid="notification-details">
+										{#each entry.entries as item, i (i)}
+											<li><LogEntryView entry={item} showSubject={false} /></li>
+										{/each}
+									</ol>
+								{:else}
+									<pre data-testid="notification-details">{entry.details}</pre>
+								{/if}
 							</details>
 							{#if entry.retry && entry.canRetry?.()}<button onclick={entry.retry}>Retry</button
 								>{/if}
@@ -227,6 +252,12 @@
 	summary {
 		cursor: pointer;
 	}
+	.entries {
+		margin-top: 8px;
+	}
+	.entries li {
+		padding: 6px 0;
+	}
 	pre {
 		font: 11px/1.5 var(--font-mono);
 		white-space: pre-wrap;

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

@@ -59,7 +59,7 @@ export declare class SchematicText {
         level: string;
         wires: string;
         loading: string | null;
-        state: "normal" | "warning" | "violation";
+        state: "warning" | "normal" | "violation";
     }[];
     /** Rows of a bus stack's card. */
     stackRows(members: number[]): {

package/dist/components.d.ts

@@ -1,6 +1,9 @@
 export { default as ModelDetails } from './components/ModelDetails.svelte';
 export { default as AppFooter } from './components/AppFooter.svelte';
 export { default as NotificationCenter } from './components/NotificationCenter.svelte';
+export { default as DiagnosticLogView } from './components/DiagnosticLogView.svelte';
+export { default as LogEntryView } from './components/LogEntryView.svelte';
+export { default as LogPanel } from './components/LogPanel.svelte';
 export { default as PanelHost } from './components/PanelHost.svelte';
 export { default as ShellEnvironment } from './components/ShellEnvironment.svelte';
 export { default as AppHeader } from './components/AppHeader.svelte';

package/dist/components.js

@@ -1,6 +1,9 @@
 export { default as ModelDetails } from './components/ModelDetails.svelte';
 export { default as AppFooter } from './components/AppFooter.svelte';
 export { default as NotificationCenter } from './components/NotificationCenter.svelte';
+export { default as DiagnosticLogView } from './components/DiagnosticLogView.svelte';
+export { default as LogEntryView } from './components/LogEntryView.svelte';
+export { default as LogPanel } from './components/LogPanel.svelte';
 export { default as PanelHost } from './components/PanelHost.svelte';
 export { default as ShellEnvironment } from './components/ShellEnvironment.svelte';
 export { default as AppHeader } from './components/AppHeader.svelte';

package/dist/controller.svelte.d.ts

@@ -20,6 +20,9 @@ type SavedCaseCapture = {
 export declare function isDisplayOnlyElement(element: {
     editable?: boolean;
 } | null | undefined): boolean;
+/** Trigger a browser download of in-memory text. Case files never leave the machine:
+ * a save is a local Blob download. */
+export declare function downloadText(text: string, filename: string, mime: string): void;
 export type { SolvableCase };
 type DemandRangeAnchor = {
     caseId: string;
@@ -416,6 +419,10 @@ export declare class Controller {
     caseGeographyLayers(c: LocalCase): Promise<string[]>;
     /** Capture a matching cached result without constructing or solving a model. */
     captureSavedCase(c: SolvableCase): Promise<SavedCaseCapture>;
+    /** Record what PowerIO and the engine said while reading a case file. */
+    private logImport;
+    /** Record a geographic layer's reader findings and placement notes. */
+    private logCoordinates;
     /** Build a local case from a balanced PowerIO ingest payload without activating
      * it yet; co-dropped placement data is applied before the first solve. */
     private localFromBalancedPayload;

package/dist/controller.svelte.js

@@ -3,6 +3,7 @@ import { previewScaleFor, scalarDomain, sensFlatColor, sensitivityDomain } from
 import { caseDeltas as sharedCaseDeltas, caseRatings as sharedCaseRatings, displayMetaFor, displaySeriesFor } from './display.js';
 import { CaseState, LocalCase, MulticonductorCase } from './state.svelte.js';
 import { placeSyntheticTopology } from './synthetic-layout.js';
+import { powerIoEntry, solveEntry } from './log.svelte.js';
 import { distExtensionFormat, isGeoFileName } from './drop-classify.js';
 import { DropBatchGate, readDropFileBytes, validateDropBatch } from './drop-limits.js';
 import { buildGeographicView, buildDiagramView, placeMultiView } from './multiconductor.js';
@@ -52,7 +53,7 @@ function delayUntilFocusSettles(ms, signal) {
 }
 /** Trigger a browser download of in-memory text. Case files never leave the machine:
  * a save is a local Blob download. */
-function downloadText(text, filename, mime) {
+export function downloadText(text, filename, mime) {
     const url = URL.createObjectURL(new Blob([text], { type: mime }));
     const anchor = document.createElement('a');
     anchor.href = url;
@@ -443,6 +444,10 @@ export class Controller {
         if (seq !== (c.solveSeq ?? 0))
             return;
         c.solving = false;
+        // Every solve of a case restates the same findings; they count once.
+        const findings = c.solution?.diagnostics ?? [];
+        if (findings.length)
+            this.app.log.record(findings.map((d) => solveEntry(d, { subject: this.caseName(c) })), { repeat: false });
         const selectionLive = target !== null &&
             this.isActiveSolveCase(c) &&
             ('bus' in target
@@ -1019,6 +1024,7 @@ export class Controller {
             routes += payload.report.matched_branches;
             unmatched += payload.report.unmatched_features;
             warnings.push(...l.diagnostics.map((d) => `${l.name}: ${formatPowerIoDiagnostic(d)}`), ...payload.report.notes.map((n) => `${l.name}: ${n}`));
+            this.logCoordinates(l.name, l.diagnostics, payload.report.notes);
         }
         if (!payload)
             return;
@@ -2043,6 +2049,7 @@ export class Controller {
                 const label = summary.name && summary.name !== 'case'
                     ? summary.name
                     : file.name.replace(/\.[^.]+$/, '');
+                this.logImport(file.name, summary);
                 const local = new LocalCase({
                     id,
                     label,
@@ -2242,6 +2249,7 @@ export class Controller {
         const view = coordsKind === 'geographic'
             ? buildGeographicView(graph, payload.geo_layer)
             : buildDiagramView(graph, payload.geo_layer);
+        this.logImport(fileName, summary);
         const c = new MulticonductorCase({
             id: `dist-${++this.localSeq}`,
             label,
@@ -2517,6 +2525,7 @@ export class Controller {
             next = payload.module_json;
             matched += payload.report.matched_buses + payload.report.matched_branches;
             notes.push(`${payload.report.matched_buses} buses, ${payload.report.matched_branches} routes matched; ${payload.report.unmatched_features} unmatched objects`, ...payload.report.notes, ...layer.diagnostics.map(formatPowerIoDiagnostic));
+            this.logCoordinates(layer.name, layer.diagnostics, payload.report.notes);
         }
         if (!payload || !matched)
             throw new Error('No coordinates matched the selected case');
@@ -2743,7 +2752,13 @@ export class Controller {
             ...placeSyntheticTopology(c.topology, { lon: 0, lat: 0 }),
             coordinate_space: 'diagram'
         };
-        return { id: 'study', name: c.name, base_mva: c.base_mva, synthetic_coords: !c.view, ...view };
+        return {
+            id: 'study',
+            name: c.name,
+            base_mva: c.base_mva,
+            synthetic_coords: !c.view,
+            ...view
+        };
     }
     async caseGeographyLayers(c) {
         if (!c.studyInputJson || !c.view)
@@ -2781,15 +2796,46 @@ export class Controller {
             if (snapshot.base_input !== base ||
                 JSON.stringify(snapshot.display_solution) !== JSON.stringify(c.solution))
                 throw new Error('The server case changed. Reload it before saving.');
-            return { input: snapshot.input, solution: snapshot.solution, view: snapshot.view };
+            return {
+                input: snapshot.input,
+                solution: snapshot.solution,
+                view: snapshot.view
+            };
         }
         return { input: base };
     }
+    /** Record what PowerIO and the engine said while reading a case file. */
+    logImport(fileName, summary) {
+        this.app.log.record([
+            ...(summary.diagnostics ?? []).map((d) => powerIoEntry(d, { stage: 'Open', subject: fileName })),
+            ...(summary.warnings ?? []).map((message) => ({
+                severity: 'note',
+                stage: 'Open',
+                source: 'tellegen',
+                subject: fileName,
+                message
+            }))
+        ]);
+    }
+    /** Record a geographic layer's reader findings and placement notes. */
+    logCoordinates(layer, diagnostics, notes) {
+        this.app.log.record([
+            ...(diagnostics ?? []).map((d) => powerIoEntry(d, { stage: 'Coordinates', subject: layer })),
+            ...(notes ?? []).map((message) => ({
+                severity: 'note',
+                stage: 'Coordinates',
+                source: 'tellegen',
+                subject: layer,
+                message
+            }))
+        ]);
+    }
     /** Build a local case from a balanced PowerIO ingest payload without activating
      * it yet; co-dropped placement data is applied before the first solve. */
     localFromBalancedPayload = (fileName, payload) => {
         const { module_json, topology, view, formulation, ...summary } = payload;
         const label = summary.name && summary.name !== 'case' ? summary.name : fileName.replace(/\.[^.]+$/, '');
+        this.logImport(fileName, summary);
         return new LocalCase({
             id: `local-${++this.localSeq}`,
             label,
@@ -2832,7 +2878,11 @@ export class Controller {
                 local.formulation = input.formulation;
             if (input.geoLayer) {
                 await this.applyGeoLayers(local, [
-                    { name: `${input.name}.geo.json`, layer: input.geoLayer, diagnostics: [] }
+                    {
+                        name: `${input.name}.geo.json`,
+                        layer: input.geoLayer,
+                        diagnostics: []
+                    }
                 ]);
             }
             this.placeTopologyAsDiagram(local);
@@ -2940,8 +2990,10 @@ export class Controller {
             return [];
         try {
             const exported = await study.export(format);
-            downloadText(exported.text, `${this.caseFileStem(c)}.${exported.extension}`, 'text/plain');
+            const fileName = `${this.caseFileStem(c)}.${exported.extension}`;
+            downloadText(exported.text, fileName, 'text/plain');
             this.app.error = null;
+            this.app.log.record((exported.diagnostics ?? []).map((d) => powerIoEntry(d, { stage: 'Export', subject: fileName })), { repeat: false });
             return exported.diagnostics;
         }
         catch (e) {

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';

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';

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,6 +1,7 @@
 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';
+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';
@@ -339,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. */

package/dist/state.svelte.js

@@ -1,4 +1,5 @@
 import { DEFAULT_FORMULATION } from '@tellegen/engine';
+import { DiagnosticLog, errorEntry } from './log.svelte.js';
 import { graphInputs } from './diagram/graph-inputs.js';
 import { buildSearchIndex } from './diagram/search.js';
 import { snapshotFromMcPf } from './diagram/snapshot.js';
@@ -248,7 +249,11 @@ export class AppState {
             throw new Error('Invalid saved drawing view');
         }
         this.settleFrame();
-        this.diagramCameraRequest = { caseId, center: [...snapshot.center], scale: snapshot.scale };
+        this.diagramCameraRequest = {
+            caseId,
+            center: [...snapshot.center],
+            scale: snapshot.scale
+        };
         this.diagramCameraSeq++;
     }
     requestCamera(snapshot) {
@@ -297,16 +302,28 @@ export class AppState {
     /** 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 = $state(null);
+    #errorDetail = $state(null);
+    /** Every error and engine finding of this session, structured; see `DiagnosticLog`. */
+    log = new DiagnosticLog();
     get error() {
         return this.#error;
     }
     set error(message) {
         this.#error = message;
-        if (message)
+        if (message) {
             this.errorRevision++;
+            this.log.record(errorEntry(message));
+        }
         this.errorRetry = null;
-        this.errorDetail = null;
+        this.#errorDetail = null;
+    }
+    get errorDetail() {
+        return this.#errorDetail;
+    }
+    set errorDetail(detail) {
+        this.#errorDetail = detail;
+        if (detail && this.#error)
+            this.log.record(errorEntry(this.#error, detail), { repeat: false });
     }
     /** Case files parsed in the browser via the powerio wasm module. */
     localCases = $state.raw([]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tellegen/svelte",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Svelte components for tellegen power system maps, local case files, and browser solves.",
   "keywords": [
     "svelte",
@@ -67,7 +67,7 @@
     "pack:dry-run": "npm pack --dry-run --cache ../../node_modules/.cache/npm-pack"
   },
   "dependencies": {
-    "@tellegen/engine": "^0.4.3"
+    "@tellegen/engine": "^0.4.6"
   },
   "peerDependencies": {
     "@deck.gl/core": "^9.4.0",