@vscada/core 0.0.1

package/dist/registry/element-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-catalog.d.ts","sourceRoot":"","sources":["../../src/registry/element-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE7D,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,aAAa,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CACvC;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2PmB,CAAC;AAEhD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,eAAe,CAAC;AAC3D,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,eAAe,IAAI,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC"}

package/dist/registry/primitive-registry.d.ts

@@ -0,0 +1,7 @@
+import type { PrimitiveGroup, PrimitiveModule } from '../contracts/primitive';
+export declare function registerPrimitives(...groups: PrimitiveGroup[]): void;
+export declare function getPrimitiveBuilder(type: string): PrimitiveModule | undefined;
+export declare function getRegisteredTypes(): ReadonlySet<string>;
+/** Test-only: registration is module-level global state shared across a test file. */
+export declare function __resetPrimitiveRegistryForTests(): void;
+//# sourceMappingURL=primitive-registry.d.ts.map

package/dist/registry/primitive-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-registry.d.ts","sourceRoot":"","sources":["../../src/registry/primitive-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAW9E,wBAAgB,kBAAkB,CAAC,GAAG,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI,CASpE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAE7E;AAED,wBAAgB,kBAAkB,IAAI,WAAW,CAAC,MAAM,CAAC,CAExD;AAED,sFAAsF;AACtF,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD"}

package/dist/registry/theme-registry.d.ts

@@ -0,0 +1,6 @@
+import type { ThemeTokens } from '../tokens';
+export declare function registerThemes(...themes: ThemeTokens[]): void;
+/** Falls back to an empty, pipe-less token set so unregistered themes degrade gracefully rather than crash. */
+export declare function getThemeTokens(name: string): ThemeTokens;
+export declare function __resetThemeRegistryForTests(): void;
+//# sourceMappingURL=theme-registry.d.ts.map

package/dist/registry/theme-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-registry.d.ts","sourceRoot":"","sources":["../../src/registry/theme-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAc7C,wBAAgB,cAAc,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAI7D;AAED,+GAA+G;AAC/G,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAExD;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD"}

package/dist/registry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Supply side of Story 1.2's `knownTypes` seam. Story 1.2 wired a
+ * placeholder (empty set); this now delegates to the real primitive
+ * registry (AD-3) — the structural validator itself is untouched, exactly
+ * as that story's seam was designed to allow.
+ */
+export declare function getKnownElementTypes(): ReadonlySet<string>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,WAAW,CAAC,MAAM,CAAC,CAE1D"}

package/dist/scada-view.d.ts

@@ -0,0 +1,322 @@
+import { LitElement, type PropertyValues } from 'lit';
+import type { Scene } from './scene/scene-schema';
+import type { TagValue } from './contracts/tag-value';
+import type { ConnectionState } from './contracts/connection-state';
+import { type TimeSource } from './contracts/time-source';
+import { type Renderer } from './contracts/renderer';
+import { type SchedulerMode } from './scheduler/scheduler';
+import { type AnimationPriority } from './scheduler/animation-registry';
+import { type MatchMediaFn } from './a11y/reduced-motion';
+/**
+ * Story 4.3 Task 2 — infers each animation handle's LOD-cap priority
+ * tier from its OWN synthetic handle-map key, which every primitive that
+ * registers an `AnimationHandle` already names systematically (never a
+ * real tag): `recipe.ts`'s `__vessel-wave-animation-${id}`,
+ * `rotation-drive/base.ts`'s `__rotating-animations-${id}`, and
+ * `conveyance/pipe`'s `nextId('pipe-flow-animation')`. Zero primitive-
+ * package changes needed for this — `_registerHandles` is the one place
+ * every primitive's `HandleMap` already funnels through.
+ *
+ * Known limitation, not introduced by this story: `rotation-drive/base.ts`
+ * bundles a driven-equipment element's rotation AND its state-lamp blink
+ * into ONE combined pause/resume handle (pre-existing architecture), so
+ * that handle is tagged `'rotation'`, not `'state-lamp'` — under a very
+ * tight LOD cap, a running pump's blink could pause alongside its
+ * rotation.
+ *
+ * Architecture code audit (2026-08-27, AD-5 finding P1-1) — the STANDALONE
+ * `indicator-lamp` primitive used to never register through
+ * `AnimationRegistry` at all (its blink was driven by direct
+ * `AnimationControl` calls inline in its own state handler), which meant a
+ * stale/disconnected scene could not freeze it either — the exact failure
+ * AD-5 exists to prevent. It now registers its blink as a proper
+ * `AnimationHandle` (`__indicator-lamp-animation-${id}`), tagged
+ * `'state-lamp'` here so it both respects freeze-on-stale AND keeps the
+ * originally-intended "state-lamps survive longest" property deliberately,
+ * via the rank-0 tier `ANIMATION_PRIORITY_RANK` already defined for it,
+ * rather than accidentally via non-registration.
+ *
+ * Story 3.8 — `vapor/base.ts`'s `__vapor-drift-animation-${id}` (plume and
+ * steam-vent's shared billow-drift handle) is tagged `'wave'`, the same
+ * tier as the vessel liquid wave: both are ambient, lowest-priority-to-
+ * survive continuous motion under a tight LOD cap, never safety-critical.
+ * Exported so this mapping is directly unit-testable without standing up a
+ * full scene (mirrors every other primitive-package registration site's
+ * own doc comment above — no primitive-package code needed here either).
+ */
+export declare function inferAnimationPriority(handleKey: string): AnimationPriority;
+/**
+ * Root element. Story 1.1 proved Lit + Shadow DOM wiring; Story 1.2 added
+ * the `scene` validation pipeline (AD-8). This story wires the actual
+ * frame pipeline (AD-1): `values`/`setValues()` feed the store; the single
+ * per-instance scheduler reads it on each tick and writes through handles
+ * → renderer. `TimeSource`/`Renderer` are constructor-injectable for
+ * tests (spec §8.4); real usage via `document.createElement`/markup uses
+ * the live defaults.
+ *
+ * @customElement scada-view
+ *
+ * @fires {CustomEvent<SceneErrorDetail>} scene-error - A structurally invalid `scene` assignment (AD-8), or a dev-only Zod diagnostic on an otherwise-valid one. Structural failures render nothing until a valid scene is assigned.
+ * @fires {CustomEvent<ValueWarningDetail>} value-warning - Dev-only: a pushed `TagValue` didn't map to any declared binding/state/threshold for its element.
+ * @fires {CustomEvent<ElementClickDetail>} element-click - A scene element's (or collapsed group's) hit area was activated by click/tap/keyboard, while `interactive` is true (§3.4).
+ * @fires {CustomEvent<ElementHoverDetail>} element-hover - A fine (mouse) pointer entered a scene element's hit area (§3.4).
+ * @fires {CustomEvent<RenderStats>} render-stats - Once per second while `debug` is true: frame-timing/element-count accounting for perf diagnostics (§3.2 `debug`).
+ *
+ * @attr {string} license-key - Plain-HTML-attribute fallback for `setLicenseKey()` (Story 6.2 Task 2). Module-level, not per-instance.
+ * @attr {string} tag-prefix - Plain-HTML-attribute fallback for the `tagPrefix` property (Story 2.6 AC2).
+ * @attr {string} interactive - Plain-HTML-attribute fallback for the `interactive` property. Any value other than the literal `"false"` means interactive.
+ * @attr {string} mode - Plain-HTML-attribute fallback for the `mode` property. `"static"` selects static mode; any other value (including absent) means live.
+ * @attr {string} animated - Plain-HTML-attribute fallback for the `animated` property. Any value other than the literal `"false"` means animated.
+ *
+ * @cssprop [--vscada-focus-ring-color=#2c7be5] - Keyboard focus ring color (§11), resolved from the active theme's `focusRing` token when declared.
+ * @cssprop [--vscada-focus-ring-width=2px] - Keyboard focus ring width (§11).
+ * @cssprop [--vscada-focus-ring-offset=2px] - Keyboard focus ring offset (§11).
+ *
+ * @csspart canvas - The root `<svg>` the whole scene renders into.
+ */
+export declare class ScadaView extends LitElement {
+    static styles: import("lit").CSSResult;
+    private _scene;
+    private _lastError;
+    private _pendingDevValidation;
+    private _sceneGeneration;
+    private readonly _renderer;
+    private readonly _store;
+    private readonly _scheduler;
+    private readonly _animations;
+    /** Story 4.4 Task 1 — §11 reduced-motion's declared-static-swap registry, sibling to `_animations` but a distinct registration surface (see `StaticRepresentationRegistry`'s own doc). */
+    private readonly _staticRepresentations;
+    private readonly _reducedMotion;
+    /** Story 4.4 Task 3 — §11 ARIA live region; unsubscribed in `disconnectedCallback`. */
+    private readonly _liveRegion;
+    private _unsubscribeConditionTransition;
+    private _builtElements;
+    private _builtDefs;
+    private _watermark;
+    private _licenseVerdict;
+    private _needsStructureInsert;
+    private _schedulerStarted;
+    private _unsubscribeLicense;
+    /** Story 4.2 — §3.2 `interactive`: "Whether elements emit click events." A cheap global toggle (AC3) checked at dispatch time, never a rebuild trigger. */
+    private _interactive;
+    /** Story 4.2 Task 2 — one arbiter per instance, surviving rebuilds, so a drag begun before a mid-gesture rebuild still resolves correctly via the same tracked pointerId. */
+    private readonly _gestureArbiter;
+    private _hitLayerGroup;
+    /** Hit rects built THIS structure build, with enough info to recompute their box in place on a zoom change (Story 4.3 Task 1) — never rebuilt for a zoom-only change, only for a real structural rebuild. */
+    private _hitAreaEntries;
+    /** Story 4.3 Task 1 — AD-4 view state (zoom/pan), reset on scene reload, NOT scene data. Owns its own tween-drive subscription independent of `_scheduler`'s start/stop lifecycle. */
+    private readonly _viewportState;
+    private readonly _panZoomGestures;
+    /** The one root `<g>` every built element/hit-layer renders inside — translate+scale is the ONLY thing zoom/pan ever touches (AD-2: never re-render on zoom). Rebuilt fresh each structure build, re-stamped with the CURRENT transform immediately (a rebuild mid-gesture must not visually snap to identity). */
+    private _viewportGroup;
+    /** Story 4.3 Task 2 — previous LOD resolution, fed back into `resolveLodActive` for its hysteresis band. */
+    private _lodActive;
+    private _listenersAttached;
+    /** Story 4.3 Task 3 — off-screen (`IntersectionObserver`) / hidden-tab (`visibilitychange`) pause. Assumed visible until the observer's first callback. */
+    private _isIntersecting;
+    private _intersectionObserver;
+    private _boundVisibilityChange;
+    /** Story 4.3 Task 4 — `render-stats` consumer, only subscribed while `debug` is on. */
+    private _unsubscribeRenderStats;
+    /** Story 2.5 — view state (AD-4: collapse/expand), NOT scene data. Constructed lazily on first scene load, `reset()` on every subsequent one — never on a same-scene rebuild (e.g. a group toggle), which is what lets a toggle survive its own rebuild. */
+    private _groupViewState;
+    /** Story 2.4 Task 2/3 — rebuilt fresh every structure build (tied to the currently-registered handles' lifecycle, unlike `_groupViewState` above). */
+    private _flowInferenceCache;
+    private _flowStoppedSourceIds;
+    private _flowClosedNodeIds;
+    /** Adversarial-review Fix 3 — ids that got a flow-state-tracking Fsm/handle registered this build, INCLUDING hidden children of a collapsed group (never in `_builtElements`, which only holds visually-built elements). Teardown needs this separately so a hidden source's tracking registration doesn't leak across rebuilds. */
+    private _flowTrackedElementIds;
+    constructor(timeSource?: TimeSource, renderer?: Renderer, matchMedia?: MatchMediaFn | undefined);
+    /** §3.2 — configuring the timeout is allowed; disabling the freeze behavior it drives is not (NFR4). */
+    get stalenessTimeout(): number;
+    set stalenessTimeout(ms: number);
+    /** Story 1.3 Task 4 — the tween-vs-snap `|Δ|` cap, as a component-level option (sensible default, see `DEFAULT_SNAP_THRESHOLD`). */
+    get snapThreshold(): number;
+    set snapThreshold(value: number);
+    /** §3.2 — parent-supplied upstream health. `'disconnected'` freezes the entire scene (§4.4) regardless of individual timestamps. */
+    get connectionState(): ConnectionState;
+    set connectionState(state: ConnectionState);
+    /**
+     * §3.2 `mode` (Story 4.1, §8.3 "one code path") — delegates entirely to
+     * `Scheduler.mode`, which owns the live↔static transition (snap-then-stop
+     * / restart). Static mode is what makes `setValues()` below apply a
+     * synchronous write pass instead of starting the rAF loop (AC1).
+     */
+    get mode(): SchedulerMode;
+    set mode(value: SchedulerMode);
+    /**
+     * §3.2 `animate` (Story 4.1 AC1) — master switch for continuous animation,
+     * orthogonal to `mode` (§8.1: static mode keeps animations running by
+     * default; this is the explicit opt-out for true snapshot capture).
+     * Exposed as `animated`, not `animate` — `Element.prototype.animate()`
+     * (the native Web Animations API method every `HTMLElement` already has)
+     * would otherwise collide with a same-named boolean property, breaking
+     * the class's assignability to `Element`/`CustomElementConstructor`.
+     */
+    get animated(): boolean;
+    set animated(value: boolean);
+    /** Story 4.4 Task 1 — current `prefers-reduced-motion` state as last observed by the core-owned listener (§11). Read-only: the OS/browser preference, not a settable switch — `animated` remains the one property that toggles continuous motion directly. */
+    get reducedMotionActive(): boolean;
+    /** AC4 — every in-flight tween and data interpolation completes to its target immediately (Story 4.1's static-mode switch depends on this). Story 4.3 — a mid-flight PROGRAMMATIC zoom tween (gesture-driven zoom is never mid-flight — it's already immediate) settles the same way. */
+    snapToTargets(): void;
+    /** Story 4.2 AC3 — §3.2 `interactive`. Gates whether a tap/click ever dispatches `element-click` (checked at pointerup time); does not remove or rebuild the hit-area structure itself. */
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    /**
+     * Story 4.3 Task 1 — §3.2 `zoom`, two-way. A GESTURE update (pinch/
+     * wheel/drag-zoom) writes `_viewportState` directly and this getter
+     * reflects it immediately; an external `view.zoom = x` assignment
+     * animates via the tween layer instead of jumping (`setZoomAnimated`).
+     * Never a structural rebuild (AD-2) — the root viewport `<g>` transform
+     * plus an in-place hit-area recompute (`_onViewportFrame`) are the ONLY
+     * things a zoom change touches, superseding Story 4.2's rebuild-per-
+     * zoom-change behavior.
+     */
+    get zoom(): number;
+    set zoom(value: number);
+    /** §3.2 `debug` — gates 1Hz `render-stats` accounting entirely; subscribes/unsubscribes the event-dispatching consumer on toggle. */
+    get debug(): boolean;
+    set debug(value: boolean);
+    /**
+     * Story 1.7 — the sanctioned deterministic-frame mechanism for visual
+     * regression: seeks every registered WAAPI animation (impeller
+     * rotation, flow dashes, lamp blink, …) to an absolute `currentTime`.
+     * Dev/test utility — trivially small, never load-bearing for production
+     * rendering. If a screenshot still shows motion after this, something
+     * bypassed the animation registry (AD-5) and that's a real bug this
+     * method exists to catch, not a test to work around.
+     */
+    seekAll(timeMs: number): void;
+    /**
+     * §3.3 `exportSVG` (Story 4.1 AC3) — works in ANY mode (live or static):
+     * serializes the current rendered `<svg>` to a standalone string. Returns
+     * `''` if no scene has been built yet (nothing to export).
+     */
+    exportSVG(): string;
+    /**
+     * Story 6.2 Task 2 — plain-HTML fallback for `setLicenseKey()`. `setLicenseKey` is module-level (per-company, not per-view), so any instance observing this attribute is enough to license the whole page.
+     * Story 2.6 AC2 — `tag-prefix` mirrors the same plain-HTML-attribute convention for `tagPrefix` below.
+     */
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    /** Story 2.6 AC2 — every tag lookup is prefixed by this string (`ValueStore.tagPrefix`); changing it at runtime re-resolves and resets interpolation state for affected tags (see `Scheduler`'s own doc on `syncTagPrefixIfChanged`). */
+    get tagPrefix(): string;
+    set tagPrefix(prefix: string);
+    /** §3.2 `scene` — the currently-loaded, validated scene, or `null` if none has been assigned yet or the last assignment failed structural validation (AD-8; see the setter below). */
+    get scene(): Scene | null;
+    set scene(raw: unknown);
+    /** Awaitable in tests; resolves once dev-only Zod diagnostics for the current scene have run. */
+    get pendingDevValidation(): Promise<void> | null;
+    /** Reconstructed from the store's current buffer — not a cached mirror of the last-pushed array (AD-4: no extra state). */
+    get values(): TagValue[];
+    set values(values: TagValue[]);
+    /**
+     * Imperative equivalent of setting `values` (§3.3). Story 4.1 AC1 — in
+     * static mode this is the "single synchronous write pass, no rAF" §8.3
+     * describes: `Scheduler.snapToTargets()` (already the sanctioned
+     * immediate-write path, AC4) writes every registration's current value
+     * with zero tween, with no rAF loop ever started. `_viewportState` is
+     * deliberately untouched here (unlike the public `snapToTargets()`
+     * below) — a value push must not also snap an unrelated in-flight zoom/
+     * pan gesture.
+     */
+    setValues(values: TagValue[]): void;
+    /** The only way values are cleared — never an empty `setValues([])` (§3.3, §4.2). */
+    clearValues(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Story 6.3 — reacts to the module-level license verdict: toggles this instance's watermark and (once, page-wide) logs the trial notice. */
+    private _onLicenseVerdict;
+    firstUpdated(): void;
+    updated(changed: PropertyValues): void;
+    render(): import("lit").TemplateResult<1>;
+    private _buildElements;
+    /**
+     * Story 2.4 Task 2/3 — drives `this._flowInferenceCache.update()` off an
+     * actual tag-value-driven state transition (never per tick — the cache's
+     * own doc requires "on a source/valve FSM state-change event"). The one
+     * event-driven mechanism this codebase has for observing a value change
+     * IS a scheduler-registered handle's `write()` (exactly how
+     * pump-centrifugal drives its own internal FSM); `FlowInferenceCache.update`
+     * is itself signature-guarded (a no-op unless the stopped/closed set
+     * actually changed), so calling it unconditionally here — rather than
+     * gating on `Fsm`'s own `changed` flag, which is `false` on a value's
+     * very first resolution — is both safe and correct.
+     */
+    private _registerFlowStateTracking;
+    /** Story 2.5 Task 3 — the `element-click`/`elementType:'group'` + `toggleGroup` wiring `group-view-state.ts` deferred to `<scada-view>`. A collapse-state change is a structure-once (AD-2) event exactly like a scene reload: full teardown + rebuild, just without resetting `_groupViewState` (only a genuinely new `scene` assignment does that). */
+    private _toggleGroup;
+    /**
+     * Story 4.4 Task 3 — resolves elementId -> a `LiveRegionController`
+     * announcement. `next` alone can't distinguish "stale because THIS tag
+     * timed out" from "stale because the whole scene disconnected" (both
+     * collapse into the same `Condition` by the time `Scheduler` reports
+     * them, §4.3's `worstOf`) — read `connectionState` at the moment of the
+     * transition to disambiguate, exactly as `Scheduler.onConditionTransition`'s
+     * own doc says the caller must.
+     */
+    private _handleConditionTransition;
+    /**
+     * Story 4.4 Task 3 — wraps every numeric handle whose tag has a declared
+     * threshold with a thin band-transition check (`resolveAlarmBand`),
+     * announcing only on an actual band CHANGE into a non-normal band (never
+     * every write) before delegating to the primitive's own handle. The
+     * quantity word in the announcement ("level", "needle", …) is the tag's
+     * own binding `type` — the same vocabulary the scene author already
+     * chose, never a new naming scheme.
+     */
+    private _wrapHandlesForLiveRegion;
+    private _registerHandles;
+    private _teardownBuiltElements;
+    private _maybeStartScheduler;
+    private _dispatchValueWarning;
+    /** Story 4.2 Task 2 — §3.4 `element-click`. */
+    private _dispatchElementClick;
+    /** Story 4.2 Task 2 — §3.4 `element-hover`; only ever called for a fine (mouse) pointer entering (AC2 — `attachElementInteraction`'s own gate). */
+    private _dispatchElementHover;
+    /** §3.4 `render-stats` (Story 4.3 Task 4) — only ever called while `debug` is on. */
+    private _dispatchRenderStats;
+    /**
+     * Story 4.3 Task 1 — the ONE per-gesture-frame write path: stamps the
+     * viewport `<g>`'s transform, recomputes every hit-area's box in place
+     * for the new zoom (no rebuild, AD-2), and re-evaluates the LOD
+     * threshold. Called both from a live gesture (immediate) and from the
+     * external-set zoom tween's own per-tick callback.
+     */
+    private _onViewportFrame;
+    private _applyViewportTransform;
+    /**
+     * Story 4.3 Task 1 — converts the SVG's live CSS-to-viewBox scale ratio
+     * (assumes uniform `xMidYMid meet` scaling — this component's own
+     * `render()` always sets `viewBox="0 0 canvasWidth canvasHeight"` with
+     * no `preserveAspectRatio` override) so a gesture's CLIENT-space (CSS
+     * px) delta converts to the SAME viewBox-unit space `pan` lives in.
+     */
+    private _viewBoxScale;
+    /** Converts an absolute CLIENT-space point (pinch centroid / wheel cursor) into the viewBox-unit space `zoomAboutPoint`'s anchor expects. */
+    private _toCanvasPoint;
+    /**
+     * Story 4.3 Task 1 — attached ONCE (`firstUpdated`) on the root `<svg>`,
+     * not per-element: Pointer Events bubble, so this observes every
+     * gesture including ones starting over an element's hit area (this
+     * component has no drag-to-reposition affordance — any drag anywhere
+     * pans the camera). `touch-action: none` (component styles) stops the
+     * browser's own native touch scroll/pinch from fighting this.
+     */
+    private _attachPanZoomListeners;
+    /**
+     * Story 4.3 Task 3 — off-screen (`IntersectionObserver`) OR hidden-tab
+     * (`document.hidden`) either one pauses; both must clear before
+     * resuming. Idempotent via `Scheduler`'s own `pauseForOffscreen`/
+     * `resumeFromOffscreen` guards, so calling this on every observer/
+     * visibilitychange firing (even a redundant one) is safe.
+     */
+    private _syncVisibilityPause;
+}
+/**
+ * Explicit registration — importing @vscada/core has no side effects
+ * (`"sideEffects": false`); consumers opt in, mirroring AD-3's explicit
+ * `registerPrimitives(...)` convention.
+ */
+export declare function defineScadaView(tagName?: string): void;
+//# sourceMappingURL=scada-view.d.ts.map

package/dist/scada-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scada-view.d.ts","sourceRoot":"","sources":["../src/scada-view.ts"],"names":[],"mappings":"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"}

package/dist/scene/connection-geometry.d.ts

@@ -0,0 +1,95 @@
+import type { Connection, Scene } from './scene-schema';
+import type { TopologyGraph } from '../topology/graph';
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Segment {
+    from: Point;
+    to: Point;
+}
+export interface Corner {
+    from: Point;
+    to: Point;
+    radius: number;
+    /** SVG arc sweep-flag (0 or 1), derived from the turn direction. */
+    sweepFlag: 0 | 1;
+}
+export interface FlowBindingRef {
+    tag: string;
+    min: number;
+    max: number;
+}
+export interface ResolvedRoute {
+    /** Straight sub-segments, pre-trimmed around corners. */
+    segments: Segment[];
+    /** One entry between each pair of adjacent segments. */
+    corners: Corner[];
+    medium: string | undefined;
+    /** From the connection's own `bindings` (Story 1.4 addition to ConnectionSchema) — the pipe renderer's dash-speed source. */
+    flowBinding: FlowBindingRef | undefined;
+}
+/**
+ * Resolves a connection to an ordered point route. Story 1.4 shipped
+ * `direct` and `manual` + corner-rounding; Story 2.1 adds the `orthogonal`
+ * elbow generator behind the same `ResolvedRoute` interface — the pipe
+ * renderer never sees a routing mode, only resolved geometry.
+ *
+ * Mode-dispatch precedence (Task 3): `manual` waypoints, OR `orthogonal`
+ * with `waypoints` present, always win over the generator — waypoints are
+ * the sanctioned manual escape hatch for a route an author dislikes.
+ * `orthogonal` with no waypoints calls the elbow generator. `direct` (and
+ * `manual`/`orthogonal` with no waypoints supplied) resolve to a single
+ * straight segment, unchanged from 1.4.
+ *
+ * `connection.routing` defaults to `'orthogonal'` at the point of use here
+ * (not in the schema/validator): production scenes only go through the
+ * always-on structural validator (AD-8), never the dev-only Zod `.parse()`
+ * that would apply the schema's declared `.default('orthogonal')` — so an
+ * omitted `routing` field must still resolve to orthogonal routing, matching
+ * what the schema promises.
+ *
+ * Story 2.2, Task 1: `connection.laneOffset` displaces the raw centerline
+ * polyline perpendicular by `laneOffset * laneWidth` BEFORE corner
+ * rounding runs — this is what "corners re-fillet after displacement"
+ * means: `finalizeRoute` always rounds the already-displaced points, so
+ * the fillet is computed against the new (offset) corner, never the
+ * original centerline's. `laneOffset` of `0`/unset is a no-op
+ * (`applyLaneOffset` returns the identical points array), so every
+ * connection predating this field resolves byte-identical to before.
+ *
+ * Returns `null` when either endpoint can't be resolved to an element's
+ * absolute port position (e.g. it targets a group — group connection
+ * endpoints are Story 2.5 territory via `resolveGroupAwareConnectionGeometry`,
+ * out of scope here). Story 2.6 AC1: an `off-page` element's declared port
+ * DOES resolve here like any other element's — it needs exactly one
+ * terminable port so ordinary connections can end on it; only the visual
+ * stub and its structural exemption from the primitive-type registry are
+ * off-page-specific (see `structural-validator.ts`'s `CORE_NATIVE_TYPES`).
+ *
+ * `topology` (Story 2.3, Task 3) is an OPTIONAL third argument: when a
+ * caller passes the scene's built `TopologyGraph`, the route's `medium`
+ * resolves via the effective-medium precedence (`connection.medium ??` its
+ * topology edge's medium) instead of the connection's own field verbatim.
+ * Omitting it — every existing call site does, unchanged — reproduces
+ * exactly the Story 1.4-2.2 behavior byte-for-byte; this is purely which
+ * VALUE lands in `ResolvedRoute.medium`, never a change to routing/geometry.
+ */
+export declare function resolveConnectionGeometry(connection: Connection, scene: Scene, topology?: TopologyGraph): ResolvedRoute | null;
+export declare function toSegments(points: Point[]): Segment[];
+/**
+ * Corner-rounding math, shared verbatim by the manual/direct paths above
+ * and by Story 2.1's orthogonal generator (`orthogonal-router.ts`) — the
+ * generator only produces a waypoint list; rounding is already generic and
+ * stays exactly as 1.4 shipped it (clamped to half the shorter adjacent
+ * segment, sweep-flag from the turn's cross-product sign).
+ */
+export declare function roundedPolylinePoints(points: Point[], radius: number): {
+    segments: Segment[];
+    corners: Corner[];
+};
+/** SVG path `d` string for a resolved route — one `M`, then `L`/`A` pairs. */
+export declare function routeToPathData(route: ResolvedRoute): string;
+/** Angle (radians) of a segment's run direction — used to keep the cross-section gradient perpendicular (§7.1). */
+export declare function segmentAngle(segment: Segment): number;
+//# sourceMappingURL=connection-geometry.d.ts.map

package/dist/scene/connection-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-geometry.d.ts","sourceRoot":"","sources":["../../src/scene/connection-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAQ,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAI9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,KAAK,CAAC;CACX;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,wDAAwD;IACxD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,6HAA6H;IAC7H,WAAW,EAAE,cAAc,GAAG,SAAS,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,aAAa,GAAG,IAAI,CAsC9H;AA8CD,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,CAMrD;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA8BjH;AAyBD,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAa5D;AAED,mHAAmH;AACnH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAErD"}

package/dist/scene/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Zero-dependency constants shared by the always-on structural validator
+ * and the Zod schema. Kept in their own zod-free module so the public
+ * entry (`index.ts`) can re-export `SUPPORTED_SCENE_VERSIONS` as a runtime
+ * value WITHOUT creating a static import edge into `scene-schema.ts` — that
+ * edge would defeat production Zod-stripping (AC3) by pulling the whole
+ * schema module into the main bundle graph.
+ */
+export declare const SUPPORTED_SCENE_VERSIONS: readonly ["1.0"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/scene/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/scene/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,kBAAmB,CAAC"}

package/dist/scene/crossing-jumps.d.ts

@@ -0,0 +1,85 @@
+import type { Point, ResolvedRoute } from './connection-geometry';
+import type { Connection, Scene } from './scene-schema';
+/**
+ * Story 2.2, Tasks 2 & 3: crossing detection + jump-over splicing. Runs
+ * ONLY at scene-build time (AD-2) — `resolveSceneRoutes` is the intended
+ * single entry point; callers must invoke it once per scene load/change,
+ * never inside the animation/render loop. Pure functions throughout: no
+ * store, no clock, no `Math.random`, no object-iteration-order
+ * dependence — same scene in, same geometry out, always.
+ */
+/**
+ * Default jump-over arc radius: ~0.8x the reference pipe width — big
+ * enough to clearly read as a "hop" over the crossed pipe at reference
+ * scale, small enough not to visually dominate the route. Named
+ * constant per Story 2.1's precedent (no theme token exists for this;
+ * core has no theme access per AD-10).
+ */
+export declare const JUMP_ARC_RADIUS: number;
+/** A detected crossing, located on the route that will receive the jump
+ * (the LATER connection, by scene declaration order — see
+ * `detectCrossings`). */
+export interface Crossing {
+    point: Point;
+    /** Index into that route's `segments` array (pre-splice) where the crossing occurs. */
+    segmentIndex: number;
+    /** Parametric position (0..1) along that segment — orders multiple crossings on one segment before splicing. */
+    t: number;
+}
+export interface RoutedConnection {
+    connection: Connection;
+    route: ResolvedRoute | null;
+}
+/**
+ * Segment-intersection pass over every pair of resolved routes — O(n^2)
+ * segment pairs, acceptable at scene-build time per the story (a
+ * sweep-line upgrade is explicitly deferred until a real scene's
+ * connection count proves it necessary, same "optimize only if proven
+ * needed" discipline as 2.1's router).
+ *
+ * A crossing is only counted where the intersection point is STRICTLY
+ * interior to both segments (parametric position in the open interval
+ * `(epsilon, 1-epsilon)` on both). Two pipes that join at a shared
+ * port/junction always meet exactly AT one of their segment endpoints,
+ * so this rule excludes junctions for free — no separate "is this a
+ * junction" check is needed.
+ *
+ * Deterministic winner (Task 3's design decision, binding): every
+ * crossing is attributed to the connection at the LATER index in
+ * `routes` — i.e. later in the scene's declared `connections` array.
+ * That connection's route is the one meant to receive the jump-over
+ * arc; the earlier one stays a plain centerline. This makes the winner
+ * a pure function of declaration order alone, so the same scene always
+ * produces the same jump placement.
+ */
+export declare function detectCrossings(routes: ReadonlyArray<ResolvedRoute | null>): Map<number, Crossing[]>;
+/**
+ * Splices a small semicircular "jump-over" arc into `route` at each of
+ * `crossings` — automatic and unconfigurable per connection (§5.3: no
+ * opt-out in v1, don't add one). Multiple crossings on the same route
+ * are applied highest-segment-index (and, within a segment,
+ * highest-parametric-position) first, so each splice's index shift
+ * never invalidates a not-yet-applied crossing earlier in the list.
+ *
+ * Reuses the exact `Corner` shape corner-rounding already produces
+ * (`{from, to, radius, sweepFlag}`) — the pipe renderer and
+ * `routeToPathData` need no changes at all: an `A rx ry 0 0 sweep x y`
+ * arc is already what they draw between two segments, and for an exact
+ * semicircle (chord length == diameter, guaranteed here since `before`
+ * and `after` are each `radius` away from the crossing point along the
+ * same line) the large-arc-flag is immaterial — only `sweepFlag`
+ * chooses which of the two mirror semicircles is drawn, fixed here for
+ * determinism.
+ */
+export declare function spliceJumpOvers(route: ResolvedRoute, crossings: readonly Crossing[], radius?: number): ResolvedRoute;
+/**
+ * Scene-build-time-only orchestration (AD-2): resolves every
+ * connection's geometry (Story 2.2's lane-offset displacement is
+ * already applied inside `resolveConnectionGeometry`), detects every
+ * crossing between DIFFERENT connections' routes ONCE over the whole
+ * set, and splices jump-over arcs into each crossing's later-declared
+ * connection. Callers must invoke this exactly once per scene
+ * load/change — never inside the animation loop.
+ */
+export declare function resolveSceneRoutes(scene: Scene): RoutedConnection[];
+//# sourceMappingURL=crossing-jumps.d.ts.map

package/dist/scene/crossing-jumps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossing-jumps.d.ts","sourceRoot":"","sources":["../../src/scene/crossing-jumps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,KAAK,EAAE,aAAa,EAAW,MAAM,uBAAuB,CAAC;AAGnF,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,QAA6B,CAAC;AAE1D;;yBAEyB;AACzB,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,KAAK,CAAC;IACb,uFAAuF;IACvF,YAAY,EAAE,MAAM,CAAC;IACrB,gHAAgH;IAChH,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;CAC7B;AAiBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAoBpG;AA0BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,QAAQ,EAAE,EAAE,MAAM,GAAE,MAAwB,GAAG,aAAa,CAmCrI;AA6FD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,gBAAgB,EAAE,CAenE"}

package/dist/scene/dev-validate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dev-only Zod diagnostics layer (AC3). Runs AFTER the structural gate has
+ * already passed — this never gates rendering, it only surfaces richer
+ * validation issues Zod catches that the lightweight structural validator
+ * does not (e.g. wrong enum value, negative canvas dimensions).
+ *
+ * The `import.meta.env.DEV` guard is a Vite build-time constant: `vite
+ * build` (production mode) statically replaces it with `false`, after
+ * which esbuild's minifier eliminates this function's body as unreachable
+ * — including the dynamic `import('./scene-schema')` — so the Zod runtime
+ * never ships in the production bundle. Verified empirically by
+ * `test/bundle.prod.test.ts`, not just asserted here.
+ */
+export interface ZodDiagnostic {
+    path: string;
+    message: string;
+}
+/**
+ * Returns `null` when diagnostics are skipped (not a dev build). Returns an
+ * array (possibly empty) when running in dev: empty means Zod found no
+ * additional issues beyond the structural gate.
+ */
+export declare function validateSceneWithZod(raw: unknown): Promise<ZodDiagnostic[] | null>;
+//# sourceMappingURL=dev-validate.d.ts.map

package/dist/scene/dev-validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-validate.d.ts","sourceRoot":"","sources":["../../src/scene/dev-validate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,CAexF"}

package/dist/scene/errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Structural validation error codes (AD-8). Hand-rolled union, not derived
+ * from Zod — this file has zero Zod dependency so it survives production
+ * bundling unconditionally, same as the validator that uses it.
+ */
+export declare const SCENE_ERROR_CODES: readonly ["MISSING_VERSION", "UNSUPPORTED_VERSION", "BAD_SHAPE", "DUPLICATE_ID", "UNKNOWN_TYPE", "UNRESOLVED_PORT", "UNRESOLVED_TOPOLOGY_REF", "AMBIGUOUS_GROUP_PORT_MAP", "UNRESOLVED_GROUP_PORT_MAP", "AMBIGUOUS_GROUP_CHILD"];
+export type SceneErrorCode = (typeof SCENE_ERROR_CODES)[number];
+/** Error envelope per spine conventions: `{ code, message, path? }`. */
+export interface SceneErrorDetail {
+    code: SceneErrorCode;
+    message: string;
+    path: string;
+}
+export declare function sceneError(code: SceneErrorCode, message: string, path: string): SceneErrorDetail;
+//# sourceMappingURL=errors.d.ts.map

package/dist/scene/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/scene/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,kOAWpB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,wEAAwE;AACxE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAEhG"}