@vscada/primitives 0.0.1

package/dist/vapor/story-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story-kit.d.ts","sourceRoot":"","sources":["../../src/vapor/story-kit.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,SAAS,EACT,KAAK,OAAO,EACZ,KAAK,QAAQ,EAEb,KAAK,QAAQ,EAEb,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AAoCtB,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,gFAAgF;IAChF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAwCD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,SAAS,CAAC;IACnB,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;IACpC,QAAQ,IAAI,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,kIAAkI;IAClI,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,GAAE,sBAA2B,GAAG,iBAAiB,CAkBxJ"}

package/dist/vapor.js

@@ -0,0 +1,194 @@
+import { resolveEmissionIntensity as e, resolveMediumStyle as t } from "@vscada/core";
+function n(e, t, n, r) {
+	return t + n * Math.sin(2 * Math.PI * e / r);
+}
+function r(e, t, r, i, a = 6) {
+	let o = [], s = a > 0 ? a : 6;
+	for (let a = 0; a < e; a += s) o.push({
+		x: n(a, t, r, i),
+		y: a
+	});
+	return o.push({
+		x: n(e, t, r, i),
+		y: e
+	}), o;
+}
+function i(e, t, n, i, a = 6) {
+	let o = r(e, t, n, i, a), s = [...o].reverse();
+	return [
+		...o.map((e, t) => `${t === 0 ? "M" : "L"}${e.x},${e.y}`),
+		...s.map((e) => `L${-e.x},${e.y}`),
+		"Z"
+	].join(" ");
+}
+//#endregion
+//#region src/motion/seamless-loop.ts
+function a(e, t, n, r, i) {
+	let a = t === "x" ? "translateX(0px)" : "translateY(0px)", o = t === "x" ? `translateX(-${n}px)` : `translateY(-${n}px)`;
+	return i.animateTransform(e, [a, o], r);
+}
+//#endregion
+//#region src/vapor/billow-layer.ts
+var o = "http://www.w3.org/2000/svg", s = 3e3;
+function c(e, t) {
+	let { containerHeight: n, centerX: r, baseHalfWidth: c, wobble: l, period: u, color: d, durationMs: f = s } = e, p = i(n + u, c, l, u), m = document.createElementNS(o, "g");
+	m.setAttribute("class", "vscada-vapor-billow-carrier"), m.setAttribute("transform", `translate(${r}, 0)`);
+	let h = document.createElementNS(o, "g");
+	h.setAttribute("class", "vscada-vapor-billow-loop"), m.appendChild(h);
+	let g = document.createElementNS(o, "path");
+	return g.setAttribute("class", "vscada-vapor-billow-fill"), g.setAttribute("d", p), g.setAttribute("fill", d), g.setAttribute("fill-opacity", "0"), g.setAttribute("stroke", "none"), h.appendChild(g), {
+		carrier: m,
+		fill: g,
+		control: a(h, "y", u, f, t)
+	};
+}
+//#endregion
+//#region src/vapor/base.ts
+function l(e) {}
+function u(t) {
+	let { element: n, group: r, layers: i, staticGlyph: a, plumeStyle: o, brightnessFactor: s = 1, onWarning: c = l } = t, u = n.bindings.find((e) => e.type === "emission");
+	if (!u) return { handles: {} };
+	let d = {
+		kind: "numeric",
+		write(t, n) {
+			n < 0 && c({
+				code: "NEGATIVE_EMISSION_VALUE",
+				message: `Tag "${u.tag}": emission value ${n} is negative`,
+				tag: u.tag
+			});
+			let l = e(u, n);
+			t.setAttr(r, "opacity", l > 0 ? "1" : "0");
+			let d = Math.min(1, l * o.opacity * s);
+			for (let e of i) t.setAttr(e.fill, "fill-opacity", String(d)), e.control.setPlaybackRate(l * o.driftSpeed);
+			a && t.setAttr(a, "fill-opacity", String(d));
+		}
+	};
+	return { handles: { [u.tag]: d } };
+}
+function d(e, t, n) {
+	if (!n) return {};
+	let r = n, i = {
+		kind: "static-representation",
+		activate() {
+			for (let e of t) e.carrier.style.display = "none";
+			r.style.display = "";
+		},
+		deactivate() {
+			for (let e of t) e.carrier.style.display = "";
+			r.style.display = "none";
+		}
+	};
+	return { [`__vapor-static-representation-${e}`]: i };
+}
+function f(e, t) {
+	return t.length === 0 ? {} : { [`__vapor-drift-animation-${e}`]: {
+		kind: "animation",
+		pause() {
+			for (let e of t) e.control.pause();
+		},
+		resume() {
+			for (let e of t) e.control.resume();
+		},
+		seek(e) {
+			for (let n of t) n.control.seek(e);
+		}
+	} };
+}
+//#endregion
+//#region src/vapor/plume/index.ts
+var p = "http://www.w3.org/2000/svg", m = 3, h = .35, g = .9, _ = .6;
+function v(e, n, r) {
+	let a = document.createElementNS(p, "g");
+	a.setAttribute("data-element-id", e.id), a.setAttribute("class", "vscada-vapor-plume"), a.setAttribute("opacity", "0");
+	let o = t(n.tokens.medium, e.medium);
+	if (!o?.plume) return {
+		svg: a,
+		handles: {}
+	};
+	let { w: l, h: v } = e, y = l / 2, b = Math.max(8, v * g), x = [];
+	for (let e = 0; e < m; e++) {
+		let t = Math.max(2, l / 2 * (1 - e * .18)), n = c({
+			containerHeight: v,
+			centerX: y,
+			baseHalfWidth: t,
+			wobble: t * h,
+			period: b,
+			color: o.color,
+			durationMs: s * (1 + e * _)
+		}, r);
+		a.appendChild(n.carrier), x.push(n);
+	}
+	let S = document.createElementNS(p, "path");
+	S.setAttribute("class", "vscada-vapor-plume-static"), S.setAttribute("transform", `translate(${y}, 0)`), S.setAttribute("d", i(v, l * .32, l * .32 * h, b)), S.setAttribute("fill", o.color), S.setAttribute("fill-opacity", "0"), S.setAttribute("stroke", "none"), S.style.display = "none", a.appendChild(S);
+	let C = u({
+		element: e,
+		group: a,
+		layers: x,
+		staticGlyph: S,
+		plumeStyle: o.plume
+	}), w = f(e.id, x), T = d(e.id, x, S);
+	return {
+		svg: a,
+		handles: {
+			...C.handles,
+			...w,
+			...T
+		}
+	};
+}
+var y = Object.freeze({
+	group: "vapor",
+	primitives: Object.freeze({ plume: { build: v } })
+}), b = "http://www.w3.org/2000/svg", x = 2, S = .3, C = .7, w = .5, T = .4, E = 1.6, D = "steam";
+function O(e, n, r) {
+	let a = document.createElementNS(b, "g");
+	a.setAttribute("data-element-id", e.id), a.setAttribute("class", "vscada-vapor-steam-vent"), a.setAttribute("opacity", "0");
+	let o = t(n.tokens.medium, e.medium ?? D);
+	if (!o?.plume) return {
+		svg: a,
+		handles: {}
+	};
+	let { w: l, h: p } = e, m = l / 2, h = Math.max(6, p * C), g = [];
+	for (let e = 0; e < x; e++) {
+		let t = Math.max(1.5, l / 2 * (1 - e * .2)), n = c({
+			containerHeight: p,
+			centerX: m,
+			baseHalfWidth: t,
+			wobble: t * S,
+			period: h,
+			color: o.color,
+			durationMs: s * w * (1 + e * T)
+		}, r);
+		a.appendChild(n.carrier), g.push(n);
+	}
+	let _ = document.createElementNS(b, "path");
+	_.setAttribute("class", "vscada-vapor-steam-vent-static"), _.setAttribute("transform", `translate(${m}, 0)`), _.setAttribute("d", i(p, l * .28, l * .28 * S, h)), _.setAttribute("fill", o.color), _.setAttribute("fill-opacity", "0"), _.setAttribute("stroke", "none"), _.style.display = "none", a.appendChild(_);
+	let v = u({
+		element: e,
+		group: a,
+		layers: g,
+		staticGlyph: _,
+		plumeStyle: o.plume,
+		brightnessFactor: E
+	}), y = f(e.id, g), O = d(e.id, g, _);
+	return {
+		svg: a,
+		handles: {
+			...v.handles,
+			...y,
+			...O
+		}
+	};
+}
+var k = Object.freeze({
+	group: "vapor",
+	primitives: Object.freeze({ "steam-vent": { build: O } })
+}), A = Object.freeze({
+	group: "vapor",
+	primitives: Object.freeze({
+		...y.primitives,
+		...k.primitives
+	})
+});
+//#endregion
+export { A as vapor };

package/dist/vessel-body/hardware.d.ts

@@ -0,0 +1,13 @@
+import type { VesselTokens } from '@vscada/core';
+/** §7.2 layer 6's "which small details" per vessel silhouette — one shared builder, a variant switch, never a per-vessel fork. */
+export type VesselHardwareVariant = 'tank-vertical' | 'tank-horizontal' | 'drum' | 'sphere' | 'hopper' | 'silo';
+/**
+ * §7.2 layer 6: "three or four small details convince more than a perfect
+ * outline" — deliberately NOT exhaustive per vessel. Every dimension is a
+ * function of `w`/`h` (parametric, AD-3); every color/width is a token
+ * (AD-7, via the small `rect`/`circle`/`weldLine`/… helpers above, which
+ * degrade to `'none'` exactly like every other primitive here when a token
+ * is unregistered).
+ */
+export declare function buildHardwareLayer(w: number, h: number, variant: VesselHardwareVariant, tokens: VesselTokens | undefined): SVGGElement;
+//# sourceMappingURL=hardware.d.ts.map

package/dist/vessel-body/hardware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardware.d.ts","sourceRoot":"","sources":["../../src/vessel-body/hardware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAIjD,kIAAkI;AAClI,MAAM,MAAM,qBAAqB,GAAG,eAAe,GAAG,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAgFhH;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,WAAW,CA6DtI"}

package/dist/vessel-body/liquid/dished-bottom.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Dished-bottom tank head clip geometry (Story 3.2 Task 3, §7.2: "Rim
+ * details — top and bottom ellipses for tank heads (ellipse ratio ~0.18 of
+ * width)"). Story 1.5 shipped a plain full-rect clip; that's fine at high
+ * fill but wrong at low fill — a real dished bottom narrows to a point, so
+ * a 2% level should read as a thin LENS at the vessel's horizontal center,
+ * not a full-width sliver. This module owns that shape as pure geometry so
+ * it's testable without a browser (jsdom does not rasterize clip-path).
+ */
+/** §7.2's constant — the dish's height as a fraction of the vessel's WIDTH (not height). */
+export declare const DISH_WIDTH_RATIO = 0.18;
+/** Clamped so a very short/squat vessel can't have a dish taller than the vessel itself. */
+export declare function dishHeightFor(w: number, h: number, ratio?: number): number;
+/**
+ * Clip path `d` for the vessel's liquid area: a flat-sided rect down to
+ * `h - dish`, then a half-ellipse (rx = w/2, ry = dish) sweeping through
+ * the bottom-center point (w/2, h) back up to the opposite side. Sweep
+ * flag 1 draws the LOWER half of the ellipse (the two endpoints sit on the
+ * ellipse's horizontal axis, so sweep alone picks top-half vs bottom-half
+ * for this exactly-180-degree arc) — i.e. the bulge goes down, not up.
+ * Built ONCE per element (cached by clip id, same pattern as Story 1.5's
+ * plain-rect clip) — never regenerated per frame or per level change.
+ */
+export declare function dishedBottomClipPathD(w: number, h: number, ratio?: number): string;
+/**
+ * The visible liquid width at `depthFromTip` px above the vessel's very
+ * bottom point (0 at the tip, growing to the full `w` once `depthFromTip`
+ * reaches the dish's height). Pure ellipse cross-section math — exists so
+ * the "0-5% level" AC is verifiable directly (a thin puddle must compute
+ * to LESS than the full width) without needing real SVG rendering.
+ */
+export declare function dishWidthAtDepth(w: number, h: number, depthFromTip: number, ratio?: number): number;
+//# sourceMappingURL=dished-bottom.d.ts.map

package/dist/vessel-body/liquid/dished-bottom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dished-bottom.d.ts","sourceRoot":"","sources":["../../../src/vessel-body/liquid/dished-bottom.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,GAAE,MAAyB,GAAG,MAAM,CAE5F;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,GAAE,MAAyB,GAAG,MAAM,CAKpG;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,GAAE,MAAyB,GAAG,MAAM,CAUrH"}

package/dist/vessel-body/liquid/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Liquid wave module (Story 3.2) — shared by every vessel primitive with a
+ * clipped liquid `<g>` (tank-vertical today; tank-horizontal/spherical/etc.
+ * in Story 3.3+ reuse the same wave/clip geometry). Deliberately exports
+ * pure geometry (`wave-path`, `dished-bottom`) separately from the DOM
+ * builder (`wave-layer`) so both halves stay independently unit-testable.
+ */
+export { buildWaveCrestPathD, buildWaveCrestPoints, buildWavePathD, WAVE_SAMPLE_STEP_PX, type WavePoint } from './wave-path';
+export { BASE_WAVE_DURATION_MS, DEFAULT_SPECULAR, DEFAULT_WAVE_AMPLITUDE, DEFAULT_WAVE_PERIOD, DEFAULT_WAVE_SPEED, buildWaveLayer, type WaveLayer, type WaveLayerParams, } from './wave-layer';
+export { DISH_WIDTH_RATIO, dishedBottomClipPathD, dishHeightFor, dishWidthAtDepth } from './dished-bottom';
+//# sourceMappingURL=index.d.ts.map

package/dist/vessel-body/liquid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vessel-body/liquid/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,cAAc,EAAE,mBAAmB,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7H,OAAO,EACL,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,KAAK,SAAS,EACd,KAAK,eAAe,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/vessel-body/liquid/wave-layer.d.ts

@@ -0,0 +1,57 @@
+import type { AnimationControl, Renderer, SpecularStyle } from '@vscada/core';
+/** Reference duration for one full `translateX(-period)` loop at playbackRate 1 — same "documented default, not spec-pinned" convention as the pipe's `BASE_DASH_DURATION_MS` (Story 1.4). */
+export declare const BASE_WAVE_DURATION_MS = 4000;
+/**
+ * Motion fallbacks used only when a vessel's resolved medium has no
+ * registered wave params (no `medium` tokens at all, or a medium missing
+ * these optional §7.4 fields) — plain px/dimensionless defaults, never a
+ * color (AD-7 bans literal COLORS in primitives; a documented motion
+ * magnitude is the same convention `dash.ts`'s `BASE_DASH_DURATION_MS`
+ * already uses).
+ */
+export declare const DEFAULT_WAVE_AMPLITUDE = 3;
+export declare const DEFAULT_WAVE_PERIOD = 80;
+export declare const DEFAULT_WAVE_SPEED = 1;
+export declare const DEFAULT_SPECULAR: SpecularStyle;
+export interface WaveLayerParams {
+    /**
+     * The vessel's own width — the path is built at LEAST 2x THIS (AC 1:
+     * "built once at 2x container width"), and wider still whenever `period`
+     * exceeds `containerWidth` (Bug 1 fix): the WAAPI loop translates the
+     * built path by `-period` px, so seamless coverage requires the built
+     * path to span at least `containerWidth + period`, not a fixed 2x.
+     */
+    containerWidth: number;
+    amplitude: number;
+    period: number;
+    /** Multiplier applied to the loop's WAAPI playbackRate at build time — the medium's `waveSpeed` ("viscosity reads as slowness", §7.4's primary characterization lever). */
+    speedFactor: number;
+    /** Already-resolved theme/medium color — never a literal hex (AD-7). */
+    color: string;
+    /** Wave ribbon fill opacity. */
+    opacity: number;
+    specular: SpecularStyle;
+}
+export interface WaveLayer {
+    /** Y-translated by the tank's EXISTING level write (Story 1.5's tween) — never a second/new tween (Task 1). */
+    carrier: SVGGElement;
+    /** The one WAAPI loop control for this layer — pause/resume/seek reach it via the primitive's own `AnimationHandle`, which is core's AD-5 registry entry point. */
+    control: AnimationControl;
+}
+/**
+ * Builds ONE wave layer: a carrier group (Y, level-driven, transform-only)
+ * wrapping a loop group (X, WAAPI-driven seamless loop) wrapping the wave
+ * path(s). `buildWavePathD` is called exactly ONCE here — every other
+ * change to this layer (level, playback rate, freeze) is a transform or a
+ * WAAPI control call, never a re-build (AD-2/Task 1's hard constraint).
+ *
+ * `specular` strokes a SEPARATE crest-only path (Bug 7 fix — the closed
+ * fill ribbon's `d` also includes the flat `bandDepth` baseline and
+ * vertical end-caps, which a stroke pass would draw as straight seams, not
+ * "a soft band along the crest"): 'sharp' (water) = thin bright crest
+ * line, 'diffuse' (oil) = wide soft band, 'none' (slurry, AC 2's named
+ * case) = omitted entirely — matte is the ABSENCE of the element, not a
+ * muted version of it.
+ */
+export declare function buildWaveLayer(params: WaveLayerParams, renderer: Renderer): WaveLayer;
+//# sourceMappingURL=wave-layer.d.ts.map

package/dist/vessel-body/liquid/wave-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-layer.d.ts","sourceRoot":"","sources":["../../../src/vessel-body/liquid/wave-layer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAK9E,8LAA8L;AAC9L,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,gBAAgB,EAAE,aAAuB,CAAC;AAOvD,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,2KAA2K;IAC3K,WAAW,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,SAAS;IACxB,+GAA+G;IAC/G,OAAO,EAAE,WAAW,CAAC;IACrB,mKAAmK;IACnK,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAuDrF"}

package/dist/vessel-body/liquid/wave-path.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Sine-wave path geometry (Story 3.2 Task 1, §7.3's technique pulled into
+ * v1 per spec-amendments §B1): "each path built once at 2x container
+ * width, animated only via `transform: translateX(-period)`, linear
+ * infinite. Because the path is periodic, translating by exactly one
+ * period is seamless."
+ *
+ * Pure math — no DOM here — so the periodicity claim (AD-2's "structure
+ * once" hinges on it: if this weren't exactly periodic, a translateX loop
+ * would visibly jump at the seam) is directly unit-testable without a
+ * browser.
+ */
+/** Px between samples along the wave crest — small enough to read as a smooth curve at typical vessel widths, large enough to keep the `d` string short. */
+export declare const WAVE_SAMPLE_STEP_PX = 6;
+export interface WavePoint {
+    x: number;
+    y: number;
+}
+/**
+ * The crest of the wave: `y = -amplitude * sin(2*pi*x/period)`, sampled
+ * from `x = 0` to `x = width` inclusive. Negative sign so a positive
+ * amplitude bulges the crest UP (toward the surface) at x=0, matching how
+ * the wave layer is anchored to the liquid surface (§7.3).
+ */
+export declare function buildWaveCrestPoints(width: number, amplitude: number, period: number, sampleStep?: number): WavePoint[];
+/**
+ * The crest ALONE as an open path `d` (`M`/`L` polyline, no baseline, no
+ * close): what `buildWavePathD` draws as its top edge, exposed separately
+ * so a stroked "highlight the crest" pass (the specular treatment, Story
+ * 3.2 Bug 7 fix) can reuse just this curve instead of the closed fill
+ * ribbon — reusing the closed ribbon's `d` for a stroke also strokes its
+ * flat `bandDepth` baseline and vertical end-caps, which is NOT "a soft
+ * band along the crest."
+ */
+export declare function buildWaveCrestPathD(width: number, amplitude: number, period: number, sampleStep?: number): string;
+/**
+ * The wave layer's fillable `d`: the crest polyline, then straight down to
+ * a flat `bandDepth` baseline and back — a shallow ribbon riding the
+ * surface, not a filled-to-the-floor shape (§7.3's "gentle wave layer",
+ * not a redrawn liquid body). Built exactly ONCE per element (AD-2); every
+ * subsequent level/playback change is transform-only — this function must
+ * never be called again outside `build()`.
+ */
+export declare function buildWavePathD(width: number, amplitude: number, period: number, bandDepth: number, sampleStep?: number): string;
+//# sourceMappingURL=wave-path.d.ts.map

package/dist/vessel-body/liquid/wave-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-path.d.ts","sourceRoot":"","sources":["../../../src/vessel-body/liquid/wave-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,4JAA4J;AAC5J,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAA4B,GAAG,SAAS,EAAE,CAS5I;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAA4B,GAAG,MAAM,CAGtI;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAE,MAA4B,GAAG,MAAM,CAGpJ"}

package/dist/vessel-body/recipe.d.ts

@@ -0,0 +1,85 @@
+import type { HandleMap, Renderer, SceneElement, ThemeContext } from '@vscada/core';
+import { type VesselHardwareVariant } from './hardware';
+/**
+ * Story 3.3 Task 1 — the shared §7.2 seven-layer vessel recipe. ONE module,
+ * every vessel (tank-vertical retrofitted, plus tank-horizontal/-spherical/
+ * hopper/silo/drum) parameterizes this with geometry only (Dev Notes: "if a
+ * vessel needs recipe-module changes, change the module — never fork it").
+ *
+ * Layers, back to front, exactly per §7.2:
+ *  1. body base — vertical gradient, mid-tone -> darker
+ *  2. cylindrical shading overlay — the "does most of the work" layer;
+ *     linear (orientation-dependent axis) for cylinders, radial highlight
+ *     for spheres
+ *  3. liquid group — Story 3.2's wave module, reused verbatim, clipped to
+ *     THIS vessel's own shape (never the wave/dish code itself changed)
+ *  4. specular strip — narrow near-white band, opacity 0.12
+ *  5. rim ellipses — darker stroke + lighter upper arc + optional crown
+ *     ribbing
+ *  6. hardware — nozzles/manway/lugs/skirt/weld seams (`hardware.ts`)
+ *  7. contact shadow at the base
+ *
+ * Threshold wall markers + the alarm-band-colored liquid surface indicator
+ * (AC2) are additive, built alongside layer 3/on top of layer 6 — not one
+ * of the seven, but driven by the SAME per-frame level write so no second
+ * tween/mechanism is introduced.
+ *
+ * Bug 1 fix (adversarial review, post-3.3): the surface-alarm indicator is
+ * carried by whichever element is ACTUALLY the visible surface read for
+ * this medium, never a second competing one — restoring the exact
+ * suppression rule Story 3.2's own review fix established
+ * (`hasMediumSpecularParams = mediumStyle?.specular !== undefined`, see
+ * `tank-vertical`'s pre-3.3 history): when the resolved medium has ANY
+ * specular field (the wave module's own crest-only highlight,
+ * `.vscada-liquid-wave-specular`, built by `buildWaveLayer` in
+ * `liquid/wave-layer.ts`), that highlight IS the surface read, and it's
+ * recolored per alarm band in place — the plain `surfaceLine` is omitted
+ * entirely. Only media with no resolved specular params at all (no
+ * `medium` tokens registered, or a medium with no `specular` field — e.g.
+ * steam/flue-gas) fall back to the plain, always-alarm-colored
+ * `surfaceLine`. The two are mutually exclusive by construction — never
+ * both present for the same build.
+ */
+export type VesselOrientation = 'vertical' | 'horizontal' | 'spherical';
+export interface RimEllipse {
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    /** A handful of short radial tick lines near the ellipse's top arc — §7.2's "radial ribbing around the crown". */
+    crownRibbing?: boolean;
+}
+export interface VesselGeometry {
+    orientation: VesselOrientation;
+    /** The vessel's own silhouette — layers 1/2/4/5 (and the liquid clip, unless `liquidClipPathD` is given) are clipped/drawn to this. */
+    bodyPathD: string;
+    /** Defaults to `bodyPathD` — only silo's liquid clip (the straight cylindrical section, not the roofed outline) differs; see `shapes.ts`'s own doc. */
+    liquidClipPathD?: string;
+    /**
+     * Bug 2 fix — topmost Y (local element space, same units as `h`) a
+     * threshold wall marker may ever be drawn at. Defaults to `0` (no
+     * clamp): every vessel except silo has `liquidClipPathD` spanning the
+     * same y-range as `bodyPathD`, so a marker anywhere in `[0, h]` is
+     * always inside the actual silhouette. Silo's liquid clip plateaus at
+     * its roofline (`siloCylinderTop`) — without this clamp, a threshold
+     * above that fill-fraction draws its tick inside/above the conical
+     * roof, a region the liquid (and thus the marker it represents) can
+     * never actually reach.
+     */
+    markerMinY?: number;
+    rims: readonly RimEllipse[];
+    hardware: VesselHardwareVariant;
+}
+export interface BuildVesselOptions {
+    element: SceneElement;
+    theme: ThemeContext;
+    renderer: Renderer;
+    geometry: VesselGeometry;
+}
+/** Layer class names, in the exact §7.2 back-to-front order — the single source of truth `recipe.ts` builds against and `recipe.test.ts` asserts against. */
+export declare const VESSEL_LAYER_CLASSES: readonly ["vscada-vessel-body-base", "vscada-vessel-shading", "vscada-vessel-liquid", "vscada-vessel-specular", "vscada-vessel-rim", "vscada-vessel-hardware", "vscada-vessel-shadow"];
+export declare function buildVesselRecipe({ element, theme, renderer, geometry }: BuildVesselOptions): {
+    svg: SVGElement;
+    handles: HandleMap;
+};
+//# sourceMappingURL=recipe.d.ts.map

package/dist/vessel-body/recipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipe.d.ts","sourceRoot":"","sources":["../../src/vessel-body/recipe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,SAAS,EAAE,QAAQ,EAAE,YAAY,EAAuB,YAAY,EAAgB,MAAM,cAAc,CAAC;AAEjJ,OAAO,EAAsB,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAa5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,YAAY,GAAG,WAAW,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,kHAAkH;IAClH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,iBAAiB,CAAC;IAC/B,uIAAuI;IACvI,SAAS,EAAE,MAAM,CAAC;IAClB,uJAAuJ;IACvJ,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5B,QAAQ,EAAE,qBAAqB,CAAC;CACjC;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,6JAA6J;AAC7J,eAAO,MAAM,oBAAoB,wLAQvB,CAAC;AAiPX,wBAAgB,iBAAiB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,kBAAkB,GAAG;IAAE,GAAG,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,CAqOrI"}

package/dist/vessel-body/shapes.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Body-silhouette / liquid-clip geometry for the five Story 3.3 vessel
+ * shapes (tank-vertical's own dished-bottom head lives in `liquid/
+ * dished-bottom.ts` — Story 3.2 built it first and it's reused verbatim,
+ * not duplicated here). Pure path math, same convention as
+ * `dished-bottom.ts`: no DOM, independently unit-testable, called exactly
+ * once per element build (`recipe.ts` never regenerates a `d` per frame —
+ * AD-2).
+ *
+ * Every shape here reuses `DISH_WIDTH_RATIO` (§7.2's "ellipse ratio ~0.18 of
+ * width") as its own head/cap/roof proportion — one spec constant, five
+ * consumers, never five independently-tuned magic numbers.
+ */
+/** Fraction of a hopper's total height given to the straight cylindrical section before the converging cone starts. */
+export declare const HOPPER_CYLINDER_RATIO = 0.5;
+/** Fraction of a hopper's width left open at the discharge throat (bottom). */
+export declare const HOPPER_THROAT_RATIO = 0.18;
+/** Fraction of a silo's total height given to the conical roof. */
+export declare const SILO_ROOF_RATIO = 0.18;
+/**
+ * tank-horizontal / drum body+liquid-clip: a "stadium"/capsule shape — a
+ * straight mid-section with elliptical end caps bulging outward left and
+ * right. The vertical-tank equivalent of `dishedBottomClipPathD` rotated
+ * 90°: there the round cross-section is horizontal (left-right), so its
+ * dish is a bottom-only cap; here the cylinder's AXIS is horizontal, so the
+ * round cross-section is vertical (top-bottom) and BOTH ends get a cap.
+ * `ry` is always the full half-height — a true semicircular-ish end, not a
+ * shallow dish — since a horizontal vessel's end head is seen near
+ * side-on, not foreshortened the way a vertical tank's top/bottom is.
+ */
+export declare function capsulePathD(w: number, h: number, ratio?: number): string;
+/** The capsule's own half-cap width, exposed so callers (rim placement) don't recompute/duplicate the clamp logic above. */
+export declare function capsuleCapWidth(w: number, h: number, ratio?: number): number;
+/**
+ * The sphere's actual inscribed-circle center/radius (diameter = min(w, h))
+ * — the SINGLE source of truth `spherePathD` builds its outline from.
+ * Bug 5 fix: `buildSpecular`'s spherical branch and tank-spherical's rim
+ * placement used to compute their own positions from `w`/`h` independently
+ * rather than calling this, so for a non-square element box (w !== h) the
+ * decorative glint/rim could land outside the visible circle (silently
+ * clipped away by the body clip-path). Every spherical-vessel consumer that
+ * needs "where is the circle" must call this, never re-derive `r`/center
+ * with its own math.
+ */
+export declare function sphereGeometry(w: number, h: number): {
+    cx: number;
+    cy: number;
+    r: number;
+};
+/** tank-spherical body+liquid-clip: a plain circle inscribed in the element's box (diameter = min(w, h)) — no foreshortening, spec §7.2's own "spherical vessels use the same recipe" carve-out replaces banding with a radial highlight instead, not the outline itself. */
+export declare function spherePathD(w: number, h: number): string;
+/**
+ * hopper body+liquid-clip: a straight-sided cylindrical top section down to
+ * `HOPPER_CYLINDER_RATIO * h`, then a converging trapezoid down to a
+ * narrow discharge throat (`HOPPER_THROAT_RATIO * w` wide) at the very
+ * bottom. The SAME path is used for the liquid clip (Dev Notes: level
+ * maps LINEARLY to height in v1 — see the hopper primitive's own doc for
+ * why that's a documented simplification, not volume-accurate).
+ */
+export declare function hopperPathD(w: number, h: number, cylinderRatio?: number, throatRatio?: number): string;
+/** silo body outline: a tall straight cylinder with a triangular/conical roof. Bottom is flat (a real discharge cone, when drawn, is a `hardware` detail — see `hardware.ts` — not part of the outline). */
+export declare function siloPathD(w: number, h: number, roofRatio?: number): string;
+/** Y of the roofline / top of the straight cylindrical section — silo's liquid clip (see `siloLiquidClipPathD`) starts here, never inside the pointed roof. */
+export declare function siloCylinderTop(h: number, roofRatio?: number): number;
+/**
+ * silo liquid clip: a plain rect for JUST the straight cylindrical section
+ * (below the roofline) — deliberately NOT the same path as
+ * `siloPathD` (the one documented exception to "body path == liquid clip
+ * path" every other vessel here follows). A real silo's product never
+ * visibly fills into the pointed roof; clipping the liquid to the full
+ * roofed outline would let a near-full level narrow to a point at the top,
+ * which reads as wrong. The plain rect naturally plateaus the visible fill
+ * at the roofline for any level fraction whose unclipped top edge would
+ * otherwise land inside the roof — an acceptable v1 simplification (Dev
+ * Notes: "level maps linearly to height").
+ */
+export declare function siloLiquidClipPathD(w: number, h: number, roofRatio?: number): string;
+//# sourceMappingURL=shapes.d.ts.map

package/dist/vessel-body/shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../../src/vessel-body/shapes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,uHAAuH;AACvH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,mEAAmE;AACnE,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,GAAE,MAAyB,GAAG,MAAM,CAK3F;AAED,4HAA4H;AAC5H,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,GAAE,MAAyB,GAAG,MAAM,CAE9F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAE1F;AAED,6QAA6Q;AAC7Q,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,aAAa,GAAE,MAA8B,EAC7C,WAAW,GAAE,MAA4B,GACxC,MAAM,CAMR;AAED,4MAA4M;AAC5M,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,GAAE,MAAwB,GAAG,MAAM,CAG3F;AAED,+JAA+J;AAC/J,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,GAAE,MAAwB,GAAG,MAAM,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,GAAE,MAAwB,GAAG,MAAM,CAGrG"}

package/dist/vessels/drum/drum.stories.d.ts

@@ -0,0 +1,33 @@
+import { type VesselStory, type VesselStoryArgs, type VesselStoryMeta } from '../story-kit';
+/** Story 3.3 Task 4 — same reference pattern as `tank-vertical.stories.ts`; see that file's doc. */
+export declare const meta: VesselStoryMeta;
+export declare const argTypes: {
+    readonly level: {
+        readonly control: {
+            readonly type: "range";
+            readonly min: 0;
+            readonly max: 100;
+            readonly step: 1;
+        };
+    };
+    readonly medium: {
+        readonly control: {
+            readonly type: "select";
+        };
+        readonly options: readonly ["water", "oil", "fuel-diesel", "slurry-sludge", "acid-chemical", "molten-hot", "condensate", "feedwater", "hydraulic-oil"];
+    };
+    readonly thresholdDemo: {
+        readonly control: "boolean";
+    };
+    readonly stale: {
+        readonly control: "boolean";
+    };
+};
+export declare const Default: VesselStory;
+export declare const LevelSweep: VesselStory;
+export declare const MediumSwitch: VesselStory;
+export declare const ThresholdDemo: VesselStory;
+export declare const StaleFreeze: VesselStory;
+export declare function render(container: HTMLElement, args?: Partial<VesselStoryArgs>): import("../story-kit").MountedVesselStory;
+export default meta;
+//# sourceMappingURL=drum.stories.d.ts.map

package/dist/vessels/drum/drum.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drum.stories.d.ts","sourceRoot":"","sources":["../../../src/vessels/drum/drum.stories.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAEtI,oGAAoG;AACpG,eAAO,MAAM,IAAI,EAAE,eAKlB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;CAAyB,CAAC;AAE/C,eAAO,MAAM,OAAO,EAAE,WAAiC,CAAC;AACxD,eAAO,MAAM,UAAU,EAAE,WAA0D,CAAC;AACpF,eAAO,MAAM,YAAY,EAAE,WAAoF,CAAC;AAChH,eAAO,MAAM,aAAa,EAAE,WAAyF,CAAC;AACtH,eAAO,MAAM,WAAW,EAAE,WAA0E,CAAC;AAErG,wBAAgB,MAAM,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,GAAE,OAAO,CAAC,eAAe,CAAM,6CAEjF;AAED,eAAe,IAAI,CAAC"}

package/dist/vessels/drum/index.d.ts

@@ -0,0 +1,3 @@
+import type { PrimitiveGroup } from '@vscada/core';
+export declare const drum: PrimitiveGroup;
+//# sourceMappingURL=index.d.ts.map

package/dist/vessels/drum/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vessels/drum/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,cAAc,EAAyD,MAAM,cAAc,CAAC;AAkCrH,eAAO,MAAM,IAAI,EAAE,cAGjB,CAAC"}

package/dist/vessels/hopper/hopper.stories.d.ts

@@ -0,0 +1,39 @@
+import { type VesselStory, type VesselStoryArgs, type VesselStoryMeta } from '../story-kit';
+/**
+ * Story 3.3 Task 4 — same reference pattern as `tank-vertical.stories.ts`;
+ * see that file's doc. The level sweep here also doubles as a demonstration
+ * of the documented v1 simplification (`hopper/index.ts`'s own doc): watch
+ * the fill visibly narrow through the funnel as the level drops — the
+ * PIXEL-height mapping is linear, not the true (smaller) volume fraction.
+ */
+export declare const meta: VesselStoryMeta;
+export declare const argTypes: {
+    readonly level: {
+        readonly control: {
+            readonly type: "range";
+            readonly min: 0;
+            readonly max: 100;
+            readonly step: 1;
+        };
+    };
+    readonly medium: {
+        readonly control: {
+            readonly type: "select";
+        };
+        readonly options: readonly ["water", "oil", "fuel-diesel", "slurry-sludge", "acid-chemical", "molten-hot", "condensate", "feedwater", "hydraulic-oil"];
+    };
+    readonly thresholdDemo: {
+        readonly control: "boolean";
+    };
+    readonly stale: {
+        readonly control: "boolean";
+    };
+};
+export declare const Default: VesselStory;
+export declare const LevelSweep: VesselStory;
+export declare const MediumSwitch: VesselStory;
+export declare const ThresholdDemo: VesselStory;
+export declare const StaleFreeze: VesselStory;
+export declare function render(container: HTMLElement, args?: Partial<VesselStoryArgs>): import("../story-kit").MountedVesselStory;
+export default meta;
+//# sourceMappingURL=hopper.stories.d.ts.map

package/dist/vessels/hopper/hopper.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hopper.stories.d.ts","sourceRoot":"","sources":["../../../src/vessels/hopper/hopper.stories.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAEtI;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,eAKlB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;CAAyB,CAAC;AAE/C,eAAO,MAAM,OAAO,EAAE,WAAiC,CAAC;AACxD,eAAO,MAAM,UAAU,EAAE,WAA0D,CAAC;AACpF,eAAO,MAAM,YAAY,EAAE,WAA0F,CAAC;AACtH,eAAO,MAAM,aAAa,EAAE,WAAwF,CAAC;AACrH,eAAO,MAAM,WAAW,EAAE,WAA0E,CAAC;AAErG,wBAAgB,MAAM,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,GAAE,OAAO,CAAC,eAAe,CAAM,6CAEjF;AAED,eAAe,IAAI,CAAC"}