@tellegen/svelte 0.1.2 → 0.3.0

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

@@ -16,4 +16,3 @@ declare const SizeLegend: $$__sveltets_2_IsomorphicComponent<Record<string, neve
 }, {}, {}, string>;
 type SizeLegend = InstanceType<typeof SizeLegend>;
 export default SizeLegend;
-//# sourceMappingURL=SizeLegend.svelte.d.ts.map

package/dist/components/SolveCard.svelte

@@ -1,56 +1,63 @@
 <script lang="ts">
-	import { getController } from '../context.svelte.js';
+	import { getAppState, getController } from '../context.svelte.js';
 	import { formulationLabel, solveMetaLabel } from '../format.js';
 	import Sparkline from '../Sparkline.svelte';
+	import PanelFrame from './PanelFrame.svelte';
+	let open = $state(true);
 
 	const ctrl = getController();
+	const app = getAppState();
+	const saved = $derived(app.studyView);
 	const active = $derived(ctrl.activeSolvable);
-	const iterations = $derived(active?.iterations ?? []);
+	const iterations = $derived(
+		saved
+			? Array.isArray(saved.solution?.iterations)
+				? saved.solution.iterations
+				: []
+			: (active?.iterations ?? [])
+	);
 </script>
 
-{#if active && (active.solving || active.solveMs != null)}
-	<div class="solvecard">
-		<div class="solvecard-head mono">
-			<span><b>OPF solve</b></span>
+{#if saved || (active && (active.solving || active.solveMs != null))}
+	<PanelFrame id="solver" title="Solver" side="right" order={10} width={320} bind:open>
+		<div class="solvecard">
+			<div class="solve-label mono">
+				{saved ? 'Saved result' : active?.formulation === 'acpf' ? 'Power flow' : 'OPF solve'}
+			</div>
+			{#if iterations.length > 1}
+				{#key iterations}
+					<Sparkline {iterations} />
+				{/key}
+			{/if}
+			{#if saved}
+				<div class="solve-meta mono dim">
+					<span class="solve-formulation">{formulationLabel(saved.formulation)}</span>
+					<span>{saved.solution?.status ?? 'Not solved'}</span>
+					<span>Saved state: {saved.label}</span>
+				</div>
+			{:else if active}
+				<div class="solve-meta mono dim">
+					<span class="solve-formulation">{formulationLabel(active.formulation)}</span>
+					<span>{solveMetaLabel(active)}</span>
+					{#if active.solveMs != null}<span>{active.solveMs} ms</span>{/if}
+				</div>
+				{#if active.solveBackend === 'rust-server' && active.solveFallbackReason}
+					<p class="fallback-reason mono dim" title={active.solveFallbackReason}>
+						fallback: {active.solveFallbackReason}
+					</p>
+				{/if}
+			{/if}
 		</div>
-		{#if iterations.length > 1}
-			{#key iterations}
-				<Sparkline {iterations} />
-			{/key}
-		{/if}
-		<div class="solve-meta mono dim">
-			<span class="solve-formulation">{formulationLabel(active.formulation)}</span>
-			<span>{solveMetaLabel(active)}</span>
-			{#if active.solveMs != null}<span>{active.solveMs} ms</span>{/if}
-		</div>
-		{#if active.solveBackend === 'rust-server' && active.solveFallbackReason}
-			<p class="fallback-reason mono dim" title={active.solveFallbackReason}>
-				fallback: {active.solveFallbackReason}
-			</p>
-		{/if}
-	</div>
+	</PanelFrame>
 {/if}
 
 <style>
+	.solve-label {
+		font-size: 11px;
+		margin-bottom: 8px;
+	}
 	.solvecard {
-		position: absolute;
-		top: 76px;
-		right: 20px;
-		z-index: 10;
-		width: 300px;
 		padding: 13px 15px 11px;
-		background: var(--panel);
-		border: 1px solid var(--line);
-		border-radius: 3px;
-		backdrop-filter: blur(6px);
-		box-shadow: 0 4px 24px rgba(32, 36, 43, 0.08);
-		animation: rise 0.3s ease-out both;
-	}
-
-	.solvecard-head {
-		font-size: 10.5px;
-		margin-bottom: 6px;
-		white-space: nowrap;
 	}
 
 	.solve-meta {
@@ -72,14 +79,4 @@
 		line-height: 1.35;
 		overflow-wrap: anywhere;
 	}
-
-	@media (max-width: 760px) {
-		.solvecard {
-			/* just clear of the header's case tabs */
-			top: 108px;
-			left: auto;
-			right: 10px;
-			width: min(300px, calc(100% - 20px));
-		}
-	}
 </style>

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

@@ -1,4 +1,3 @@
 declare const SolveCard: import("svelte").Component<Record<string, never>, {}, "">;
 type SolveCard = ReturnType<typeof SolveCard>;
 export default SolveCard;
-//# sourceMappingURL=SolveCard.svelte.d.ts.map

package/dist/components/TopMovers.svelte

@@ -3,15 +3,20 @@
 	import { signedExp } from '../format.js';
 
 	const ctrl = getController();
-	const unitTitle =
-		'LMP is measured in $/MWh and demand is perturbed in MW, so dLMP/dd has units ($/MWh)/MW.';
+	const units = $derived(
+		(ctrl.selectedSensitivity?.units ?? '(objective units/MW)/MW').replaceAll(
+			'objective_unit',
+			'objective units'
+		)
+	);
+	const unitTitle = $derived(`LMP response per MW of demand, in ${units}.`);
 </script>
 
 <div class="movers-block">
 	{#if !ctrl.previewing && ctrl.topMovers.length > 0}
 		<table class="mono">
 			<caption class="mono dim" title={unitTitle}>
-				largest &Delta;LMP per MW demand <span class="unit">($/MWh)/MW</span>
+				largest LMP response <span class="unit">{units}</span>
 			</caption>
 			<tbody>
 				{#each ctrl.topMovers as mover (mover.bus)}

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

@@ -1,19 +1,3 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const TopMovers: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type TopMovers = InstanceType<typeof TopMovers>;
+declare const TopMovers: import("svelte").Component<Record<string, never>, {}, "">;
+type TopMovers = ReturnType<typeof TopMovers>;
 export default TopMovers;
-//# sourceMappingURL=TopMovers.svelte.d.ts.map

package/dist/components.d.ts

@@ -1,3 +1,4 @@
+export { default as ModelDetails } from './components/ModelDetails.svelte';
 export { default as AppFooter } from './components/AppFooter.svelte';
 export { default as AppHeader } from './components/AppHeader.svelte';
 export { default as BusPicker } from './components/BusPicker.svelte';
@@ -16,4 +17,4 @@ export { default as SizeLegend } from './components/SizeLegend.svelte';
 export { default as SolveCard } from './components/SolveCard.svelte';
 export { default as TopMovers } from './components/TopMovers.svelte';
 export { default as Sparkline } from './Sparkline.svelte';
-//# sourceMappingURL=components.d.ts.map
+export { default as McResults } from './components/McResults.svelte';

package/dist/components.js

@@ -1,3 +1,4 @@
+export { default as ModelDetails } from './components/ModelDetails.svelte';
 export { default as AppFooter } from './components/AppFooter.svelte';
 export { default as AppHeader } from './components/AppHeader.svelte';
 export { default as BusPicker } from './components/BusPicker.svelte';
@@ -16,3 +17,4 @@ export { default as SizeLegend } from './components/SizeLegend.svelte';
 export { default as SolveCard } from './components/SolveCard.svelte';
 export { default as TopMovers } from './components/TopMovers.svelte';
 export { default as Sparkline } from './Sparkline.svelte';
+export { default as McResults } from './components/McResults.svelte';

package/dist/context.svelte.d.ts

@@ -17,4 +17,3 @@ export declare const setUiConfig: (config: TellegenUiConfig) => TellegenUiConfig
 export declare const getAppState: () => AppState;
 export declare const getController: () => Controller;
 export declare const getUiConfig: () => TellegenUiConfig;
-//# sourceMappingURL=context.svelte.d.ts.map

package/dist/controller.svelte.d.ts

@@ -1,15 +1,25 @@
 import { type TellegenApiClient } from './api.js';
 import type { BranchRatingDeltas, Network, NetworkBus, SensitivityColumn, Solution } from './api.js';
 import { CaseState, LocalCase, MulticonductorCase, type AppState, type DemandRangeMode, type SolvableCase } from './state.svelte.js';
-import { type BrowserStudy, type Formulation, type SensTarget } from '@tellegen/engine';
+import { type EngineTransport, type McPfOptions, type McPfResult, type McStudySnapshot, type BrowserStudy, type Formulation, type PowerIoDiagnostic, type SensTarget } from '@tellegen/engine';
 /** A parsed geographic sidecar awaiting application: the canonical `.geo.json`
  * layer document from the engine's tolerant reader, its source file name, and
  * the reader's notes on records it could not use. */
 type GeoLayerFile = {
     name: string;
     layer: string;
-    warnings: string[];
+    diagnostics: PowerIoDiagnostic[];
 };
+type SavedCaseCapture = {
+    input: string;
+    solution?: string;
+    view?: import('@tellegen/engine').StudyView;
+};
+/** A lowered analysis row is view-only only when a current producer says so;
+ * absence keeps payloads from older compatible engine/server versions editable. */
+export declare function isDisplayOnlyElement(element: {
+    editable?: boolean;
+} | null | undefined): boolean;
 export type { SolvableCase };
 type DemandRangeAnchor = {
     caseId: string;
@@ -19,28 +29,32 @@ type DemandRangeAnchor = {
 export interface ControllerOptions {
     api?: TellegenApiClient;
     apiBase?: string;
+    mcTransport?: Pick<EngineTransport, 'solveMcModule' | 'applyMcGeo'> & Partial<Pick<EngineTransport, 'solveMcStudy' | 'applyMcStudyGeo' | 'createMcPfSession'>>;
 }
 export declare class Controller {
     app: AppState;
     api: TellegenApiClient;
+    mcTransport: Pick<EngineTransport, 'solveMcModule' | 'applyMcGeo'> & Partial<Pick<EngineTransport, 'solveMcStudy' | 'applyMcStudyGeo' | 'createMcPfSession'>>;
     abort: AbortController | null;
     sensitivity429Until: number;
     serverComputeOff: boolean;
     caseStudies: WeakMap<SolvableCase, {
         study: BrowserStudy;
-        networkJson: string;
+        studyInputJson: string;
         formulation: Formulation;
         baseSolution: Solution;
     }>;
+    private detachedCaseCaptures;
     studyUnavailable: WeakMap<SolvableCase, string>;
     studyBuilds: WeakMap<SolvableCase, {
-        networkJson: string;
+        studyInputJson: string;
         formulation: Formulation;
         token: object;
         promise: Promise<BrowserStudy | null>;
     }>;
     localSeq: number;
     loading: Promise<void> | null;
+    private readonly dropBatchGate;
     nearbyRangeAnchor: DemandRangeAnchor | null;
     hiddenDefaults: Set<string>;
     casesLoaded: boolean;
@@ -68,6 +82,7 @@ export declare class Controller {
     /** True when two selection targets name the same bus or branch. */
     sameTarget(a: SensTarget, b: SensTarget): boolean;
     isPerturbed(c: SolvableCase | null): boolean;
+    bumpRevision(c: SolvableCase): void;
     setNearbyRangeAnchor(c: SolvableCase, bus: number, delta?: number): void;
     beginBusSelection(c: SolvableCase, busId: number): {
         ac: AbortController;
@@ -84,12 +99,12 @@ export declare class Controller {
     rememberHiddenDefaultCase(id: string): void;
     localNetwork(c: LocalCase): Network | null;
     maybeStartLocalSolve(id: string): void;
-    getStudy(c: SolvableCase, networkJson: string): Promise<BrowserStudy | null>;
-    browserSensitivity(c: SolvableCase, networkJson: string, target: SensTarget): Promise<SensitivityColumn | null>;
+    getStudy(c: SolvableCase, studyInputJson: string): Promise<BrowserStudy | null>;
+    browserSensitivity(c: SolvableCase, studyInputJson: string, target: SensTarget): Promise<SensitivityColumn | null>;
     disposeStudy(c: SolvableCase): void;
     acceptSensitivity(c: SolvableCase, col: SensitivityColumn | null, target: SensTarget | null, sensitivitySeq?: number): void;
     finishSolve(c: SolvableCase, seq: number, target: SensTarget | null): void;
-    ensureNetworkJson(c: SolvableCase): Promise<string | null>;
+    ensureStudyInputJson(c: SolvableCase): Promise<string | null>;
     previewDeltas(c: SolvableCase, bus: number, value: number): {
         [x: string]: number;
         [x: number]: number;
@@ -144,6 +159,7 @@ export declare class Controller {
     };
     sliderMin: number;
     sliderMax: number;
+    sliderDisabled: boolean;
     committedRating: number;
     ratingSliderValue: number;
     ratingBounds: {
@@ -184,7 +200,7 @@ export declare class Controller {
     placeLocalCase: (lon: number, lat: number) => Promise<void>;
     /** Write the case's on-screen layout into its network payload
      * (`Bus.location` with `synthetic` provenance — the engine also accepts
-     * `manual`, which round trips through restored packages), so saves,
+     * `manual`, which round trips through saved PowerIO modules), so saves,
      * exports, and the `.geo.json` download carry it. Best effort: on an
      * engine failure the view still renders, only the layout's persistence is
      * lost. */
@@ -198,7 +214,7 @@ export declare class Controller {
      * wins on shared elements). The engine owns matching and the network becomes
      * the single owner of the coordinates: matched points land in
      * `Bus.location`, routes in `Branch.route`, and the refreshed
-     * `network_json` replaces the case payload — so a saved package or export
+     * `module_json` replaces the case IR — so a saved module or export
      * carries exactly what is on screen. A live Study is synced the same way.
      * Throws when a layer matches nothing. */
     applyGeoLayers: (c: LocalCase, layers: GeoLayerFile[]) => Promise<void>;
@@ -206,10 +222,12 @@ export declare class Controller {
      * the case's network and view, provenance flips to the geographic source,
      * and the warnings panel gets the placement summary. */
     private adoptGeoPayload;
-    /** Keep a live Study's base network in step with a geo change (locations
-     * are metadata the model never reads, so nothing re-solves), and re-key its
-     * cache entry so the next solve reuses it instead of rebuilding. */
-    private syncCachedStudy;
+    /** Update an existing numerical Study after the base input receives geographic data. */
+    private syncStudyGeo;
+    private caseEditKey;
+    private localSidecarCopy;
+    private stageLocalSidecars;
+    private attachSidecarsToSelected;
     applyGeoLayersToExisting: (layers: GeoLayerFile[]) => Promise<void>;
     /** Ask the map to frame the selected branch and wait for the camera to land,
      * capped by FOCUS_SETTLE_CAP_MS and cut short by the selection's abort. */
@@ -225,7 +243,7 @@ export declare class Controller {
      * transient (a wasm chunk or case JSON fetch), so say what is known and keep
      * the retry meaningful. */
     private computeOffNotice;
-    /** The one server ∂LMP/∂parameter request a selection may make: the
+    /** The one server nodal-value/parameter request a selection may make: the
      * reconciliation path when the browser Study produced no column for a DC OPF
      * case. Never retries on its own: a second request inside the same rate limit
      * window is a guaranteed rejection, and the retry button covers the user
@@ -260,32 +278,42 @@ export declare class Controller {
     commitDelta: (value: number) => void;
     finishDemandInput: (value: number) => void;
     resetCase: (c: SolvableCase) => void;
+    /** Rebuild the numerical Study for a selected calculation at the current demand. */
     changeFormulation: (c: SolvableCase, next: Formulation) => void;
     /** Parse dropped files in the browser via the powerio wasm module. Case
-     * files (.m, .raw, .aux) become local networks; geographic files can
+     * files (.m, .raw, .aux, .epc, .pwb) become local networks; geographic files can
      * place those networks; a PowerWorld .pwd becomes a substation point
      * preview. Files run serially; nothing uploads. */
     ingestFiles: (files: FileList | File[]) => Promise<void>;
-    /** Fill a coordinate-less case's positions from a co-dropped PowerWorld
-     * `.pwd`: the display's substation points project to approximate
-     * longitude/latitude and join onto buses through the `SubNum` extras key.
-     * The first display that joins wins; one that matches nothing stays
-     * available as its own preview entry, and the case stays placeable. */
+    private ingestFileBatch;
+    /** Apply co-dropped geographic data before a local case becomes active and
+     * starts solving. Without geographic data, let a coordinate-less case borrow
+     * the first matching PowerWorld display. A failed geographic join keeps the
+     * parsed case and returns the user-facing placement error. */
+    private prepareDroppedLocal;
+    /** Retain diagram geometry separately from the electrical case's geographic data. */
     private fillFromDisplaySibling;
-    /** Route a dropped `.json` by its content: a saved study package restores
-     * (`restored`), a multiconductor package or a BMOPF/PMD distribution
-     * document views (`viewed`), `failed` means the content looked routable but
-     * the engine rejected it (a fail-closed message is set), and `not-package`
-     * falls through to the caller's geo/case handling. `drop-classify` is the
-     * single owner of the classification. */
-    private ingestJsonDrop;
+    setCaseDisplayMode: (c: LocalCase, mode: "geographic" | "diagram") => void;
+    /** Route a dropped `.json` by its content. Recognized payloads return without
+     * mutating case state so co-dropped sidecars can be applied first; unrouted
+     * content returns the bytes already read for the geographic fallback. */
+    private routeJsonDrop;
     /** Parse a dropped OpenDSS `.dss` file into a multiconductor viewing case.
      * Returns true when a case landed; a parse failure sets the panel error. */
     private ingestDistFile;
-    /** Build a `MulticonductorCase` from an ingest payload and make it active.
-     * Geographic cases place immediately; planar/synthetic cases enter placement
-     * (a map click or "place on map") so the user picks their center. */
+    /** Retain parsed electrical inputs and draw each declared coordinate space directly. */
     private addMultiCase;
+    /** Compute terminal quantities only for the retained input and current case revision. */
+    solveMultiCase: (c: MulticonductorCase, options?: McPfOptions, signal?: AbortSignal) => Promise<McPfResult>;
+    /** Materialize the current retained operating point only when a portable
+     * snapshot is actually needed (save/export/geography). */
+    snapshotMultiCase: (c: MulticonductorCase) => Promise<McStudySnapshot>;
+    /** Apply coordinates atomically to the explicitly selected conductor-resolved case. */
+    applyMultiGeoLayers: (c: MulticonductorCase, layers: GeoLayerFile[]) => Promise<void>;
+    /** Stage an absolute load-branch P/Q edit and coalesce rapid UI changes into
+     * one retained-factor warm solve. */
+    queueMultiLoadPower: (c: MulticonductorCase, load: string, branch: number, p_w: number, q_var: number) => void;
+    private flushMultiLoadPowers;
     /** Make a multiconductor case active, framing it when it is placed. */
     activateMulti: (c: MulticonductorCase) => void;
     /** Select a bus in a multiconductor case: its terminal stack and incident
@@ -303,18 +331,24 @@ export declare class Controller {
     /** The unified map click-to-place: a pending multiconductor case takes the
      * click first, otherwise a pending local case does. */
     placeCase: (lon: number, lat: number) => void;
-    /** Build a local case from a restored study package: the same shape a dropped case
-     * takes, with the saved demand/rating deltas and formulation pre-applied. */
-    private restoreLocalFromPackage;
+    projectStudyInput(input: string, layer?: string): Promise<Network>;
+    caseGeographyLayers(c: LocalCase): Promise<string[]>;
+    /** Capture a matching cached result without constructing or solving a model. */
+    captureSavedCase(c: SolvableCase): Promise<SavedCaseCapture>;
+    /** 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;
     /** Build (or reuse) the case's Study and commit it at the current edit state, so a
      * save or export captures exactly what is on screen. Null (with an error set) when no
-     * network or Study is available. */
-    private syncedStudy;
-    /** Save the active study as a `.pio.json` package and download it. */
-    saveStudyPackage: (c: SolvableCase) => Promise<void>;
-    /** Export the active study's committed state to `format` and download it. Returns the
-     * writer's fidelity warnings so the caller can surface them. */
-    exportStudyAs: (c: SolvableCase, format: string) => Promise<string[]>;
+     * PowerIO module or Study is available. */
+    syncedStudy: (c: SolvableCase) => Promise<BrowserStudy | null>;
+    /** Save the materialized case as a retained PowerIO module. */
+    saveCaseModule: (c: SolvableCase) => Promise<void>;
+    /** Save the exact DC OPF result with the materialized problem instance it solved. */
+    saveSolutionModule: (c: SolvableCase) => Promise<void>;
+    /** Export the active study's committed state to `format` and download it.
+     * Returns this output operation's structured diagnostics. */
+    exportCaseAs: (c: SolvableCase, format: string) => Promise<PowerIoDiagnostic[]>;
     /** A filesystem-safe base name for a downloaded case file. */
     private caseFileStem;
     setDemandRangeMode: (mode: DemandRangeMode) => void;
@@ -334,4 +368,3 @@ export declare class Controller {
     ratingSliderCurrent: () => number;
 }
 export declare function createController(app: AppState, options?: ControllerOptions): Controller;
-//# sourceMappingURL=controller.svelte.d.ts.map