@vscada/core 0.0.1

package/dist/interaction/gesture-arbiter.d.ts

@@ -0,0 +1,20 @@
+export type Gesture = 'tap' | 'drag';
+/** CSS px slop — a pointerup within this distance of its pointerdown counts as a tap, not a drag (§D5). */
+export declare const TAP_SLOP_PX = 10;
+/**
+ * Story 4.2 Task 2 — the shared single-pointer tap/drag classifier. This
+ * is the "shared gesture arbiter" Story 4.3's pan/pinch handling plugs
+ * into alongside (multi-pointer pinch detection is explicitly out of this
+ * story's scope, per Dev Notes — see the story file). Per-pointer state is
+ * tracked by `pointerId` so concurrent pointers (e.g. a two-finger pinch
+ * starting) don't interfere with each other's classification.
+ */
+export interface GestureArbiter {
+    onPointerDown(pointerId: number, x: number, y: number): void;
+    /** 'tap' if the pointer never moved past the slop threshold since its pointerdown, 'drag' otherwise (including an untracked pointerId — e.g. one already discarded by `onPointerCancel`). */
+    onPointerUp(pointerId: number, x: number, y: number): Gesture;
+    /** Discards tracking for a pointer without classifying it (pointercancel — a resolved gesture must never look like a tap). */
+    onPointerCancel(pointerId: number): void;
+}
+export declare function createGestureArbiter(slopPx?: number): GestureArbiter;
+//# sourceMappingURL=gesture-arbiter.d.ts.map

package/dist/interaction/gesture-arbiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gesture-arbiter.d.ts","sourceRoot":"","sources":["../../src/interaction/gesture-arbiter.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAErC,2GAA2G;AAC3G,eAAO,MAAM,WAAW,KAAK,CAAC;AAO9B;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7D,6LAA6L;IAC7L,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9D,8HAA8H;IAC9H,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1C;AAED,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,MAAoB,GAAG,cAAc,CAiBjF"}

package/dist/interaction/hit-area.d.ts

@@ -0,0 +1,44 @@
+/** Minimum tappable target, CSS px (§D5, NFR6 — iPad-size touch). */
+export declare const MIN_HIT_AREA_CSS_PX = 44;
+export interface HitAreaBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * Scale-aware hit-area geometry (Story 4.2 Task 1). `zoom` is the
+ * scene-units-to-CSS-px multiplier (`ScadaView.zoom`, default 1 — Story
+ * 4.3 wires pinch gestures to it; this story only consumes it). The
+ * physical 44px floor is converted to SCENE units by dividing by zoom, so
+ * the rendered hit rect always covers at least `minCssPx` of screen space
+ * regardless of how far the view is zoomed. Centered over the symbol's
+ * own local (0,0-origin) w×h bounding box — a symbol already at/above the
+ * floor is left untouched (never shrunk).
+ */
+export declare function computeHitAreaBox(symbolW: number, symbolH: number, zoom: number, minCssPx?: number): HitAreaBox;
+/**
+ * Invisible rect catching taps (AC1). `fill="transparent"` (not `none` —
+ * a `fill:none` rect has an empty hit-test region despite
+ * `pointer-events:all`). `ScadaView.interactive` gates whether a click
+ * ever gets DISPATCHED (see `pointer-pipeline.ts`), not whether this rect
+ * exists — it is always built as part of structure (AD-2).
+ */
+export declare function buildHitArea(symbolW: number, symbolH: number, zoom: number, origin?: {
+    x: number;
+    y: number;
+}): SVGRectElement;
+/**
+ * Story 4.3 Task 1 — recomputes an ALREADY-BUILT hit rect's box for a NEW
+ * zoom, in place (four attribute writes, no rebuild). This is the "hit
+ * areas recompute per 4.2, that's all" half of the Dev Notes' zoom design
+ * decision: the root viewport `<g>` transform (`ScadaView`'s own doc)
+ * handles the visual scale of everything else; only the hit-area's
+ * SCENE-UNIT size needs to keep tracking zoom to hold its physical
+ * on-screen floor constant, since it lives inside that SAME scaled group.
+ */
+export declare function updateHitAreaBox(rect: SVGRectElement, symbolW: number, symbolH: number, zoom: number, origin?: {
+    x: number;
+    y: number;
+}): void;
+//# sourceMappingURL=hit-area.d.ts.map

package/dist/interaction/hit-area.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hit-area.d.ts","sourceRoot":"","sources":["../../src/interaction/hit-area.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAA4B,GAAG,UAAU,CAUpI;AAID;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAmB,GAAG,cAAc,CAoB9I;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAmB,GAChD,IAAI,CAMN"}

package/dist/interaction/pan-zoom-gestures.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Multiplicative zoom-per-wheel-delta-px — a documented default, not
+ * spec-pinned (same convention as `wave-layer.ts`'s `BASE_WAVE_DURATION_MS`):
+ * `factor = exp(-deltaY * sensitivity)` gives a smooth, runaway-free
+ * multiplicative zoom from the browser's native wheel `deltaY` (positive =
+ * scroll away from the user = zoom out, matching the platform default).
+ */
+export declare const WHEEL_ZOOM_SENSITIVITY = 0.0015;
+export interface PanZoomCallbacks {
+    /** Pans the viewport by a screen-px delta (drag-pan / pinch-pan). */
+    onPan(dx: number, dy: number): void;
+    /** Zooms to an ABSOLUTE target while keeping `(centerX, centerY)` stationary (pinch centroid / wheel cursor position). */
+    onZoomAboutPoint(target: number, centerX: number, centerY: number): void;
+    /** Current zoom — read fresh on every pinch/wheel step so the gesture composes correctly with an externally-driven `.zoom = x` animation running concurrently. */
+    getZoom(): number;
+}
+export interface PanZoomGestureController {
+    onPointerDown(pointerId: number, x: number, y: number): void;
+    onPointerMove(pointerId: number, x: number, y: number): void;
+    onPointerUp(pointerId: number): void;
+    onPointerCancel(pointerId: number): void;
+    onWheel(deltaY: number, x: number, y: number): void;
+}
+/**
+ * Story 4.3 Task 1 — pinch (two-pointer) + drag-pan (single-pointer, past
+ * the SAME slop `GestureArbiter` uses) + wheel-zoom, all driving
+ * `ViewportStateController` via the callbacks above. Deliberately its OWN
+ * per-pointer tracking, separate from `GestureArbiter` (whose job stays
+ * tap-vs-drag classification for `element-click`, per pointer, at
+ * pointerup) — "tap yields to gestures" falls out for free: any pointer
+ * this controller pans has, by construction, moved past the identical
+ * slop threshold, so `GestureArbiter`'s own independent distance check on
+ * that same pointerup already classifies it 'drag', never 'tap'. No
+ * coupling between the two is needed.
+ *
+ * Attach this controller's callbacks to pointer events on the SVG ROOT
+ * (not per-element) — Pointer Events bubble, so it observes every pointer
+ * including ones that started over an element's hit area; this component
+ * has no drag-to-reposition affordance, so any drag anywhere pans the
+ * camera.
+ */
+export declare function createPanZoomGestures(callbacks: PanZoomCallbacks, slopPx?: number): PanZoomGestureController;
+//# sourceMappingURL=pan-zoom-gestures.d.ts.map

package/dist/interaction/pan-zoom-gestures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pan-zoom-gestures.d.ts","sourceRoot":"","sources":["../../src/interaction/pan-zoom-gestures.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,SAAS,CAAC;AAE7C,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,0HAA0H;IAC1H,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACzE,kKAAkK;IAClK,OAAO,IAAI,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACvC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7D,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7D,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrD;AAkBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,gBAAgB,EAAE,MAAM,GAAE,MAAoB,GAAG,wBAAwB,CA4EzH"}

package/dist/interaction/pointer-pipeline.d.ts

@@ -0,0 +1,38 @@
+import type { GestureArbiter } from './gesture-arbiter';
+export interface ElementClickDetail {
+    elementId: string;
+    tags: string[];
+    elementType: string;
+}
+/** `element-hover` event detail (§3.4) — fine-pointer-only, see `ScadaView._dispatchElementHover`. */
+export interface ElementHoverDetail {
+    elementId: string;
+    tags: string[];
+}
+export interface ElementInteractionOptions {
+    elementId: string;
+    elementType: string;
+    /** The element's bound tag names (Task 2 — `element-click`'s `tags` field). */
+    tags: string[];
+    /** Shared across every attached element on one `<scada-view>` instance (persists across rebuilds so a drag begun before a rebuild still resolves correctly). */
+    arbiter: GestureArbiter;
+    /** Re-checked on every pointerup — `ScadaView.interactive`'s "cheap global toggle" (AC3), no rebuild needed to flip it. */
+    isInteractive(): boolean;
+    onClick(detail: ElementClickDetail): void;
+    /** Omit for targets with no hover behavior (e.g. this story doesn't require hover on plain elements — connections/groups may choose not to pass this). */
+    onHoverChange?(hovering: boolean): void;
+}
+/**
+ * Story 4.2 Task 2 — one Pointer Events pipeline, no separate touch/mouse
+ * handlers (the story's own design decision: forking is how tap/hover bugs
+ * breed). A tap is a pointerdown+pointerup pair the shared `arbiter`
+ * classifies as within slop; a pan/pinch gesture (Story 4.3) fails that
+ * check for free since it reuses the same arbiter instance, so it never
+ * produces a spurious click. `element-hover` is gated to
+ * `pointerType === 'mouse'` — the identical fine-pointer gate Story 2.4's
+ * upstream highlight already applies (`isFinePointerHover` in
+ * `topology/upstream-highlight.ts`), so touch never triggers hover-only
+ * behavior (AC2).
+ */
+export declare function attachElementInteraction(target: Element, options: ElementInteractionOptions): void;
+//# sourceMappingURL=pointer-pipeline.d.ts.map

package/dist/interaction/pointer-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer-pipeline.d.ts","sourceRoot":"","sources":["../../src/interaction/pointer-pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,sGAAsG;AACtG,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,gKAAgK;IAChK,OAAO,EAAE,cAAc,CAAC;IACxB,2HAA2H;IAC3H,aAAa,IAAI,OAAO,CAAC;IACzB,OAAO,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC1C,0JAA0J;IAC1J,aAAa,CAAC,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,yBAAyB,GAAG,IAAI,CAwClG"}

package/dist/license/console-notice.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Story 6.3 Task 3 — the SOLE production console output permitted
+ * anywhere in this library. Fires at most once per page load, not once
+ * per `<scada-view>` instance.
+ *
+ * AC1's literal wording is "one console notice per instance"; this
+ * deliberately deviates. N instances on a multi-view dashboard each
+ * logging their own copy is noise, not a notice — six identical lines is
+ * worse UX than one. Decision (recorded per Dev Notes' instruction):
+ * once per page, mentioning the affected instance count when >1.
+ */
+export declare function maybeLogUnlicensedNotice(instanceCount: number): void;
+/** Test-only: resets the once-flag between test files. */
+export declare function __resetConsoleNoticeForTests(): void;
+//# sourceMappingURL=console-notice.d.ts.map

package/dist/license/console-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-notice.d.ts","sourceRoot":"","sources":["../../src/license/console-notice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAQpE;AAED,0DAA0D;AAC1D,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD"}

package/dist/license/format.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Mirrors `tools/license-cli/KEY-FORMAT.md` (Story 6.1) — core only ever
+ * VERIFIES license keys, never issues them, so only the parse half of
+ * that contract lives here. Deliberately duplicated rather than imported:
+ * AD-10 forbids any `packages/*` → `tools/*` dependency (vendor tooling
+ * must never ship in a customer bundle). Keep both sides in sync by hand
+ * on a format-version bump; the committed fixtures in
+ * `tools/license-cli/fixtures/` are the cross-check that they still agree.
+ */
+export interface LicensePayload {
+    company: string;
+    /** ISO calendar date, `YYYY-MM-DD`. */
+    expiry: string;
+    tier: string;
+    keyId: string;
+}
+export interface ParsedLicenseKey {
+    version: string;
+    encodedPayload: string;
+    payload: LicensePayload;
+    signature: Uint8Array<ArrayBuffer>;
+}
+/** Web-standard `atob`/`TextEncoder`/`TextDecoder` only — this runs in the browser, unlike 6.1's Node-side CLI. */
+export declare function base64UrlToBytes(text: string): Uint8Array<ArrayBuffer> | null;
+/** Returns `null` on any malformed input rather than throwing — a bad key is never a code path into an error, only ever an "unlicensed" verdict. */
+export declare function parseLicenseKey(key: string): ParsedLicenseKey | null;
+/** The exact byte sequence that was signed — see KEY-FORMAT.md. */
+export declare function licenseSigningMessage(version: string, encodedPayload: string): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=format.d.ts.map

package/dist/license/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/license/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,cAAc,CAAC;IACxB,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;CACpC;AAID,mHAAmH;AACnH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI,CAW7E;AAaD,oJAAoJ;AACpJ,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAoBpE;AAED,mEAAmE;AACnE,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAEtG"}

package/dist/license/state.d.ts

@@ -0,0 +1,43 @@
+import { type LicensePayload } from './format';
+export type LicenseStatus = 'unlicensed' | 'pending' | 'licensed';
+export interface LicenseVerdict {
+    status: LicenseStatus;
+    payload?: LicensePayload;
+}
+/**
+ * Pure resolution logic — fully testable against 6.1's committed fixtures
+ * without touching module-level state. `setLicenseKey` below is the thin,
+ * stateful, cached wrapper real consumers call.
+ */
+export declare function resolveLicenseVerdict(key: string, publicKeys: Record<string, JsonWebKey>, now: number, buildReleaseDate: string): Promise<LicenseVerdict>;
+export declare function registerScadaViewInstance(): void;
+export declare function unregisterScadaViewInstance(): void;
+export declare function getConnectedInstanceCount(): number;
+/**
+ * Module-level `setLicenseKey()` (AC1/Design Decisions) — one call
+ * licenses every `<scada-view>` instance on the page, matching
+ * per-company (not per-view) licensing. Verification is async and never
+ * blocks or throws into a render path (Design Decisions: "verification
+ * is advisory to rendering, authoritative to watermark" — 6.3 owns what a
+ * `pending`/`unlicensed` verdict does visually; this module only produces
+ * the verdict and caches it per key string).
+ *
+ * AD-4 note (architecture-code-audit-2026-08-27): the call below reads
+ * outside the injected `TimeSource` — already reviewed and allow-listed
+ * by `core/test/no-date-now.test.ts` (see that file's own rationale: a
+ * calendar-date expiry comparison needs real wall-clock time, and
+ * `TimeSource.now()`'s relative/replayable tick is the wrong unit and
+ * would let playback mode fool license expiry). This module-level
+ * function also has no single natural `TimeSource` to inject regardless
+ * (page-global state, zero-to-many `<scada-view>` instances). Testability
+ * doesn't depend on it either: `resolveLicenseVerdict` just below already
+ * takes `now` as an explicit parameter, which is what `license.test.ts`'s
+ * expiry-matrix tests call directly, bypassing this wrapper.
+ */
+export declare function setLicenseKey(key: string): void;
+export declare function getLicenseVerdict(): LicenseVerdict;
+/** Returns an unsubscribe function; fires immediately with the current verdict on subscribe (6.3's watermark consumes this). */
+export declare function onLicenseVerdict(listener: (verdict: LicenseVerdict) => void): () => void;
+/** Test-only: clears module-level license state between test files. */
+export declare function __resetLicenseStateForTests(): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/license/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/license/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,cAAc,EAAmB,MAAM,UAAU,CAAC;AAcvF,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,SAAS,GAAG,UAAU,CAAC;AAElE,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B;AAsBD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACtC,GAAG,EAAE,MAAM,EACX,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,cAAc,CAAC,CAkBzB;AAgBD,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAOD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAe/C;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED,gIAAgI;AAChI,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,GAAG,MAAM,IAAI,CAIxF;AAED,uEAAuE;AACvE,wBAAgB,2BAA2B,IAAI,IAAI,CAMlD"}

package/dist/license/vendor-keys.d.ts

@@ -0,0 +1,12 @@
+/**
+ * keyId → public JWK, embedded in core at build time by hand-editing this
+ * file. Empty until the vendor generates its first production keypair
+ * (`tools/license-cli` `keygen`) — see `tools/license-cli/RUNBOOK.md`'s
+ * rotation procedure, step 3, which is exactly this file. An empty map
+ * means every key is `UNKNOWN_KEY_ID` (safe default: nothing verifies
+ * until a real vendor keypair is deliberately embedded here).
+ *
+ * Never put a private key anywhere near this file or this package.
+ */
+export declare const VENDOR_PUBLIC_KEYS: Record<string, JsonWebKey>;
+//# sourceMappingURL=vendor-keys.d.ts.map

package/dist/license/vendor-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor-keys.d.ts","sourceRoot":"","sources":["../../src/license/vendor-keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,CAAC"}

package/dist/license/verify-fallback.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Fallback verifier (AC1, AD-9) — used when `crypto.subtle` is absent
+ * (insecure contexts are normal on intranet HMIs). `@noble/curves` v2.2.0,
+ * MIT, audited (Trail of Bits/Kudelski/Cure53 across its history, no open
+ * advisories as of this story — checked on the web at implementation
+ * time per the Dev Notes instruction; see Dev Agent Record). Chosen over
+ * a hand-rolled P-256 verifier: raw elliptic-curve point arithmetic is
+ * exactly the kind of code where a subtle bug is a silent security hole,
+ * not a visible bug — an audited library is the correct trade for ~a few
+ * KB of bundle size.
+ *
+ * `p256.verify(signature, message, publicKey)` hashes `message` with
+ * SHA-256 internally by default — the same default WebCrypto's
+ * `{name:'ECDSA', hash:'SHA-256'}` and Node's `dsaEncoding:'ieee-p1363'`
+ * use, confirmed empirically against 6.1's fixtures (not just asserted
+ * from docs) before this file was written. No separate hashing step, no
+ * extra `@noble/hashes` dependency needed here.
+ *
+ * `{ lowS: false }` is required: noble enforces low-S canonical
+ * signatures by default and REJECTS a mathematically valid signature
+ * whose `s` happens to be > curve-order/2. Neither Node's `crypto.sign`
+ * (6.1's issuer) nor WebCrypto's `subtle.sign`/`subtle.verify`
+ * (`verify-webcrypto.ts`) normalize to or require low-S — ECDSA doesn't
+ * mandate it, only some ecosystems (e.g. Bitcoin) add it as policy — so
+ * roughly half of all real signatures would silently and incorrectly
+ * fail here without this option. Found by 6.1's own fixture set failing
+ * against this file specifically (passing on the WebCrypto path) — see
+ * Dev Agent Record and the KEY-FORMAT.md addendum.
+ */
+export declare function verifyWithFallback(message: Uint8Array<ArrayBuffer>, signature: Uint8Array<ArrayBuffer>, publicKeyJwk: JsonWebKey): boolean;
+//# sourceMappingURL=verify-fallback.d.ts.map

package/dist/license/verify-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-fallback.d.ts","sourceRoot":"","sources":["../../src/license/verify-fallback.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAQ1I"}

package/dist/license/verify-webcrypto.d.ts

@@ -0,0 +1,4 @@
+/** Primary verifier path (AC1) — used whenever `crypto.subtle` exists. Never throws: any failure (missing subtle, malformed JWK, wrong signature) resolves `false`. */
+export declare function isWebCryptoAvailable(): boolean;
+export declare function verifyWithWebCrypto(message: Uint8Array<ArrayBuffer>, signature: Uint8Array<ArrayBuffer>, publicKeyJwk: JsonWebKey): Promise<boolean>;
+//# sourceMappingURL=verify-webcrypto.d.ts.map

package/dist/license/verify-webcrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-webcrypto.d.ts","sourceRoot":"","sources":["../../src/license/verify-webcrypto.ts"],"names":[],"mappings":"AAAA,uKAAuK;AAEvK,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAS1J"}

package/dist/license/watermark.d.ts

@@ -0,0 +1,20 @@
+export interface WatermarkOverlay {
+    /** Insert as the FIRST child of the canvas — below every scene element, so equipment visually "erases" the pattern over itself (non-obstruction via z-order). */
+    repeat: SVGGElement;
+    /** Insert as the LAST child — a fixed corner badge, always legible (non-obstruction via position: real schematics rarely put equipment in a canvas corner). */
+    badge: SVGGElement;
+    setVisible(visible: boolean): void;
+}
+/**
+ * Fail-soft trial watermark (Story 6.3, AC1). Philosophy — an honesty
+ * mechanism, not DRM: client-side enforcement is legal-teeth-plus-
+ * friction, nothing more (session decision, spec-amendments C1). Do NOT
+ * escalate this file into a MutationObserver arms race or add
+ * obfuscation/re-assertion-on-tamper logic beyond "rebuilt whenever the
+ * scene rebuilds" if a future ticket asks for "harder" enforcement —
+ * that contradicts SPEC C5/AD-9's fail-soft safety posture (a lapsed
+ * subscription must never darken a control-room screen) and should be
+ * refused at review, not implemented.
+ */
+export declare function buildWatermarkOverlay(canvasWidth: number, canvasHeight: number, defs: SVGDefsElement): WatermarkOverlay;
+//# sourceMappingURL=watermark.d.ts.map

package/dist/license/watermark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watermark.d.ts","sourceRoot":"","sources":["../../src/license/watermark.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,gBAAgB;IAC/B,iKAAiK;IACjK,MAAM,EAAE,WAAW,CAAC;IACpB,+JAA+J;IAC/J,KAAK,EAAE,WAAW,CAAC;IACnB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,gBAAgB,CAkDvH"}

package/dist/media/registry.d.ts

@@ -0,0 +1,97 @@
+import type { TopologyGraph } from '../topology/graph';
+/**
+ * Medium registry — styling half (§7.4, Story 2.3 Task 3). TypeScript
+ * shape only: real per-medium values (color/dash/speed) live in theme
+ * packages (classic-hmi ships water, steam, flue-gas, ash, condensate,
+ * electrical), resolved the same way every other token group is (AD-7).
+ *
+ * Deliberately narrow today — `MediumStyle` is the STYLING half only.
+ * Story 3.2 extends it additively with wave/visual params (amplitude,
+ * period, speed, specular, meniscus, bubbles, per §7.4's full table); this
+ * shape is designed so that extension never needs a breaking change here,
+ * so it stays a flat, easily-widened interface rather than something
+ * pre-built with unused fields now.
+ */
+export interface MediumDashSignature {
+    /** Dash length, px, at reference scale. */
+    length: number;
+    /** Gap length, px. */
+    gap: number;
+    opacity: number;
+}
+/** §7.4's `specular` field — how the medium's surface highlight reads (Story 3.2). */
+export type SpecularStyle = 'sharp' | 'diffuse' | 'none';
+/**
+ * Vapor-media plume parameters (steam, flue-gas) — §7.4's table row for
+ * those two rows says "plume, drifting opacity" with no liquid wave at
+ * all. Defined now so the registry shape is complete per the spec table;
+ * consumed by a future Story 3.8 plume renderer, no rendering here.
+ */
+export interface MediumPlumeStyle {
+    opacity: number;
+    driftSpeed: number;
+}
+export interface MediumStyle {
+    color: string;
+    dashSignature: MediumDashSignature;
+    /**
+     * Multiplier applied to the pipe's registered flow-dash animation (1 =
+     * reference speed). This scales the SAME AD-5-registered animation
+     * handle the pipe primitive already creates — never a second,
+     * medium-driven control path.
+     */
+    animationSpeedFactor: number;
+    /**
+     * Story 3.2 — the motion/visual half of §7.4 (vessel liquid wave/surface
+     * character). All optional: Story 2.3's pipe-only media (`ash`,
+     * `electrical`) never declare them, and the pipe primitive never reads
+     * them — additive extension, no existing consumer's meaning changes.
+     */
+    opacity?: number;
+    /** Wave crest height, px at reference scale. */
+    waveAmplitude?: number;
+    /** Wave horizontal period, px at reference scale — the seamless-loop translate distance (§7.3). */
+    wavePeriod?: number;
+    /** Multiplier applied to the wave loop's registered WAAPI playbackRate (1 = reference speed; oil ≈ 0.5 — "viscosity reads as slowness"). */
+    waveSpeed?: number;
+    specular?: SpecularStyle;
+    /** Darker/lighter tint at the vessel walls where the surface meets glass (§7.4's table; boolean flag — no geometry implied). */
+    meniscus?: boolean;
+    /** Steam/flue-gas only — see `MediumPlumeStyle`. */
+    plume?: MediumPlumeStyle;
+}
+export interface MediumTokens {
+    /** Medium name (kebab-case, e.g. "flue-gas") -> style. */
+    styles: Record<string, MediumStyle>;
+    /** Fallback medium name used when a pipe's resolved medium isn't registered, or has none at all. */
+    defaultMedium?: string;
+}
+/** Looks up a medium's style with graceful, literal-color-free degradation (AD-3/AD-7): unregistered theme or unknown medium name both resolve to `undefined`, never a hardcoded fallback color. */
+export declare function resolveMediumStyle(mediaTokens: MediumTokens | undefined, mediumName: string | undefined): MediumStyle | undefined;
+/**
+ * Story 3.2 Task 2 — §7.4: "Clients pick a name; power users override
+ * fields." A scene's `media` block (Story 1.2's `MediaSchema`, keyed by
+ * medium NAME, each value a record of per-field overrides) always wins
+ * over the theme-registered preset for that same medium name; fields the
+ * override doesn't mention keep the preset's value. This is a MERGE on top
+ * of `resolveMediumStyle`'s existing name/defaultMedium resolution — never
+ * a second, parallel medium-lookup path. Returns `undefined` under the
+ * exact same conditions `resolveMediumStyle` would (no tokens, unknown
+ * medium with no default) — overrides can refine a resolved style, never
+ * conjure one out of nothing.
+ */
+export declare function resolveEffectiveMediumStyle(mediaTokens: MediumTokens | undefined, mediumName: string | undefined, sceneMediaOverrides: Record<string, Record<string, unknown>> | undefined): MediumStyle | undefined;
+/**
+ * Medium inheritance precedence (Task 3): a connection's own `medium` field
+ * always wins; otherwise fall back to its topology edge's medium (matched
+ * by id — a topology edge's `id` corresponds to the connection it
+ * describes, §5.4). A connection with no topology edge at all (or no
+ * medium anywhere) resolves to `undefined` — the pipe primitive/theme
+ * layer handles that via `resolveMediumStyle`'s own default-medium
+ * fallback, not here.
+ */
+export declare function resolveEffectiveMedium(connection: {
+    id: string;
+    medium?: string;
+}, graph: TopologyGraph): string | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/media/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/media/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,sFAAsF;AACtF,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,mBAAmB,CAAC;IACnC;;;;;OAKG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mGAAmG;IACnG,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4IAA4I;IAC5I,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,gIAAgI;IAChI,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oDAAoD;IACpD,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpC,oGAAoG;IACpG,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,oMAAoM;AACpM,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAKjI;AAgCD;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,YAAY,GAAG,SAAS,EACrC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GACvE,WAAW,GAAG,SAAS,CAMzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,CAG5H"}

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

@@ -0,0 +1,5 @@
+import type { ConnectionRenderModule } from '../contracts/connection-renderer';
+export declare function registerConnectionRenderer(module: ConnectionRenderModule): void;
+export declare function getConnectionRenderer(): ConnectionRenderModule | undefined;
+export declare function __resetConnectionRegistryForTests(): void;
+//# sourceMappingURL=connection-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connection-registry.d.ts","sourceRoot":"","sources":["../../src/registry/connection-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAS/E,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAE/E;AAED,wBAAgB,qBAAqB,IAAI,sBAAsB,GAAG,SAAS,CAE1E;AAED,wBAAgB,iCAAiC,IAAI,IAAI,CAExD"}