@camstack/addon-pipeline-orchestrator 1.2.626 → 1.2.627

package/dist/index.mjs

@@ -43223,6 +43223,649 @@ var _macroLookup = /* @__PURE__ */ new Map();
 for (const [k, v] of Object.entries(YAMNET_TO_MACRO.mapping)) _macroLookup.set(k.toLowerCase(), v);
 for (const [k, v] of Object.entries(APPLE_SA_TO_MACRO.mapping)) _macroLookup.set(k.toLowerCase(), v);
 /**
+* Palette entry ids (D939). Audio is the one gradient; `audio-*` leaves are
+* not entries. `heatmapScrub` is a mark, not an event kind.
+*/
+var PALETTE_ENTRY_IDS = [
+	"motion",
+	"audio",
+	"recording",
+	"live",
+	"heatmapScrub",
+	"person",
+	"vehicle",
+	"animal",
+	"package",
+	"sensor",
+	"control",
+	"face",
+	"plate",
+	"car",
+	"truck",
+	"bus",
+	"motorcycle",
+	"bicycle",
+	"airplane",
+	"boat",
+	"train",
+	"bird",
+	"dog",
+	"cat",
+	"horse",
+	"sheep",
+	"cow",
+	"elephant",
+	"bear",
+	"zebra",
+	"giraffe",
+	"package-delivered",
+	"package-picked-up",
+	"suitcase",
+	"backpack",
+	"handbag",
+	"contact",
+	"motion-sensor",
+	"smoke",
+	"flood",
+	"gas",
+	"carbon-monoxide",
+	"vibration",
+	"tamper",
+	"presence",
+	"enum-sensor",
+	"device-event",
+	"lock",
+	"cover",
+	"switch",
+	"siren",
+	"button",
+	"doorbell"
+];
+var AUDIO_ENTRY_ID = "audio";
+/** Six rungs, quiet → loud. The opaque end is the entry's hex. */
+var AUDIO_GRADIENT_ALPHAS = [
+	.3,
+	.42,
+	.55,
+	.7,
+	.85,
+	1
+];
+var PALETTE_PRESET_IDS = [
+	"camstack",
+	"high-contrast",
+	"okabe-ito"
+];
+function isPaletteEntryId(id) {
+	return PALETTE_ENTRY_IDS.includes(id);
+}
+function isPalettePresetId(id) {
+	return PALETTE_PRESET_IDS.includes(id);
+}
+/**
+* CIEDE2000 and WCAG contrast for the display palette (D939).
+*
+* One implementation, shared by the hub validator, the admin editor and
+* (phase 2) the viewer. The arithmetic matches the viewer's `src/theme/cie.ts`.
+*/
+/** Page backgrounds the contrast rule is measured against. */
+var PALETTE_BACKGROUNDS = {
+	dark: "#0c0a09",
+	light: "#fafaf9"
+};
+/** Marks that are not event kinds and share the raised distance floor. */
+var PALETTE_MARK_PAIR = ["live", "heatmapScrub"];
+var HEX = /^#[0-9a-fA-F]{6}$/;
+function srgbChannel(hex, start) {
+	return Number.parseInt(hex.slice(start, start + 2), 16);
+}
+function srgbToLin(channel) {
+	const x = channel / 255;
+	return x <= .04045 ? x / 12.92 : ((x + .055) / 1.055) ** 2.4;
+}
+function relativeLuminance(hex) {
+	const r = srgbToLin(srgbChannel(hex, 1));
+	const g = srgbToLin(srgbChannel(hex, 3));
+	const b = srgbToLin(srgbChannel(hex, 5));
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+/** WCAG contrast ratio of two `#rrggbb` colours. Non-hex returns 0. */
+function contrastRatio(a, b) {
+	if (!HEX.test(a) || !HEX.test(b)) return 0;
+	const hi = Math.max(relativeLuminance(a), relativeLuminance(b));
+	const lo = Math.min(relativeLuminance(a), relativeLuminance(b));
+	return (hi + .05) / (lo + .05);
+}
+function xyzToLab(hex) {
+	const r = srgbToLin(srgbChannel(hex, 1));
+	const g = srgbToLin(srgbChannel(hex, 3));
+	const bl = srgbToLin(srgbChannel(hex, 5));
+	const x = .4124564 * r + .3575761 * g + .1804375 * bl;
+	const y = .2126729 * r + .7151522 * g + .072175 * bl;
+	const z = .0193339 * r + .119192 * g + .9503041 * bl;
+	const f = (t) => t > .008856 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
+	const fx = f(x / .95047);
+	const fy = f(y);
+	const fz = f(z / 1.08883);
+	return {
+		L: 116 * fy - 16,
+		a: 500 * (fx - fy),
+		b: 200 * (fy - fz)
+	};
+}
+function hueDeg(ap, b) {
+	if (ap === 0 && b === 0) return 0;
+	const ang = Math.atan2(b, ap) * 180 / Math.PI;
+	return ang < 0 ? ang + 360 : ang;
+}
+/** CIEDE2000. Non-hex returns 0 so a bad swatch fails the distinctness rule. */
+function deltaE00(hex1, hex2) {
+	if (!HEX.test(hex1) || !HEX.test(hex2)) return 0;
+	const lab1 = xyzToLab(hex1);
+	const lab2 = xyzToLab(hex2);
+	const cab7 = ((Math.hypot(lab1.a, lab1.b) + Math.hypot(lab2.a, lab2.b)) / 2) ** 7;
+	const g = .5 * (1 - Math.sqrt(cab7 / (cab7 + 25 ** 7)));
+	const a1p = (1 + g) * lab1.a;
+	const a2p = (1 + g) * lab2.a;
+	const c1p = Math.hypot(a1p, lab1.b);
+	const c2p = Math.hypot(a2p, lab2.b);
+	const h1p = hueDeg(a1p, lab1.b);
+	const h2p = hueDeg(a2p, lab2.b);
+	let dhp = 0;
+	if (c1p * c2p !== 0) {
+		dhp = h2p - h1p;
+		if (dhp > 180) dhp -= 360;
+		else if (dhp < -180) dhp += 360;
+	}
+	const dHp = 2 * Math.sqrt(c1p * c2p) * Math.sin(dhp * Math.PI / 360);
+	const lbp = (lab1.L + lab2.L) / 2;
+	const cbp = (c1p + c2p) / 2;
+	let hbp = h1p + h2p;
+	if (c1p * c2p !== 0) {
+		if (Math.abs(h1p - h2p) > 180) hbp += hbp < 360 ? 360 : -360;
+		hbp /= 2;
+	}
+	const t = 1 - .17 * Math.cos((hbp - 30) * Math.PI / 180) + .24 * Math.cos(2 * hbp * Math.PI / 180) + .32 * Math.cos((3 * hbp + 6) * Math.PI / 180) - .2 * Math.cos((4 * hbp - 63) * Math.PI / 180);
+	const dTheta = 30 * Math.exp(-(((hbp - 275) / 25) ** 2));
+	const cbp7 = cbp ** 7;
+	const rc = 2 * Math.sqrt(cbp7 / (cbp7 + 25 ** 7));
+	const sl = 1 + .015 * (lbp - 50) ** 2 / Math.sqrt(20 + (lbp - 50) ** 2);
+	const sc = 1 + .045 * cbp;
+	const sh = 1 + .015 * cbp * t;
+	const rt = -Math.sin(2 * dTheta * Math.PI / 180) * rc;
+	const dLp = lab2.L - lab1.L;
+	const dCp = c2p - c1p;
+	return Math.sqrt((dLp / sl) ** 2 + (dCp / sc) ** 2 + (dHp / sh) ** 2 + rt * (dCp / sc) * (dHp / sh));
+}
+/** Frozen palette tables (D939). The spec refuses a table that breaks the rule. */
+var CAMSTACK_HEX = {
+	motion: "#d946ef",
+	audio: "#059eb8",
+	recording: "#ef4444",
+	live: "#8d7a00",
+	heatmapScrub: "#4b32ff",
+	person: "#11a64c",
+	vehicle: "#3b82f6",
+	animal: "#ea6a09",
+	package: "#924667",
+	sensor: "#624bbc",
+	control: "#944d24",
+	face: "#ed4f8d",
+	plate: "#4b7027",
+	car: "#9684cf",
+	truck: "#0f9b89",
+	bus: "#a734a9",
+	motorcycle: "#c1133a",
+	bicycle: "#0e6a9b",
+	airplane: "#7c9928",
+	boat: "#b17933",
+	train: "#ad6ca3",
+	bird: "#0f7c55",
+	dog: "#c82700",
+	cat: "#7268f2",
+	horse: "#cb795e",
+	sheep: "#b8636b",
+	cow: "#cb2969",
+	elephant: "#1158d2",
+	bear: "#8d5e00",
+	zebra: "#0097d6",
+	giraffe: "#8f61bb",
+	"package-delivered": "#cd3f9b",
+	"package-picked-up": "#388a08",
+	suitcase: "#666800",
+	backpack: "#ec5022",
+	handbag: "#a76ef8",
+	contact: "#ab5a49",
+	"motion-sensor": "#b95d1a",
+	smoke: "#dd3858",
+	flood: "#b31e7d",
+	gas: "#5b70b5",
+	"carbon-monoxide": "#7b4e8e",
+	vibration: "#e65bba",
+	tamper: "#98464b",
+	presence: "#3a9468",
+	"enum-sensor": "#7885f8",
+	"device-event": "#8c43c8",
+	lock: "#649653",
+	cover: "#c67597",
+	switch: "#7a812a",
+	siren: "#ac5d7f",
+	button: "#b276cd",
+	doorbell: "#0087ab"
+};
+var CAMSTACK_FALLBACK = [
+	"#b34dc7",
+	"#1d7d34",
+	"#db6b6c",
+	"#a43d29",
+	"#0e6ee6",
+	"#29a10b",
+	"#a98731",
+	"#0181c6"
+];
+var HIGH_CONTRAST_HEX = {
+	motion: "#964360",
+	audio: "#23a132",
+	recording: "#2494ca",
+	live: "#bd7e2b",
+	heatmapScrub: "#ad6eea",
+	person: "#62611e",
+	vehicle: "#f4534c",
+	animal: "#1556cd",
+	package: "#9c4415",
+	sensor: "#066c48",
+	control: "#f2479f",
+	face: "#139d8a",
+	plate: "#909024",
+	car: "#8e35ab",
+	truck: "#bd0b2b",
+	bus: "#7a88ca",
+	motorcycle: "#e26725",
+	bicycle: "#a6679b",
+	airplane: "#7c5720",
+	boat: "#467a1b",
+	train: "#6f65a4",
+	bird: "#cb717f",
+	dog: "#c62490",
+	cat: "#b36850",
+	horse: "#1872ac",
+	sheep: "#927939",
+	cow: "#428a5c",
+	elephant: "#d41160",
+	bear: "#799453",
+	zebra: "#a85455",
+	giraffe: "#746be8",
+	"package-delivered": "#824a80",
+	"package-picked-up": "#614ac1",
+	suitcase: "#2f77f3",
+	backpack: "#fa476d",
+	handbag: "#c14cbe",
+	contact: "#c83921",
+	"motion-sensor": "#a07ebd",
+	smoke: "#a25b13",
+	flood: "#526bab",
+	gas: "#924938",
+	"carbon-monoxide": "#bb7e53",
+	vibration: "#b66182",
+	tamper: "#3c6931",
+	presence: "#6c851d",
+	"enum-sensor": "#ad2d48",
+	"device-event": "#5e9b04",
+	lock: "#00a062",
+	cover: "#ad8624",
+	switch: "#d05259",
+	siren: "#cd67b3",
+	button: "#c9746a",
+	doorbell: "#338eeb"
+};
+var HIGH_CONTRAST_FALLBACK = [
+	"#817f3b",
+	"#a0733e",
+	"#8658b2",
+	"#956301",
+	"#bc652d",
+	"#647331",
+	"#a14c9e",
+	"#d14e71"
+];
+var OKABE_ITO_HEX = {
+	motion: "#b88128",
+	audio: "#1096c8",
+	recording: "#009e73",
+	live: "#9c8c22",
+	heatmapScrub: "#0072b2",
+	person: "#d55e00",
+	vehicle: "#c0739f",
+	animal: "#226d18",
+	package: "#91446c",
+	sensor: "#217b56",
+	control: "#648647",
+	face: "#c22998",
+	plate: "#fa4575",
+	car: "#956301",
+	truck: "#2f77f3",
+	bus: "#7a4e86",
+	motorcycle: "#f54597",
+	bicycle: "#bb3e75",
+	airplane: "#e054c0",
+	boat: "#457942",
+	train: "#867afa",
+	bird: "#88914c",
+	dog: "#1556cd",
+	cat: "#71702c",
+	horse: "#9b4fa4",
+	sheep: "#c0559d",
+	cow: "#d14f65",
+	elephant: "#98470f",
+	bear: "#595896",
+	zebra: "#96790e",
+	giraffe: "#cb717b",
+	"package-delivered": "#139d8a",
+	"package-picked-up": "#906ead",
+	suitcase: "#d02939",
+	backpack: "#d41160",
+	handbag: "#f64f54",
+	contact: "#7258d2",
+	"motion-sensor": "#b66182",
+	smoke: "#627abb",
+	flood: "#b86ae4",
+	gas: "#a95261",
+	"carbon-monoxide": "#c65d3c",
+	vibration: "#7a40b7",
+	tamper: "#914b34",
+	presence: "#9481c3",
+	"enum-sensor": "#ac6d47",
+	"device-event": "#7b6fce",
+	lock: "#c67662",
+	cover: "#a6564d",
+	switch: "#ad2c4e",
+	siren: "#348e08",
+	button: "#d27303",
+	doorbell: "#55770f"
+};
+var OKABE_ITO_FALLBACK = [
+	"#9a3784",
+	"#a7392c",
+	"#409d50",
+	"#6987e7",
+	"#ee5b3d",
+	"#c0430d",
+	"#af79b3",
+	"#4b6628"
+];
+/**
+* The display palette (D939). One table of colours, three presets, one
+* validator. Taxonomy colours and every consumer read this — there is no
+* second hex table.
+*/
+var paletteHexSchema = string().regex(/^#[0-9a-f]{6}$/);
+var paletteSwatchSchema = discriminatedUnion("form", [object({
+	form: literal("solid"),
+	hex: paletteHexSchema
+}), object({
+	form: literal("gradient"),
+	hex: paletteHexSchema,
+	alphas: array(number().gt(0).lte(1)).length(AUDIO_GRADIENT_ALPHAS.length)
+})]);
+var paletteReadySchema = object({
+	status: literal("ready"),
+	presetId: _enum(PALETTE_PRESET_IDS),
+	customized: boolean(),
+	source: _enum(["stored", "unconfigured"]),
+	swatches: record(string(), paletteSwatchSchema),
+	fallbacks: array(paletteHexSchema).length(8)
+});
+var paletteResultSchema = discriminatedUnion("status", [paletteReadySchema, object({
+	status: literal("unknown"),
+	reason: string()
+})]);
+var setPaletteInputSchema = union([object({ presetId: string() }), object({
+	presetId: string(),
+	overrides: record(string(), paletteSwatchSchema)
+})]);
+var storedPaletteSchema = object({
+	presetId: string(),
+	overrides: record(string(), paletteSwatchSchema)
+});
+function solid(hex) {
+	return {
+		form: "solid",
+		hex
+	};
+}
+function audioGradient(hex) {
+	return {
+		form: "gradient",
+		hex,
+		alphas: [...AUDIO_GRADIENT_ALPHAS]
+	};
+}
+function swatchesFrom(hexes) {
+	const out = {};
+	for (const id of PALETTE_ENTRY_IDS) {
+		const hex = hexes[id];
+		if (hex === void 0) throw new Error(`palette table missing ${id}`);
+		out[id] = id === "audio" ? audioGradient(hex) : solid(hex);
+	}
+	return out;
+}
+function preset(id, name, hexes, fallbacks) {
+	return {
+		id,
+		name,
+		swatches: swatchesFrom(hexes),
+		fallbacks
+	};
+}
+var DISPLAY_PRESETS = [
+	preset("camstack", "CamStack", CAMSTACK_HEX, CAMSTACK_FALLBACK),
+	preset("high-contrast", "High contrast", HIGH_CONTRAST_HEX, HIGH_CONTRAST_FALLBACK),
+	preset("okabe-ito", "Colour-blind safe", OKABE_ITO_HEX, OKABE_ITO_FALLBACK)
+];
+function presetById(id) {
+	return DISPLAY_PRESETS.find((item) => item.id === id);
+}
+function bundledCamstack() {
+	const presetRow = presetById("camstack");
+	if (presetRow === void 0) throw new Error("CamStack preset missing");
+	return readyOf(presetRow, "unconfigured", false);
+}
+function readyOf(row, source, customized) {
+	return {
+		status: "ready",
+		presetId: row.id,
+		customized,
+		source,
+		swatches: row.swatches,
+		fallbacks: [...row.fallbacks]
+	};
+}
+function namedColours(swatches, fallbacks) {
+	const rows = [];
+	for (const id of PALETTE_ENTRY_IDS) {
+		const swatch = swatches[id];
+		if (swatch !== void 0) rows.push({
+			name: id,
+			hex: swatch.hex
+		});
+	}
+	fallbacks.forEach((hex, index) => {
+		rows.push({
+			name: `fallback-${index}`,
+			hex
+		});
+	});
+	return rows;
+}
+function gradientViolations(swatches) {
+	const audio = swatches[AUDIO_ENTRY_ID];
+	if (audio === void 0) return [];
+	if (audio.form !== "gradient") return [{
+		code: "bad-gradient",
+		entry: AUDIO_ENTRY_ID
+	}];
+	return AUDIO_GRADIENT_ALPHAS.every((alpha, index) => audio.alphas[index] === alpha) ? [] : [{
+		code: "bad-gradient",
+		entry: AUDIO_ENTRY_ID
+	}];
+}
+function isMarkPair(left, right) {
+	const marks = PALETTE_MARK_PAIR;
+	return marks.includes(left) && marks.includes(right);
+}
+/** Refuse a palette whose entries are not pairwise distinct on both themes. */
+function validatePalette(swatches, fallbacks) {
+	const violations = [];
+	for (const id of PALETTE_ENTRY_IDS) if (swatches[id] === void 0) violations.push({
+		code: "missing-entry",
+		entry: id
+	});
+	for (const key of Object.keys(swatches)) if (!isPaletteEntryId(key)) violations.push({
+		code: "unknown-entry",
+		entry: key
+	});
+	if (fallbacks.length !== 8) violations.push({ code: "bad-fallbacks" });
+	violations.push(...gradientViolations(swatches));
+	const rows = namedColours(swatches, fallbacks);
+	for (let i = 0; i < rows.length; i++) for (let j = i + 1; j < rows.length; j++) {
+		const left = rows[i];
+		const right = rows[j];
+		if (left === void 0 || right === void 0) continue;
+		const deltaE = deltaE00(left.hex, right.hex);
+		if (deltaE < (isMarkPair(left.name, right.name) ? 20 : 7)) violations.push({
+			code: "too-close",
+			left: left.name,
+			right: right.name,
+			deltaE
+		});
+	}
+	for (const row of rows) for (const background of ["dark", "light"]) {
+		const contrast = contrastRatio(row.hex, PALETTE_BACKGROUNDS[background]);
+		if (contrast < 3) violations.push({
+			code: "low-contrast",
+			entry: row.name,
+			background,
+			contrast
+		});
+	}
+	return violations.length === 0 ? { ok: true } : {
+		ok: false,
+		violations
+	};
+}
+function formatPaletteViolation(violation) {
+	switch (violation.code) {
+		case "too-close": return `${violation.left} vs ${violation.right} (ΔE ${violation.deltaE.toFixed(1)})`;
+		case "low-contrast": return `${violation.entry} on ${violation.background} (${violation.contrast.toFixed(1)}:1)`;
+		case "missing-entry": return `${violation.entry} is missing`;
+		case "unknown-entry": return `${violation.entry} is not a palette entry`;
+		case "bad-gradient": return `${violation.entry} gradient is not the six canonical steps`;
+		case "bad-fallbacks": return "fallback list must hold eight colours";
+		case "unknown-preset": return `${violation.presetId} is not a preset`;
+	}
+}
+function formatPaletteViolations(violations) {
+	return violations.map(formatPaletteViolation).join("; ");
+}
+var PaletteRejectedError = class extends Error {
+	violations;
+	constructor(violations) {
+		super(formatPaletteViolations(violations));
+		this.name = "PaletteRejectedError";
+		this.violations = violations;
+	}
+};
+function hashFallback(kind, fallbacks) {
+	let hash = 0;
+	for (let i = 0; i < kind.length; i++) hash = hash * 31 + (kind.codePointAt(i) ?? 0) >>> 0;
+	const hex = fallbacks[hash % fallbacks.length];
+	if (hex === void 0) throw new Error("display palette has no fallback colour");
+	return hex;
+}
+/** Colour a kind paints with. Audio leaves share the audio gradient's hex. */
+function paintHex(swatches, fallbacks, kind) {
+	const key = kind.trim().toLowerCase();
+	if (key.startsWith("audio-")) {
+		const audio = swatches[AUDIO_ENTRY_ID];
+		return audio !== void 0 ? audio.hex : hashFallback(key, fallbacks);
+	}
+	const direct = swatches[key];
+	if (direct !== void 0) return direct.hex;
+	return hashFallback(key, fallbacks);
+}
+function mergeOverrides(base, overrides) {
+	return {
+		...base,
+		...overrides
+	};
+}
+function overridesOf(input) {
+	return "overrides" in input ? input.overrides : {};
+}
+/** The palette a `setPalette` input would store. Invalid input is a refusal. */
+function paletteFromInput(input) {
+	const row = presetById(input.presetId);
+	if (row === void 0 || !isPalettePresetId(input.presetId)) throw new PaletteRejectedError([{
+		code: "unknown-preset",
+		presetId: input.presetId
+	}]);
+	const overrides = overridesOf(input);
+	const swatches = mergeOverrides(row.swatches, overrides);
+	const verdict = validatePalette(swatches, row.fallbacks);
+	if (!verdict.ok) throw new PaletteRejectedError(verdict.violations);
+	const customized = Object.keys(overrides).length > 0;
+	return {
+		status: "ready",
+		presetId: row.id,
+		customized,
+		source: "stored",
+		swatches,
+		fallbacks: [...row.fallbacks]
+	};
+}
+function isEmptyRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+/**
+* Interpret a settings blob. A missing row is the bundled preset and says so.
+* A blob that does not parse, names an unknown preset, or fails the rule is
+* `unknown` — never the default wearing the stored preset's name.
+*/
+function paletteFromStored(value) {
+	if (value === void 0 || value === null || isEmptyRecord(value)) return bundledCamstack();
+	const parsed = storedPaletteSchema.safeParse(value);
+	if (!parsed.success) return {
+		status: "unknown",
+		reason: "stored palette is unreadable"
+	};
+	const row = presetById(parsed.data.presetId);
+	if (row === void 0) return {
+		status: "unknown",
+		reason: `unknown preset ${parsed.data.presetId}`
+	};
+	const swatches = mergeOverrides(row.swatches, parsed.data.overrides);
+	const verdict = validatePalette(swatches, row.fallbacks);
+	if (!verdict.ok) return {
+		status: "unknown",
+		reason: formatPaletteViolations(verdict.violations)
+	};
+	const customized = Object.keys(parsed.data.overrides).length > 0;
+	return {
+		status: "ready",
+		presetId: row.id,
+		customized,
+		source: "stored",
+		swatches,
+		fallbacks: [...row.fallbacks]
+	};
+}
+function storedFromReady(ready, overrides) {
+	return {
+		presetId: ready.presetId,
+		overrides: { ...overrides }
+	};
+}
+/**
 * Unified event-kind taxonomy — THE single source of truth for
 * `kind → { parentKind, category, level, color, iconId, labelKey, label,
 * icon }`.
@@ -43236,109 +43879,88 @@ for (const [k, v] of Object.entries(APPLE_SA_TO_MACRO.mapping)) _macroLookup.set
 *   - `addon-post-analysis/shared/frame/box-drawer.ts` (DEFAULT_COLOR)
 *   - the COCO / audio class maps (macro ↔ sub relationships)
 *
-* The DATA (serializable — color/iconId/labelKey/parentKind) lives here in
-* `@camstack/types`. The UI-side mapping `iconId → lucide component` and
-* `labelKey → t()` lives in `@camstack/ui-library`. UIs never hardcode a
-* color or an icon: they read this dictionary (server descriptors carry the
-* fields inline; the client resolves color/icon/label from `iconId`/`kind`).
+* The DATA (serializable — parentKind / iconId / labelKey) lives here in
+* `@camstack/types`. Colour is NOT a second table: each entry's `color` is
+* the bundled CamStack display palette (D939). The effective cluster palette
+* is the `display-palette` capability. The UI-side mapping `iconId → lucide
+* component` and `labelKey → t()` lives in `@camstack/ui-library`.
 *
 * Two levels only (v1 YAGNI): macro → sub. `person` is a leaf macro.
 */
-var TAXONOMY_COLORS = {
-	motion: "#f59e0b",
-	audio: "#06b6d4",
-	person: "#22c55e",
-	vehicle: "#3b82f6",
-	animal: "#f97316",
-	package: "#a855f7",
-	sensor: "#8b5cf6",
-	control: "#10b981",
-	genericDetection: "#64748b"
-};
-var DETECTION_SUB_COLORS = {
-	car: "#f59e0b",
-	truck: "#d97706",
-	bus: "#b45309",
-	motorcycle: "#eab308",
-	bicycle: "#ca8a04",
-	airplane: "#60a5fa",
-	boat: "#2563eb",
-	train: "#1d4ed8",
-	bird: "#14b8a6",
-	dog: "#84cc16",
-	cat: "#f97316",
-	horse: "#a16207",
-	sheep: "#a3a3a3",
-	cow: "#78716c",
-	elephant: "#6b7280",
-	bear: "#7c2d12",
-	zebra: "#404040",
-	giraffe: "#d4a373"
-};
+var BUNDLED_PALETTE = bundledCamstack();
+function kindColor(kind) {
+	return paintHex(BUNDLED_PALETTE.swatches, BUNDLED_PALETTE.fallbacks, kind);
+}
+function firstFallback(fallbacks) {
+	const hex = fallbacks[0];
+	if (hex === void 0) throw new Error("display palette has no fallback colour");
+	return hex;
+}
+firstFallback(BUNDLED_PALETTE.fallbacks);
 function titleCase(id) {
 	return id.split(/[-_ ]/).filter((p) => p.length > 0).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join(" ");
 }
 var entries = /* @__PURE__ */ new Map();
-function macro(kind, category, color, iconId, label) {
+function macro(kind, category, iconId, label) {
 	entries.set(kind, {
 		kind,
 		parentKind: null,
 		level: "macro",
 		category,
-		color,
+		color: kindColor(kind),
 		iconId,
 		labelKey: `eventKind.${kind}`,
 		label
 	});
 }
-function sub(kind, parentKind, category, color, iconId, label) {
+function sub(kind, parentKind, category, iconId, label) {
 	entries.set(kind, {
 		kind,
 		parentKind,
 		level: "sub",
 		category,
-		color,
+		color: kindColor(kind),
 		iconId,
 		labelKey: `eventKind.${kind}`,
 		label
 	});
 }
-macro("motion", "motion", TAXONOMY_COLORS.motion, "motion", "Motion");
-macro("audio", "audio", TAXONOMY_COLORS.audio, "audio", "Audio");
-macro("person", "detection", TAXONOMY_COLORS.person, "person", "Person");
-macro("vehicle", "detection", TAXONOMY_COLORS.vehicle, "vehicle", "Vehicle");
-macro("animal", "detection", TAXONOMY_COLORS.animal, "animal", "Animal");
-macro("package", "package", TAXONOMY_COLORS.package, "package", "Package");
-macro("sensor", "sensor", TAXONOMY_COLORS.sensor, "sensor", "Sensor");
-macro("control", "control", TAXONOMY_COLORS.control, "control", "Control");
+macro("motion", "motion", "motion", "Motion");
+macro("audio", "audio", "audio", "Audio");
+macro("person", "detection", "person", "Person");
+macro("vehicle", "detection", "vehicle", "Vehicle");
+macro("animal", "detection", "animal", "Animal");
+macro("package", "package", "package", "Package");
+macro("sensor", "sensor", "sensor", "Sensor");
+macro("control", "control", "control", "Control");
 for (const [cocoClass, macroClass] of Object.entries(COCO_TO_MACRO.mapping)) {
 	if (macroClass !== "vehicle" && macroClass !== "animal") continue;
 	if (entries.has(cocoClass)) continue;
-	sub(cocoClass, macroClass, "detection", DETECTION_SUB_COLORS[cocoClass] ?? TAXONOMY_COLORS.genericDetection, cocoClass, titleCase(cocoClass));
-}
-sub("package-delivered", "package", "package", TAXONOMY_COLORS.package, "package", "Package delivered");
-sub("package-picked-up", "package", "package", TAXONOMY_COLORS.package, "package", "Package picked up");
-sub("contact", "sensor", "sensor", "#f59e0b", "door", "Contact");
-sub("motion-sensor", "sensor", "sensor", TAXONOMY_COLORS.sensor, "pir", "Motion sensor");
-sub("smoke", "sensor", "sensor", "#ef4444", "smoke", "Smoke");
-sub("flood", "sensor", "sensor", "#3b82f6", "water", "Water leak");
-sub("gas", "sensor", "sensor", "#ef4444", "gas", "Gas");
-sub("carbon-monoxide", "sensor", "sensor", "#dc2626", "smoke", "Carbon monoxide");
-sub("vibration", "sensor", "sensor", "#eab308", "vibration", "Vibration");
-sub("tamper", "sensor", "sensor", "#f97316", "tamper", "Tamper");
-sub("presence", "sensor", "sensor", "#22c55e", "presence", "Presence");
-sub("enum-sensor", "sensor", "sensor", TAXONOMY_COLORS.sensor, "generic", "Sensor state");
-sub("device-event", "sensor", "sensor", "#10b981", "button", "Device event");
-sub("lock", "control", "control", "#0ea5e9", "lock", "Lock");
-sub("cover", "control", "control", "#0ea5e9", "door", "Cover");
-sub("switch", "control", "control", TAXONOMY_COLORS.control, "switch", "Switch");
-sub("siren", "control", "control", "#dc2626", "siren", "Siren");
-sub("button", "control", "control", "#10b981", "button", "Button");
-sub("doorbell", "control", "control", "#a855f7", "doorbell", "Doorbell");
+	sub(cocoClass, macroClass, "detection", cocoClass, titleCase(cocoClass));
+}
+sub("package-delivered", "package", "package", "package", "Package delivered");
+sub("package-picked-up", "package", "package", "package", "Package picked up");
+sub("contact", "sensor", "sensor", "door", "Contact");
+sub("motion-sensor", "sensor", "sensor", "pir", "Motion sensor");
+sub("smoke", "sensor", "sensor", "smoke", "Smoke");
+sub("flood", "sensor", "sensor", "water", "Water leak");
+sub("gas", "sensor", "sensor", "gas", "Gas");
+sub("carbon-monoxide", "sensor", "sensor", "smoke", "Carbon monoxide");
+sub("vibration", "sensor", "sensor", "vibration", "Vibration");
+sub("tamper", "sensor", "sensor", "tamper", "Tamper");
+sub("presence", "sensor", "sensor", "presence", "Presence");
+sub("enum-sensor", "sensor", "sensor", "generic", "Sensor state");
+sub("device-event", "sensor", "sensor", "button", "Device event");
+sub("lock", "control", "control", "lock", "Lock");
+sub("cover", "control", "control", "door", "Cover");
+sub("switch", "control", "control", "switch", "Switch");
+sub("siren", "control", "control", "siren", "Siren");
+sub("button", "control", "control", "button", "Button");
+sub("doorbell", "control", "control", "doorbell", "Doorbell");
 for (const l of AUDIO_MACRO_LABELS) {
 	const kind = `audio-${l.id}`;
 	if (entries.has(kind)) continue;
-	sub(kind, "audio", "audio", TAXONOMY_COLORS.audio, kind, l.name);
+	sub(kind, "audio", "audio", kind, l.name);
 }
 /** The complete taxonomy dictionary, keyed by kind. */
 var EVENT_TAXONOMY = Object.freeze(Object.fromEntries(entries));
@@ -56971,6 +57593,39 @@ DeviceType.Camera, method(object({ deviceId: number() }), DayNightOptionsSchema)
 	auth: "admin"
 });
 /**
+* display-palette — the cluster's one colour table (D939).
+*
+* Hub singleton. `getPalette` reports `unknown` when the settings store
+* cannot be read; it does not pretend the bundled preset was stored.
+* `setPalette` refuses a palette that fails the ΔE / contrast rule and names
+* the pairs.
+*/
+var presetSummarySchema = object({
+	id: string(),
+	name: string(),
+	swatches: record(string(), paletteSwatchSchema),
+	fallbacks: array(string())
+});
+var displayPaletteCapability = {
+	name: "display-palette",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		getPalette: method(_void(), paletteResultSchema, {
+			auth: "protected",
+			role: "viewer"
+		}),
+		listPresets: method(_void(), array(presetSummarySchema).readonly(), {
+			auth: "protected",
+			role: "viewer"
+		}),
+		setPalette: method(setPaletteInputSchema, paletteReadySchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
+	}
+};
+/**
 * Generic device-level status snapshot. Auto-registered by `BaseDevice`
 * for every device, regardless of provider — the kernel needs a uniform
 * cap-keyed slice for the basic device flags every consumer expects to
@@ -68704,6 +69359,27 @@ Object.freeze({
 		access: "create",
 		role: "viewer"
 	},
+	"displayPalette.getPalette": {
+		capName: "display-palette",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"displayPalette.listPresets": {
+		capName: "display-palette",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"displayPalette.setPalette": {
+		capName: "display-palette",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"doorbell.getStatus": {
 		capName: "doorbell",
 		capScope: "device",
@@ -79160,6 +79836,7 @@ var SYSTEM_CAP_VOCABULARY = {
 	"device-provider": system(INTERNAL),
 	"device-removal-hook": system(INTERNAL),
 	"device-state": system("the runtime-state mirror every trigger already reads through"),
+	"display-palette": system("the cluster display palette — one colour table for every client, not a device action"),
 	"embedding-encoder": system(ML),
 	"face-gallery": system("the face gallery — curated on its own page"),
 	"failure-contribution": system(INTERNAL),
@@ -103036,6 +103713,112 @@ function deriveRuntimeSettings(config) {
 	};
 }
 //#endregion
+//#region src/display-palette-provider.ts
+/**
+* Display palette provider (D939, D940). The pipeline orchestrator owns
+* this cluster setting. The document is one key in the addon's store, so
+* a write does not replace the orchestrator's other settings. An
+* unreadable store is `unknown`, never the bundled preset.
+*/
+/** Key inside the orchestrator's addon store. Not a settings-schema field. */
+var DISPLAY_PALETTE_STORE_KEY = "displayPalette";
+function createDisplayPaletteProvider(settings, logger) {
+	return {
+		getPalette: async () => readPalette(settings, logger),
+		listPresets: async () => DISPLAY_PRESETS.map((row) => ({
+			id: row.id,
+			name: row.name,
+			swatches: row.swatches,
+			fallbacks: [...row.fallbacks]
+		})),
+		setPalette: async (input) => writePalette(settings, logger, input)
+	};
+}
+async function readPalette(settings, logger) {
+	if (settings === void 0) {
+		logger.warn("display-palette: settings store cannot be read three ways");
+		return {
+			status: "unknown",
+			reason: "settings store cannot be read"
+		};
+	}
+	const readKey = settings.readAddonStoreKeyResult;
+	if (readKey !== void 0) return readByKey(settings, readKey, logger);
+	const read = settings.readAddonStoreResult;
+	if (read === void 0) {
+		logger.warn("display-palette: settings store cannot be read three ways");
+		return {
+			status: "unknown",
+			reason: "settings store cannot be read"
+		};
+	}
+	return readByStore(settings, read, logger);
+}
+async function readByKey(settings, readKey, logger) {
+	let result;
+	try {
+		result = await readKey.call(settings, DISPLAY_PALETTE_STORE_KEY);
+	} catch (err) {
+		return readThrew(logger, err);
+	}
+	if (result.kind === "unreadable") {
+		logger.warn("display-palette: settings unreadable", { meta: { error: result.error } });
+		return {
+			status: "unknown",
+			reason: result.error ?? "settings store cannot be read"
+		};
+	}
+	if (result.kind === "absent") return bundledCamstack();
+	return interpretStored(logger, result.value);
+}
+async function readByStore(settings, read, logger) {
+	let result;
+	try {
+		result = await read.call(settings);
+	} catch (err) {
+		return readThrew(logger, err);
+	}
+	if (result.kind === "failed") {
+		logger.warn("display-palette: settings unreadable", { meta: { error: result.error } });
+		return {
+			status: "unknown",
+			reason: result.error
+		};
+	}
+	if (result.kind === "missing") return bundledCamstack();
+	return interpretStored(logger, result.value[DISPLAY_PALETTE_STORE_KEY]);
+}
+function readThrew(logger, err) {
+	const error = err instanceof Error ? err.message : String(err);
+	logger.warn("display-palette: settings read threw", { meta: { error } });
+	return {
+		status: "unknown",
+		reason: "settings store read failed"
+	};
+}
+function interpretStored(logger, value) {
+	const palette = paletteFromStored(value);
+	if (palette.status === "unknown") logger.warn("display-palette: stored palette is not usable", { meta: { reason: palette.reason } });
+	return palette;
+}
+async function writePalette(settings, logger, input) {
+	let ready;
+	try {
+		ready = paletteFromInput(input);
+	} catch (err) {
+		if (err instanceof PaletteRejectedError) logger.info("display-palette: refused", { meta: { reason: err.message } });
+		throw err;
+	}
+	const write = settings?.writeAddonStore;
+	if (settings === void 0 || write === void 0) {
+		logger.warn("display-palette: settings store cannot be written");
+		throw new Error("display-palette: settings store cannot be written");
+	}
+	const overrides = "overrides" in input ? input.overrides : {};
+	await write.call(settings, { [DISPLAY_PALETTE_STORE_KEY]: storedFromReady(ready, overrides) });
+	return ready;
+}
+//#endregion
 //#region src/viewer-ui-provider.ts
 /**
 * viewer-ui provider — the pipeline-orchestrator serves the CamStack viewer web
@@ -104492,6 +105275,10 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 				{
 					capability: viewerUiCapability,
 					provider: createViewerUiProvider()
+				},
+				{
+					capability: displayPaletteCapability,
+					provider: createDisplayPaletteProvider(this.ctx.settings, this.ctx.logger)
 				}
 			],
 			customActions: pipelineOrchestratorActions,