@camstack/types 1.2.406 → 1.2.408

package/dist/index.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sleep = require("./sleep-UP964hNP.js");
 const require_event_category = require("./event-category-DG6Vir8Z.js");
-const require_composition = require("./composition-RmnnN39T.js");
+const require_composition = require("./composition-CSLSFGTO.js");
 const require_node_color = require("./node-color.js");
 const require_err_msg = require("./err-msg-BhVbr0NX.js");
 const require_enums = require("./enums.js");
@@ -12766,6 +12766,13 @@ var ComposerUnreadableBlockSchema = zod.z.object({
 	/** The parse error, in the operator's words. */
 	error: zod.z.string()
 });
+/** A confirmed release the hub did not accept. `deviceId` is the claim's device. */
+var UnreleasedClaimSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	capName: zod.z.string(),
+	owner: zod.z.string(),
+	error: zod.z.string()
+});
 var ComposerApplyInputSchema = zod.z.object({
 	/** The shared Blocks integration; null until `core-blocks` has reconciled it. */
 	integrationId: zod.z.string().nullable(),
@@ -12775,7 +12782,13 @@ var ComposerApplyInputSchema = zod.z.object({
 	/** Operator restarts: rebuild these runtimes and re-resolve their sources. Stores nothing (D62). */
 	restartBlockIds: zod.z.array(zod.z.string()),
 	/** Composition rows that exist but do not parse: held, never withdrawn, reported failed. */
-	unreadableBlocks: zod.z.array(ComposerUnreadableBlockSchema)
+	unreadableBlocks: zod.z.array(ComposerUnreadableBlockSchema),
+	/**
+	* Operator-confirmed deletions. Their claims are released on this apply,
+	* before any replacement block claims. A block that merely vanished from the
+	* snapshot is not listed here and still waits for two applies (D49).
+	*/
+	retiredBlockIds: zod.z.array(zod.z.string()).optional()
 });
 var ComposerBlockVerdictSchema = zod.z.object({
 	blockId: zod.z.string(),
@@ -12789,7 +12802,13 @@ var ComposerApplyResultSchema = zod.z.object({
 	* integration unknown, its own rows unread or read empty once). An empty
 	* apply the caller owes is paid off only by one the composer acted on (D49).
 	*/
-	acted: zod.z.boolean()
+	acted: zod.z.boolean(),
+	/**
+	* Confirmed releases this apply tried and the hub did not accept. Empty when
+	* every one landed (or there was nothing to hand back). Absent on a result
+	* that never got that far.
+	*/
+	unreleasedClaims: zod.z.array(UnreleasedClaimSchema).optional()
 });
 var composerCapability = {
 	name: "composer",
@@ -60326,20 +60345,68 @@ var BatteryStatusSchema = zod.z.object({
 	*/
 	binary: zod.z.boolean().optional()
 });
+var BATTERY_DEVICE_TYPES = [
+	require_err_msg.DeviceType.Camera,
+	require_err_msg.DeviceType.Sensor,
+	require_err_msg.DeviceType.Button,
+	require_err_msg.DeviceType.Switch,
+	require_err_msg.DeviceType.PetFeeder,
+	require_err_msg.DeviceType.Container,
+	require_err_msg.DeviceType.Thermostat
+];
+/** Generic Customize target for the percentage reading (D936). */
+var batteryCustomize = {
+	version: 1,
+	targets: [{
+		id: "percentage",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "battery",
+			stateField: "percentage"
+		},
+		deviceTypes: BATTERY_DEVICE_TYPES,
+		apply: "add-or-replace",
+		path: "percentage",
+		sources: [{
+			kind: "field",
+			valueKinds: ["number", "string"],
+			transforms: [{ kind: "identity" }, {
+				kind: "linear",
+				defaultScale: 1,
+				defaultOffset: 0,
+				clampMin: 0,
+				clampMax: 100
+			}]
+		}],
+		companions: [
+			{
+				kind: "constant",
+				path: "charging",
+				value: "unknown",
+				when: "add"
+			},
+			{
+				kind: "constant",
+				path: "sleeping",
+				value: false,
+				when: "add"
+			},
+			{
+				kind: "clock",
+				path: "lastUpdated",
+				when: "add"
+			}
+		],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: true
+	}]
+};
 var batteryCapability = {
 	name: "battery",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [
-		require_err_msg.DeviceType.Camera,
-		require_err_msg.DeviceType.Sensor,
-		require_err_msg.DeviceType.Button,
-		require_err_msg.DeviceType.Switch,
-		require_err_msg.DeviceType.PetFeeder,
-		require_err_msg.DeviceType.Container,
-		require_err_msg.DeviceType.Thermostat
-	],
+	deviceTypes: BATTERY_DEVICE_TYPES,
 	methods: { 
 	/**
 	* Explicitly wake the camera from low-power sleep ahead of a
@@ -60423,6 +60490,7 @@ onStatusChanged: { data: zod.z.object({
 		kind: "gauge",
 		unit: "%"
 	} } },
+	customize: batteryCustomize,
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastUpdated"]
@@ -61621,6 +61689,106 @@ var ConsumablesStatusSchema = zod.z.object({
 	items: zod.z.array(ConsumableItemSchema),
 	lastChangedAt: zod.z.number()
 });
+/** Synthesize seed for a link-built status (no native provider).
+*
+*  ⚠ NO LIVE CALLER since 2026-08-08 (device-links deleted; see
+*  `CapabilityStatusSchema.empty`). The wiring guidance below was written for
+*  exactly the case the operator is asking about again — a Dreame's HA
+*  consumable-life sensors — so it is kept for that conversation, not because
+*  anything reads it today. */
+var EMPTY_STATUS = {
+	items: [],
+	lastChangedAt: 0
+};
+/** Seed for a NEW link-built consumable item. `key`/`label` are overwritten
+*  with the link's `itemKey` (see `status.itemArray`), so the placeholder
+*  empty strings never survive into a validated item. Link-built items are
+*  not resettable — there is no native provider to receive `reset()`.
+*
+*  Wiring guidance (HA vacuum consumable-life sensors):
+*  - a percent-remaining source (`numeric-sensor`, unit '%') → `level` via
+*    `identity` (or `linear` scale 1 offset 0 clamp [0,100] to be safe);
+*  - an hours-remaining source (e.g. Dreame 'Main Brush Time Left', unit 'h')
+*    → `level` via `linear` with scale = 100 / max-hours for that item
+*    (e.g. main brush 300 h → scale 0.3333) + clamp [0,100];
+*  - a discrete source (`enum-sensor`, e.g. mop pad 'installed') → `status`
+*    via `enum-map` (e.g. { installed: 'ok', missing: 'replace' }).
+*  A numeric→'replace' THRESHOLD (level < 10 → 'replace') is NOT expressible
+*  with the current transform kinds — leave `status` null (valid) until the
+*  expression transform lands. */
+/** Generic Customize target for one consumable item (D936). Native rows stay read-only. */
+var consumablesCustomize = {
+	version: 1,
+	targets: [{
+		id: "items",
+		cardinality: "keyedArray",
+		vocabulary: { cap: "consumables" },
+		deviceTypes: Object.values(require_err_msg.DeviceType),
+		apply: "add",
+		path: "items",
+		keyField: "key",
+		labelField: "label",
+		itemSchema: ConsumableItemSchema,
+		nativeItems: "read-only",
+		sourceReport: { status: "assignment-status" },
+		fields: [
+			{
+				path: "level",
+				sources: [{
+					kind: "numeric",
+					transforms: [{ kind: "identity" }, {
+						kind: "linear",
+						defaultScale: 1,
+						defaultOffset: 0,
+						clampMin: 0,
+						clampMax: 100
+					}]
+				}]
+			},
+			{
+				path: "remaining.value",
+				sources: [{
+					kind: "numeric",
+					transforms: [{ kind: "identity" }]
+				}],
+				literals: [{
+					path: "remaining.unit",
+					values: [...ConsumableRemainingUnitSchema.options]
+				}]
+			},
+			{
+				path: "status",
+				sources: [{
+					kind: "enum",
+					transforms: [{
+						kind: "enum-map",
+						outputValues: [...ConsumableStatusSchema.options],
+						unmapped: null
+					}]
+				}]
+			}
+		],
+		traits: [{
+			path: "kind",
+			values: [...ConsumableKindSchema.options],
+			defaultValue: "wear"
+		}, {
+			path: "form",
+			values: [...ConsumableFormSchema.options],
+			defaultValue: "part"
+		}],
+		companions: [{
+			kind: "clock",
+			path: "lastChangedAt",
+			when: "add"
+		}, {
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "add"
+		}],
+		advancedExpression: true
+	}]
+};
 var consumablesCapability = {
 	name: "consumables",
 	scope: "device",
@@ -61658,10 +61826,7 @@ reset: require_sleep.method(zod.z.object({
 	status: {
 		schema: ConsumablesStatusSchema,
 		kind: "push",
-		empty: {
-			items: [],
-			lastChangedAt: 0
-		},
+		empty: EMPTY_STATUS,
 		itemArray: {
 			path: "items",
 			keyField: "key",
@@ -61697,6 +61862,7 @@ reset: require_sleep.method(zod.z.object({
 	* brush's remaining life and a dishwasher's salt are each recorded the moment
 	* their provider reports them; an item that appears later gets its series.
 	*/
+	customize: consumablesCustomize,
 	history: {
 		fields: {},
 		items: {
@@ -62499,6 +62665,38 @@ var dishwasherCapability = {
 };
 //#endregion
 //#region src/capabilities/doorbell.cap.ts
+/** A rise closer than this to the previous one is the same press (D671). */
+var DOORBELL_RISE_DEBOUNCE_MS = 2e3;
+/** Pulse override: a rising edge advances `lastPressedAt` and the press count. */
+var doorbellCustomize = {
+	version: 1,
+	targets: [{
+		id: "pressed",
+		cardinality: "event",
+		shape: "pulse",
+		vocabulary: {
+			cap: "doorbell",
+			eventName: "onPressed"
+		},
+		deviceTypes: [require_err_msg.DeviceType.Camera],
+		apply: "add",
+		applyAuthority: { kind: "composition-claim" },
+		eventName: "onPressed",
+		edges: ["rising"],
+		timestampPath: "lastPressedAt",
+		counterPath: "pressCountSinceStart",
+		highWater: "composer-advance",
+		combine: "any",
+		debounce: {
+			kind: "rising-edge",
+			defaultDebounceMs: DOORBELL_RISE_DEBOUNCE_MS,
+			changedAtRequired: true
+		},
+		sources: [{ kind: "binary" }, { kind: "switch" }],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: true
+	}]
+};
 var DoorbellStatusSchema = zod.z.object({
 	/** Ms epoch of the last press. null = never observed since this provider started. */
 	lastPressedAt: zod.z.number().nullable(),
@@ -62565,7 +62763,8 @@ onPressed: {
 	/**
 	* History (D850): none — `pressCountSinceStart` resets with the addon, so it is not a monotonic meter; presses live in the events ledger.
 	*/
-	history: "none"
+	history: "none",
+	customize: doorbellCustomize
 };
 //#endregion
 //#region src/capabilities/enum-sensor.cap.ts
@@ -65312,6 +65511,44 @@ authKey: zod.z.string().optional() }), zod.z.object({
 //#endregion
 //#region src/capabilities/motion.cap.ts
 /**
+* Span timeout for a camera's attached sensors. This is the pipeline-runner
+* `motionCooldownMs` default: the window after which a heartbeat-only edge
+* no longer counts. The span does not declare a separate cooldown.
+*/
+var MOTION_SPAN_TIMEOUT_MS = 3e4;
+/** Span override: start on a rising edge, end on a fall or this timeout. */
+var motionCustomize = {
+	version: 1,
+	targets: [{
+		id: "detected",
+		cardinality: "event",
+		shape: "span",
+		vocabulary: {
+			cap: "motion",
+			eventName: "onMotionChanged"
+		},
+		deviceTypes: [require_err_msg.DeviceType.Camera],
+		apply: "replace",
+		applyAuthority: {
+			kind: "camera-sensors",
+			timeoutField: "motionCooldownMs"
+		},
+		eventName: "onMotionChanged",
+		start: "rising-edge",
+		end: "falling-edge-or-timeout",
+		timeoutMs: MOTION_SPAN_TIMEOUT_MS,
+		combine: "any",
+		sourceModes: [
+			"in-addition",
+			"confirm",
+			"replace"
+		],
+		sources: [{ kind: "binary" }, { kind: "switch" }],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: false
+	}]
+};
+/**
 * Hardware / firmware motion sensor cap — binary detected state plus
 * a timestamp of the last observation. Distinct from
 * `motion-detection.cap.ts` which owns the LOCAL ML motion pipeline;
@@ -65475,7 +65712,8 @@ onMotionChanged: { data: MotionOnMotionChangedDataSchema } },
 	history: { fields: { detected: {
 		kind: "boolean",
 		excludeDeviceTypes: [require_err_msg.DeviceType.Camera]
-	} } }
+	} } },
+	customize: motionCustomize
 };
 //#endregion
 //#region src/capabilities/motion-trigger.cap.ts
@@ -69589,6 +69827,19 @@ var ptzAutotrackCapability = {
 	history: "none"
 };
 //#endregion
+//#region src/running-state/defaults.ts
+var RUNNING_POWER_THRESHOLD_WATTS = 5;
+var RUNNING_POWER_START_DELAY_MS = 3e4;
+var RUNNING_POWER_STOP_DELAY_MS = 18e4;
+/** Before any provider reading — all fields unknown (D933). */
+var RUNNING_STATE_COLD = {
+	running: null,
+	since: null,
+	source: "native",
+	phase: null,
+	lastFetchedAt: null
+};
+//#endregion
 //#region src/capabilities/running-state.cap.ts
 var RunningStateSourceSchema = zod.z.enum(["native", "assigned"]);
 var RunningStateStatusSchema = zod.z.object({
@@ -69598,19 +69849,100 @@ var RunningStateStatusSchema = zod.z.object({
 	since: zod.z.number().nullable(),
 	source: RunningStateSourceSchema,
 	phase: zod.z.string().nullable(),
-	lastFetchedAt: zod.z.number()
+	/** null until a reading has been published (D393). */
+	lastFetchedAt: zod.z.number().nullable()
 });
 var RunningFlipEventDataSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	since: zod.z.number().nullable(),
 	phase: zod.z.string().nullable()
 });
+var RUNNING_DEVICE_TYPES = Object.values(require_err_msg.DeviceType);
+/** Generic Customize target for the running boolean (D936). */
+var runningCustomize = {
+	version: 1,
+	targets: [{
+		id: "running",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "running-state",
+			stateField: "running"
+		},
+		deviceTypes: [
+			require_err_msg.DeviceType.Dishwasher,
+			require_err_msg.DeviceType.Vacuum,
+			require_err_msg.DeviceType.LawnMower,
+			require_err_msg.DeviceType.MediaPlayer,
+			require_err_msg.DeviceType.WaterHeater,
+			require_err_msg.DeviceType.Humidifier,
+			require_err_msg.DeviceType.Fan,
+			require_err_msg.DeviceType.Climate,
+			require_err_msg.DeviceType.Thermostat,
+			require_err_msg.DeviceType.PetFeeder
+		],
+		apply: "add-or-replace",
+		path: "running",
+		sources: [
+			{
+				kind: "switch",
+				transforms: [{ kind: "identity" }]
+			},
+			{
+				kind: "binary",
+				transforms: [{ kind: "identity" }, { kind: "invert" }]
+			},
+			{
+				kind: "numeric",
+				requiredUnit: "W",
+				transforms: [{
+					kind: "threshold",
+					comparison: "gte",
+					defaultThreshold: 5,
+					defaultStartDwellMs: RUNNING_POWER_START_DELAY_MS,
+					defaultStopDwellMs: RUNNING_POWER_STOP_DELAY_MS,
+					thresholdUnit: "W"
+				}]
+			}
+		],
+		companions: [
+			{
+				kind: "constant",
+				path: "source",
+				value: "assigned",
+				when: "always"
+			},
+			{
+				kind: "constant",
+				path: "phase",
+				value: null,
+				when: "always"
+			},
+			{
+				kind: "clock",
+				path: "lastFetchedAt",
+				when: "always"
+			},
+			{
+				kind: "transition-time",
+				path: "since",
+				sourceChangedAt: "prefer"
+			}
+		],
+		sourceReport: {
+			status: "assignment-status",
+			runtimeField: "source",
+			nativeValue: "native",
+			assignedValue: "assigned"
+		},
+		advancedExpression: true
+	}]
+};
 var runningStateCapability = {
 	name: "running-state",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: Object.values(require_err_msg.DeviceType),
+	deviceTypes: RUNNING_DEVICE_TYPES,
 	methods: {},
 	events: {
 		onStarted: { data: RunningFlipEventDataSchema },
@@ -69623,7 +69955,8 @@ var runningStateCapability = {
 	runtimeState: RunningStateStatusSchema,
 	durability: "restored",
 	history: { fields: { running: { kind: "boolean" } } },
-	volatileStateFields: ["lastFetchedAt"]
+	volatileStateFields: ["lastFetchedAt"],
+	customize: runningCustomize
 };
 //#endregion
 //#region src/capabilities/reboot.cap.ts
@@ -75852,213 +76185,58 @@ var PIPELINE_OWNER_CAPABILITY_NAMES = [
 	"pipeline-runner"
 ];
 //#endregion
-//#region src/running-state/assignment.ts
-function constant(literal) {
-	return {
-		kind: "expression",
-		expr: literal,
-		bindings: {}
-	};
-}
-function fromRead(source, cap, fieldPath) {
-	return {
-		kind: "from",
-		source,
-		cap,
-		fieldPath
-	};
-}
-function sortKeys(value) {
-	if (Array.isArray(value)) return value.map(sortKeys);
-	if (typeof value !== "object" || value === null) return value;
-	return Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, inner]) => [key, sortKeys(inner)]));
-}
-function sameFeature(a, b) {
-	return JSON.stringify(sortKeys(a)) === JSON.stringify(sortKeys(b));
-}
-function booleanRunningField(input) {
-	if (input.source.kind !== "boolean") return null;
-	const read = fromRead(input.source.source, input.source.cap, input.source.fieldPath);
-	if (!input.invert) return read;
-	return {
-		kind: "expression",
-		expr: "!x",
-		bindings: { x: read }
-	};
-}
-function sinceField(input) {
-	if (input.source.kind === "boolean" && input.changedAtField !== null) return fromRead(input.source.source, input.source.cap, input.changedAtField);
-	return {
-		kind: "expression",
-		expr: "latchedAt(running)",
-		bindings: { running: fromRead(input.target, "running-state", "running") }
-	};
-}
-function powerRunningField(input) {
-	if (input.source.kind !== "number") return null;
-	if (!Number.isFinite(input.thresholdWatts) || !Number.isFinite(input.startDelayMs) || !Number.isFinite(input.stopDelayMs) || input.thresholdWatts < 0 || input.startDelayMs < 0 || input.stopDelayMs < 0) return null;
-	const read = fromRead(input.source.source, input.source.cap, input.source.fieldPath);
-	return {
-		kind: "expression",
-		expr: `dwell(x >= ${input.thresholdWatts}, ${input.startDelayMs}, ${input.stopDelayMs})`,
-		bindings: { x: read }
-	};
-}
-function runningAssignmentFeature(input) {
-	const running = input.source.kind === "number" ? powerRunningField(input) : booleanRunningField(input);
-	if (running === null) return null;
-	return {
-		kind: "fields",
-		cap: "running-state",
-		fields: {
-			source: constant("\"assigned\""),
-			phase: constant("null"),
-			lastFetchedAt: constant("now"),
-			running,
-			since: sinceField(input)
-		}
-	};
-}
-function booleanSourceFromRunningField(source) {
-	if (source === void 0) return null;
-	if (source.kind === "from") return {
-		source: source.source,
-		cap: source.cap,
-		fieldPath: source.fieldPath,
-		kind: "boolean"
-	};
-	if (source.kind !== "expression" || source.expr !== "!x") return null;
-	const x = source.bindings["x"];
-	if (x === void 0 || x.kind !== "from") return null;
-	return {
-		source: x.source,
-		cap: x.cap,
-		fieldPath: x.fieldPath,
-		kind: "boolean"
-	};
-}
-function recoverPowerRunning(running) {
-	if (running === void 0 || running.kind !== "expression") return null;
-	const match = /^dwell\(x >= ([\d.]+), (\d+), (\d+)\)$/.exec(running.expr);
-	if (match === null) return null;
-	const x = running.bindings["x"];
-	if (x === void 0 || x.kind !== "from") return null;
-	const thresholdWatts = Number(match[1]);
-	const startDelayMs = Number(match[2]);
-	const stopDelayMs = Number(match[3]);
-	if (!Number.isFinite(thresholdWatts) || !Number.isFinite(startDelayMs) || !Number.isFinite(stopDelayMs)) return null;
-	return {
-		source: {
-			...x,
-			kind: "number"
-		},
-		invert: false,
-		thresholdWatts,
-		startDelayMs,
-		stopDelayMs
-	};
-}
-/** Recover what {@link runningAssignmentFeature} wrote, else null. */
-function runningAssignmentRecovered(stored, target) {
-	if (stored.cap !== "running-state" || stored.kind !== "fields") return null;
-	const power = recoverPowerRunning(stored.fields["running"]);
-	if (power !== null) return power;
-	const booleanSource = booleanSourceFromRunningField(stored.fields["running"]);
-	if (booleanSource === null) return null;
-	const since = stored.fields["since"];
-	let changedAtField = null;
-	if (since?.kind === "from" && since.cap === booleanSource.cap && since.source.addonId === booleanSource.source.addonId && since.source.stableId === booleanSource.source.stableId) changedAtField = since.fieldPath;
-	const rebuilt = runningAssignmentFeature({
-		mode: "replace",
-		target,
-		source: booleanSource,
-		changedAtField,
-		invert: stored.fields["running"]?.kind === "expression" && stored.fields["running"].expr === "!x",
-		thresholdWatts: 0,
-		startDelayMs: 0,
-		stopDelayMs: 0
-	});
-	if (rebuilt === null) return null;
-	const { enabled: _e, ...rest } = stored;
-	if (!sameFeature(rest, rebuilt)) return null;
-	return {
-		source: booleanSource,
-		invert: stored.fields["running"]?.kind === "expression" && stored.fields["running"].expr === "!x",
-		thresholdWatts: 0,
-		startDelayMs: 0,
-		stopDelayMs: 0
-	};
-}
-function isRunningAssignmentFeature(stored, mode, target) {
-	const recovered = runningAssignmentRecovered(stored, target);
-	if (recovered === null) return false;
-	const rebuilt = recovered.source.kind === "number" ? runningAssignmentFeature({
-		mode,
-		target,
-		source: recovered.source,
-		changedAtField: null,
-		invert: false,
-		thresholdWatts: recovered.thresholdWatts,
-		startDelayMs: recovered.startDelayMs,
-		stopDelayMs: recovered.stopDelayMs
-	}) : runningAssignmentFeature({
-		mode,
-		target,
-		source: recovered.source,
-		changedAtField: stored.fields["since"]?.kind === "from" ? stored.fields["since"].fieldPath : null,
-		invert: recovered.invert,
-		thresholdWatts: 0,
-		startDelayMs: 0,
-		stopDelayMs: 0
-	});
-	if (rebuilt === null) return false;
-	const { enabled: _enabled, ...rest } = stored;
-	return sameFeature(rest, rebuilt);
-}
-//#endregion
-//#region src/running-state/defaults.ts
-var RUNNING_POWER_THRESHOLD_WATTS = 5;
-var RUNNING_POWER_START_DELAY_MS = 3e4;
-var RUNNING_POWER_STOP_DELAY_MS = 18e4;
-//#endregion
 //#region src/running-state/from-operation.ts
-function resolveSince(running, previous, sinceMs) {
+function programStartFromRemaining(running, remainingSeconds, fetchedAt) {
+	if (!running || remainingSeconds === null || remainingSeconds === void 0) return null;
+	if (remainingSeconds <= 0) return null;
+	return fetchedAt - remainingSeconds * 1e3;
+}
+function resolveSince(running, previous, transitionAtMs, bootstrapSinceMs) {
 	if (running === null) return null;
-	if ((previous?.running ?? null) !== running) return sinceMs;
-	return previous?.since ?? sinceMs;
+	const prevRunning = previous?.running ?? null;
+	if (prevRunning === null) return bootstrapSinceMs;
+	if (prevRunning !== running) return transitionAtMs;
+	return previous?.since ?? null;
 }
-function nativeSlice(running, phase, previous, sinceMs, now) {
+function nativeSlice(running, phase, previous, transitionAtMs, fetchedAt, bootstrapSinceMs) {
 	return {
 		running,
-		since: resolveSince(running, previous, sinceMs),
+		since: resolveSince(running, previous, transitionAtMs, bootstrapSinceMs),
 		source: "native",
 		phase: running === null ? null : phase,
-		lastFetchedAt: now
+		lastFetchedAt: fetchedAt
 	};
 }
-function runningFromDishwasherOperation(operation, program, previous, now) {
-	if (operation === null) return nativeSlice(null, null, previous, now, now);
-	if (operation === "Run" || operation === "Aborting") return nativeSlice(true, program ?? operation, previous, now, now);
-	if (operation === "Pause") return nativeSlice(false, "Pause", previous, now, now);
-	return nativeSlice(false, operation, previous, now, now);
-}
-function runningFromVacuumState(state, previous, now) {
-	if (state === null) return nativeSlice(null, null, previous, now, now);
-	if (state === "cleaning" || state === "returning" || state === "drying") return nativeSlice(true, state, previous, now, now);
-	if (state === "paused") return nativeSlice(false, "paused", previous, now, now);
-	return nativeSlice(false, state, previous, now, now);
-}
-function runningFromLawnMower(activity, previous, now) {
-	if (activity === null) return nativeSlice(null, null, previous, now, now);
-	if (activity === "mowing") return nativeSlice(true, activity, previous, now, now);
-	if (activity === "paused") return nativeSlice(false, "paused", previous, now, now);
-	return nativeSlice(false, activity, previous, now, now);
-}
-function runningFromMediaPlayer(state, previous, now) {
-	if (state === null) return nativeSlice(null, null, previous, now, now);
-	if (state === "playing" || state === "buffering") return nativeSlice(true, state, previous, now, now);
-	if (state === "paused") return nativeSlice(false, "paused", previous, now, now);
-	return nativeSlice(false, state, previous, now, now);
+function runningFromDishwasherOperation(operation, program, previous, fetchedAt, remainingSeconds, transitionAt) {
+	const transitionAtMs = transitionAt ?? fetchedAt;
+	if (operation === null) return nativeSlice(null, null, previous, transitionAtMs, fetchedAt, null);
+	if (operation === "Run" || operation === "Aborting") {
+		const bootstrap = programStartFromRemaining(true, remainingSeconds, fetchedAt);
+		return nativeSlice(true, program ?? operation, previous, transitionAtMs, fetchedAt, bootstrap);
+	}
+	if (operation === "Pause") return nativeSlice(false, "Pause", previous, transitionAtMs, fetchedAt, null);
+	return nativeSlice(false, operation, previous, transitionAtMs, fetchedAt, null);
+}
+function runningFromVacuumState(state, previous, fetchedAt, transitionAt) {
+	const transitionAtMs = transitionAt ?? fetchedAt;
+	if (state === null) return nativeSlice(null, null, previous, transitionAtMs, fetchedAt, null);
+	if (state === "cleaning" || state === "returning" || state === "drying") return nativeSlice(true, state, previous, transitionAtMs, fetchedAt, null);
+	if (state === "paused") return nativeSlice(false, "paused", previous, transitionAtMs, fetchedAt, null);
+	return nativeSlice(false, state, previous, transitionAtMs, fetchedAt, null);
+}
+function runningFromLawnMower(activity, previous, fetchedAt, transitionAt) {
+	const transitionAtMs = transitionAt ?? fetchedAt;
+	if (activity === null) return nativeSlice(null, null, previous, transitionAtMs, fetchedAt, null);
+	if (activity === "mowing") return nativeSlice(true, activity, previous, transitionAtMs, fetchedAt, null);
+	if (activity === "paused") return nativeSlice(false, "paused", previous, transitionAtMs, fetchedAt, null);
+	return nativeSlice(false, activity, previous, transitionAtMs, fetchedAt, null);
+}
+function runningFromMediaPlayer(state, previous, fetchedAt, transitionAt) {
+	const transitionAtMs = transitionAt ?? fetchedAt;
+	if (state === null) return nativeSlice(null, null, previous, transitionAtMs, fetchedAt, null);
+	if (state === "playing" || state === "buffering") return nativeSlice(true, state, previous, transitionAtMs, fetchedAt, null);
+	if (state === "paused") return nativeSlice(false, "paused", previous, transitionAtMs, fetchedAt, null);
+	return nativeSlice(false, state, previous, transitionAtMs, fetchedAt, null);
 }
 //#endregion
 //#region src/clips/clip-event-labels.ts
@@ -76950,74 +77128,6 @@ function feederCustomizationExample(sources) {
 	});
 }
 //#endregion
-//#region src/composition/presets/doorbell-feature.ts
-/**
-* The doorbell of a camera as a customization (D671). ONE builder: the admin
-* UI's Customize → Doorbell card writes every doorbell feature through it, and
-* edits one only when it is exactly what this builds (`isDoorbellPresetFeature`)
-* — a composed doorbell has one canonical shape.
-*/
-/** A rise closer than this to the previous one is the same press (D671). */
-var DOORBELL_RISE_DEBOUNCE_MS = 2e3;
-/** Every source cap of `source` that `SOURCE_CAP_ACTIVE_FIELD` knows AND the device has bound. */
-function doorbellFeatureSources(source, boundCaps) {
-	return Object.keys(require_composition.SOURCE_CAP_ACTIVE_FIELD).filter((cap) => Object.hasOwn(require_composition.SOURCE_CAP_CHANGED_AT_FIELD, cap) && boundCaps.includes(cap)).toSorted().flatMap((cap) => {
-		const activeField = require_composition.SOURCE_CAP_ACTIVE_FIELD[cap];
-		const changedAtField = require_composition.SOURCE_CAP_CHANGED_AT_FIELD[cap];
-		return activeField === void 0 || changedAtField === void 0 ? [] : [{
-			source,
-			cap,
-			activeField,
-			changedAtField
-		}];
-	});
-}
-/** The canonical D671 doorbell feature. Throws on zero sources. */
-function buildDoorbellCompositionFeature(input) {
-	const sources = [...input.sources].toSorted((a, b) => `${a.source.addonId}/${a.source.stableId}#${a.cap}`.localeCompare(`${b.source.addonId}/${b.source.stableId}#${b.cap}`));
-	if (sources.length === 0) throw new Error("doorbell composition needs at least one source");
-	const edgeBindings = {};
-	sources.forEach((entry, index) => {
-		edgeBindings[`active${index}`] = {
-			kind: "from",
-			source: entry.source,
-			cap: entry.cap,
-			fieldPath: entry.activeField
-		};
-		edgeBindings[`changed${index}`] = {
-			kind: "from",
-			source: entry.source,
-			cap: entry.cap,
-			fieldPath: entry.changedAtField
-		};
-	});
-	return {
-		kind: "fields",
-		cap: "doorbell",
-		enabled: input.enabled,
-		fields: {
-			lastPressedAt: {
-				kind: "expression",
-				expr: `latest(${sources.map((_, index) => `rose(active${index}, changed${index}, ${DOORBELL_RISE_DEBOUNCE_MS})`).join(", ")})`,
-				bindings: edgeBindings
-			},
-			pressCountSinceStart: {
-				kind: "expression",
-				expr: "count(lastPressedAt)",
-				bindings: { lastPressedAt: {
-					kind: "from",
-					source: {
-						addonId: input.camera.addonId,
-						stableId: input.camera.stableId
-					},
-					cap: "doorbell",
-					fieldPath: "lastPressedAt"
-				} }
-			}
-		}
-	};
-}
-//#endregion
 //#region src/composition/presets/numeric-transforms.ts
 /**
 * Self-only invert / unit-convert composition features (D663). The Numeric
@@ -100291,6 +100401,1862 @@ function historyFieldsFor(capName) {
 	return HISTORY_CATALOG[capName] ?? {};
 }
 //#endregion
+//#region src/generated/customize-catalog.ts
+/**
+* Customize catalog, projected from every `*.cap.ts` `customize` block.
+* 5 caps. Field keys are `runtimeState` paths. No Zod.
+*/
+var CAP_CUSTOMIZE_CATALOG = {
+	"battery": {
+		version: 1,
+		targets: [{
+			id: "percentage",
+			cardinality: "scalar",
+			deviceTypes: [
+				require_err_msg.DeviceType.Camera,
+				require_err_msg.DeviceType.Sensor,
+				require_err_msg.DeviceType.Button,
+				require_err_msg.DeviceType.Switch,
+				require_err_msg.DeviceType.PetFeeder,
+				require_err_msg.DeviceType.Container,
+				require_err_msg.DeviceType.Thermostat
+			],
+			apply: "add-or-replace",
+			vocabularyCap: "battery",
+			vocabularyStateField: "percentage",
+			sources: [{
+				kind: "field",
+				valueKinds: ["number", "string"],
+				transformKinds: ["identity", "linear"]
+			}],
+			sourceReport: { status: "assignment-status" },
+			advancedExpression: true,
+			path: "percentage",
+			valueKind: "number",
+			nullable: true,
+			companions: [
+				{
+					kind: "constant",
+					path: "charging",
+					value: "unknown",
+					when: "add"
+				},
+				{
+					kind: "constant",
+					path: "sleeping",
+					value: false,
+					when: "add"
+				},
+				{
+					kind: "clock",
+					path: "lastUpdated",
+					when: "add"
+				}
+			]
+		}]
+	},
+	"consumables": {
+		version: 1,
+		targets: [{
+			id: "items",
+			cardinality: "keyedArray",
+			deviceTypes: [
+				require_err_msg.DeviceType.Camera,
+				require_err_msg.DeviceType.Hub,
+				require_err_msg.DeviceType.Light,
+				require_err_msg.DeviceType.Siren,
+				require_err_msg.DeviceType.Switch,
+				require_err_msg.DeviceType.Sensor,
+				require_err_msg.DeviceType.Thermostat,
+				require_err_msg.DeviceType.Climate,
+				require_err_msg.DeviceType.Button,
+				require_err_msg.DeviceType.EventEmitter,
+				require_err_msg.DeviceType.Update,
+				require_err_msg.DeviceType.Generic,
+				require_err_msg.DeviceType.Notifier,
+				require_err_msg.DeviceType.Script,
+				require_err_msg.DeviceType.Automation,
+				require_err_msg.DeviceType.Lock,
+				require_err_msg.DeviceType.Cover,
+				require_err_msg.DeviceType.Valve,
+				require_err_msg.DeviceType.Humidifier,
+				require_err_msg.DeviceType.WaterHeater,
+				require_err_msg.DeviceType.Fan,
+				require_err_msg.DeviceType.MediaPlayer,
+				require_err_msg.DeviceType.AlarmPanel,
+				require_err_msg.DeviceType.Control,
+				require_err_msg.DeviceType.Presence,
+				require_err_msg.DeviceType.Weather,
+				require_err_msg.DeviceType.Vacuum,
+				require_err_msg.DeviceType.LawnMower,
+				require_err_msg.DeviceType.Container,
+				require_err_msg.DeviceType.Image,
+				require_err_msg.DeviceType.PetFeeder,
+				require_err_msg.DeviceType.Dishwasher
+			],
+			apply: "add",
+			vocabularyCap: "consumables",
+			sources: [],
+			sourceReport: { status: "assignment-status" },
+			advancedExpression: true,
+			path: "items",
+			keyField: "key",
+			labelField: "label",
+			nativeItems: "read-only",
+			fields: [
+				{
+					path: "level",
+					valueKind: "number",
+					nullable: true,
+					sources: [{
+						kind: "numeric",
+						transformKinds: ["identity", "linear"]
+					}]
+				},
+				{
+					path: "remaining.value",
+					valueKind: "number",
+					nullable: true,
+					sources: [{
+						kind: "numeric",
+						transformKinds: ["identity"]
+					}],
+					literals: [{
+						path: "remaining.unit",
+						values: [
+							"days",
+							"hours",
+							"cycles"
+						]
+					}]
+				},
+				{
+					path: "status",
+					valueKind: "enum",
+					nullable: true,
+					enumValues: [
+						"ok",
+						"low",
+						"empty",
+						"full",
+						"replace"
+					],
+					sources: [{
+						kind: "enum",
+						transformKinds: ["enum-map"]
+					}]
+				}
+			],
+			traits: [{
+				path: "kind",
+				values: [
+					"wear",
+					"supply",
+					"waste"
+				],
+				defaultValue: "wear"
+			}, {
+				path: "form",
+				values: [
+					"part",
+					"tank",
+					"product",
+					"bin"
+				],
+				defaultValue: "part"
+			}],
+			companions: [{
+				kind: "clock",
+				path: "lastChangedAt",
+				when: "add"
+			}, {
+				kind: "clock",
+				path: "lastFetchedAt",
+				when: "add"
+			}]
+		}]
+	},
+	"doorbell": {
+		version: 1,
+		targets: [{
+			id: "pressed",
+			cardinality: "event",
+			deviceTypes: [require_err_msg.DeviceType.Camera],
+			apply: "add",
+			vocabularyCap: "doorbell",
+			vocabularyEvent: "onPressed",
+			sources: [{
+				kind: "binary",
+				transformKinds: []
+			}, {
+				kind: "switch",
+				transformKinds: []
+			}],
+			sourceReport: { status: "assignment-status" },
+			advancedExpression: true,
+			shape: "pulse",
+			applyAuthority: { kind: "composition-claim" },
+			eventName: "onPressed",
+			combine: "any",
+			edges: ["rising"],
+			timestampPath: "lastPressedAt",
+			counterPath: "pressCountSinceStart",
+			highWater: "composer-advance",
+			debounceMs: 2e3
+		}]
+	},
+	"motion": {
+		version: 1,
+		targets: [{
+			id: "detected",
+			cardinality: "event",
+			deviceTypes: [require_err_msg.DeviceType.Camera],
+			apply: "replace",
+			vocabularyCap: "motion",
+			vocabularyEvent: "onMotionChanged",
+			sources: [{
+				kind: "binary",
+				transformKinds: []
+			}, {
+				kind: "switch",
+				transformKinds: []
+			}],
+			sourceReport: { status: "assignment-status" },
+			advancedExpression: false,
+			shape: "span",
+			applyAuthority: {
+				kind: "camera-sensors",
+				timeoutField: "motionCooldownMs"
+			},
+			eventName: "onMotionChanged",
+			combine: "any",
+			start: "rising-edge",
+			end: "falling-edge-or-timeout",
+			timeoutMs: 3e4,
+			sourceModes: [
+				"in-addition",
+				"confirm",
+				"replace"
+			]
+		}]
+	},
+	"running-state": {
+		version: 1,
+		targets: [{
+			id: "running",
+			cardinality: "scalar",
+			deviceTypes: [
+				require_err_msg.DeviceType.Dishwasher,
+				require_err_msg.DeviceType.Vacuum,
+				require_err_msg.DeviceType.LawnMower,
+				require_err_msg.DeviceType.MediaPlayer,
+				require_err_msg.DeviceType.WaterHeater,
+				require_err_msg.DeviceType.Humidifier,
+				require_err_msg.DeviceType.Fan,
+				require_err_msg.DeviceType.Climate,
+				require_err_msg.DeviceType.Thermostat,
+				require_err_msg.DeviceType.PetFeeder
+			],
+			apply: "add-or-replace",
+			vocabularyCap: "running-state",
+			vocabularyStateField: "running",
+			sources: [
+				{
+					kind: "switch",
+					transformKinds: ["identity"]
+				},
+				{
+					kind: "binary",
+					transformKinds: ["identity", "invert"]
+				},
+				{
+					kind: "numeric",
+					requiredUnit: "W",
+					transformKinds: ["threshold"]
+				}
+			],
+			sourceReport: {
+				status: "assignment-status",
+				runtimeField: "source",
+				nativeValue: "native",
+				assignedValue: "assigned"
+			},
+			advancedExpression: true,
+			path: "running",
+			valueKind: "boolean",
+			nullable: true,
+			companions: [
+				{
+					kind: "constant",
+					path: "source",
+					value: "assigned",
+					when: "always"
+				},
+				{
+					kind: "constant",
+					path: "phase",
+					value: null,
+					when: "always"
+				},
+				{
+					kind: "clock",
+					path: "lastFetchedAt",
+					when: "always"
+				},
+				{
+					kind: "transition-time",
+					path: "since",
+					sourceChangedAt: "prefer"
+				}
+			]
+		}]
+	}
+};
+//#endregion
+//#region src/composition/customize/override-draft.ts
+/**
+* A saved Customize assignment (D936). The schema is the type: callers use
+* `z.infer`, they do not restate the shape.
+*/
+var OverrideSourceSchema = zod.z.object({
+	addonId: zod.z.string().min(1),
+	stableId: zod.z.string().min(1),
+	cap: zod.z.string().min(1),
+	fieldPath: zod.z.string().min(1)
+});
+var IdentityTransformDraftSchema = zod.z.object({ kind: zod.z.literal("identity") });
+var InvertTransformDraftSchema = zod.z.object({ kind: zod.z.literal("invert") });
+var ThresholdTransformDraftSchema = zod.z.object({
+	kind: zod.z.literal("threshold"),
+	comparison: zod.z.enum(["gte", "lte"]),
+	threshold: zod.z.number(),
+	startDwellMs: zod.z.number().nonnegative(),
+	stopDwellMs: zod.z.number().nonnegative()
+});
+var LinearTransformDraftSchema = zod.z.object({
+	kind: zod.z.literal("linear"),
+	scale: zod.z.number(),
+	offset: zod.z.number(),
+	clampMin: zod.z.number().optional(),
+	clampMax: zod.z.number().optional()
+});
+var EnumMapTransformDraftSchema = zod.z.object({
+	kind: zod.z.literal("enum-map"),
+	mapping: zod.z.record(zod.z.string(), zod.z.string().nullable())
+});
+var NumberBridgeTransformDraftSchema = zod.z.object({ kind: zod.z.literal("number") });
+var CustomizeTransformDraftSchema = zod.z.discriminatedUnion("kind", [
+	IdentityTransformDraftSchema,
+	InvertTransformDraftSchema,
+	ThresholdTransformDraftSchema,
+	LinearTransformDraftSchema,
+	EnumMapTransformDraftSchema,
+	NumberBridgeTransformDraftSchema
+]);
+var ScalarOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("scalar"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var KeyedArrayOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("keyedArray"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	key: zod.z.string().min(1),
+	label: zod.z.string().min(1),
+	fieldPath: zod.z.string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var PulseOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("pulse"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	enabled: zod.z.boolean(),
+	debounceMs: zod.z.number().nonnegative(),
+	sources: zod.z.array(OverrideSourceSchema).min(1)
+});
+var SpanSourceDraftSchema = OverrideSourceSchema.extend({ mode: zod.z.enum([
+	"in-addition",
+	"confirm",
+	"replace"
+]).optional() });
+var SpanOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("span"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	timeoutMs: zod.z.number().nonnegative(),
+	cooldownMs: zod.z.number().nonnegative().optional(),
+	sources: zod.z.array(SpanSourceDraftSchema)
+});
+var OverrideDraftSchema = zod.z.discriminatedUnion("kind", [
+	ScalarOverrideDraftSchema,
+	KeyedArrayOverrideDraftSchema,
+	PulseOverrideDraftSchema,
+	SpanOverrideDraftSchema
+]);
+/** Effective authority for one declared target. Not a second stored switch. */
+var CustomizeAssignmentStatusSchema = zod.z.object({
+	targetId: zod.z.string().min(1),
+	configured: zod.z.boolean(),
+	source: zod.z.enum(["native", "assigned"]),
+	state: zod.z.enum([
+		"active",
+		"stale",
+		"released",
+		"unavailable"
+	]),
+	reason: zod.z.string().nullable()
+});
+//#endregion
+//#region src/composition/customize/field-source.ts
+function fromRead(source, cap, fieldPath) {
+	return {
+		kind: "from",
+		source,
+		cap,
+		fieldPath
+	};
+}
+function expression(expr, bindings) {
+	return {
+		kind: "expression",
+		expr,
+		bindings
+	};
+}
+function literal(expr) {
+	return expression(expr, {});
+}
+function isLiteral(source, expr) {
+	return source?.kind === "expression" && source.expr === expr && Object.keys(source.bindings).length === 0;
+}
+//#endregion
+//#region src/composition/customize/scalar-expr.ts
+var UNSIGNED = /^\d+(?:\.\d+)?$/;
+var SIGNED = /^-?\d+(?:\.\d+)?$/;
+var DWELL = /^dwell\(x (>=|<=) (\d+(?:\.\d+)?), (\d+(?:\.\d+)?), (\d+(?:\.\d+)?)\)$/;
+var LINEAR_CLAMP = /^clamp\((x|number\(x\)) \* (-?\d+(?:\.\d+)?) \+ (-?\d+(?:\.\d+)?), (-?\d+(?:\.\d+)?), (-?\d+(?:\.\d+)?)\)$/;
+var LINEAR_BARE = /^(x|number\(x\)) \* (-?\d+(?:\.\d+)?) \+ (-?\d+(?:\.\d+)?)$/;
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function unsignedToken(value) {
+	return token(value, UNSIGNED);
+}
+function signedToken(value) {
+	return token(value, SIGNED);
+}
+function constantExpr(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number") return signedToken(value);
+	if (typeof value === "boolean") return value ? "true" : "false";
+	return "null";
+}
+function isIdentifier(path) {
+	return IDENT.test(path);
+}
+function dwellExpr(comparison, threshold, start, stop) {
+	return `dwell(x ${comparison === "gte" ? ">=" : "<="} ${threshold}, ${start}, ${stop})`;
+}
+function linearExpr(inner, scale, offset, clampMin, clampMax) {
+	const arithmetic = `${inner} * ${scale} + ${offset}`;
+	if (clampMin === null || clampMax === null) return arithmetic;
+	return `clamp(${arithmetic}, ${clampMin}, ${clampMax})`;
+}
+function parseDwell(expr) {
+	const match = DWELL.exec(expr);
+	if (match === null) return null;
+	const threshold = Number(match[2]);
+	const startDwellMs = Number(match[3]);
+	const stopDwellMs = Number(match[4]);
+	if (!Number.isFinite(threshold) || !Number.isFinite(startDwellMs) || !Number.isFinite(stopDwellMs)) return null;
+	return {
+		comparison: match[1] === "<=" ? "lte" : "gte",
+		threshold,
+		startDwellMs,
+		stopDwellMs
+	};
+}
+function parseLinear(expr) {
+	const clamped = LINEAR_CLAMP.exec(expr);
+	if (clamped !== null) return linearFrom(clamped[1], clamped[2], clamped[3], clamped[4], clamped[5]);
+	const bare = LINEAR_BARE.exec(expr);
+	if (bare === null) return null;
+	return linearFrom(bare[1], bare[2], bare[3], void 0, void 0);
+}
+function singleFrom(source) {
+	if (source.kind === "from") return {
+		cap: source.cap,
+		fieldPath: source.fieldPath,
+		addonId: source.source.addonId,
+		stableId: source.source.stableId
+	};
+	if (source.kind !== "expression" || Object.keys(source.bindings).length !== 1) return null;
+	const bound = source.bindings["x"];
+	if (bound === void 0 || bound.kind !== "from") return null;
+	return {
+		cap: bound.cap,
+		fieldPath: bound.fieldPath,
+		addonId: bound.source.addonId,
+		stableId: bound.source.stableId
+	};
+}
+function token(value, pattern) {
+	if (!Number.isFinite(value)) return null;
+	const text = Object.is(value, -0) ? "0" : String(value);
+	return pattern.test(text) ? text : null;
+}
+function linearFrom(inner, scale, offset, clampMin, clampMax) {
+	if (inner !== "x" && inner !== "number(x)") return null;
+	if (scale === void 0 || offset === void 0) return null;
+	const parsedScale = Number(scale);
+	const parsedOffset = Number(offset);
+	if (!Number.isFinite(parsedScale) || !Number.isFinite(parsedOffset)) return null;
+	if (clampMin === void 0 || clampMax === void 0) return {
+		inner,
+		scale: parsedScale,
+		offset: parsedOffset
+	};
+	const parsedMin = Number(clampMin);
+	const parsedMax = Number(clampMax);
+	if (!Number.isFinite(parsedMin) || !Number.isFinite(parsedMax)) return null;
+	return {
+		inner,
+		scale: parsedScale,
+		offset: parsedOffset,
+		clampMin: parsedMin,
+		clampMax: parsedMax
+	};
+}
+//#endregion
+//#region src/composition/customize/scalar-compile.ts
+var catalog$4 = CAP_CUSTOMIZE_CATALOG;
+function compileScalarOverride(input) {
+	const target = catalogTarget$4(input.draft.cap, input.draft.targetId);
+	if (target === null || target.cardinality !== "scalar" || target.path === void 0) return fail$2("target");
+	if (input.draft.transform.kind === "enum-map") return fail$2("enum");
+	const source = sourceSpec$1(target, input.sourceValueKind, input.draft.source.cap);
+	if (source === null) return fail$2("source-kind");
+	if (source.requiredUnit !== void 0 && input.sourceUnit !== source.requiredUnit) return fail$2("unit");
+	const allowed = input.draft.transform.kind === "number" ? "identity" : input.draft.transform.kind;
+	if (!source.transformKinds.includes(allowed)) return fail$2("transform");
+	const value = compileValue$1(input);
+	if (!value.ok) return value;
+	const fields = compileCompanions$1(input, target, value.value);
+	if (!fields.ok) return fields;
+	return {
+		ok: true,
+		value: {
+			kind: "fields",
+			cap: input.draft.cap,
+			fields: fields.value
+		}
+	};
+}
+function fail$2(reason) {
+	return {
+		ok: false,
+		reason
+	};
+}
+function catalogTarget$4(cap, targetId) {
+	const entry = catalog$4[cap];
+	if (entry === void 0) return null;
+	return entry.targets.find((target) => target.id === targetId) ?? null;
+}
+function sourceSpec$1(target, valueKind, sourceCap) {
+	if (valueKind === "boolean" && sourceCap === "switch") return target.sources.find((source) => source.kind === "switch") ?? null;
+	if (valueKind === "boolean") return target.sources.find((source) => source.kind === "binary") ?? fieldSource(target, "boolean");
+	if (valueKind === "number") return target.sources.find((source) => source.kind === "numeric") ?? fieldSource(target, "number");
+	return fieldSource(target, "string");
+}
+function fieldSource(target, valueKind) {
+	return target.sources.find((source) => source.kind === "field" && (source.valueKinds ?? []).includes(valueKind)) ?? null;
+}
+function compileValue$1(input) {
+	const read = fromRead(refOf$1(input.draft), input.draft.source.cap, input.draft.source.fieldPath);
+	const transform = input.draft.transform;
+	if (transform.kind === "identity" || transform.kind === "number") return {
+		ok: true,
+		value: identityValue(read, input.sourceValueKind)
+	};
+	if (transform.kind === "invert") {
+		if (input.sourceValueKind !== "boolean") return fail$2("source-kind");
+		return {
+			ok: true,
+			value: expression("!x", { x: read })
+		};
+	}
+	if (transform.kind === "threshold") return thresholdValue(transform, read);
+	if (transform.kind === "linear") return linearValue$1(transform, read, input.sourceValueKind);
+	return fail$2("transform");
+}
+function identityValue(read, valueKind) {
+	if (valueKind === "string") return expression("number(x)", { x: read });
+	return read;
+}
+function thresholdValue(transform, read) {
+	const threshold = unsignedToken(transform.threshold);
+	if (threshold === null) return fail$2("threshold");
+	const start = unsignedToken(transform.startDwellMs);
+	const stop = unsignedToken(transform.stopDwellMs);
+	if (start === null || stop === null) return fail$2("dwell");
+	return {
+		ok: true,
+		value: expression(dwellExpr(transform.comparison, threshold, start, stop), { x: read })
+	};
+}
+function linearValue$1(transform, read, valueKind) {
+	const scale = signedToken(transform.scale);
+	const offset = signedToken(transform.offset);
+	if (scale === null || offset === null) return fail$2("scale");
+	const clamps = clampTokens$1(transform.clampMin, transform.clampMax);
+	if (!clamps.ok) return clamps;
+	return {
+		ok: true,
+		value: expression(linearExpr(valueKind === "string" ? "number(x)" : "x", scale, offset, clamps.value.min, clamps.value.max), { x: read })
+	};
+}
+function clampTokens$1(clampMin, clampMax) {
+	if (clampMin === void 0 && clampMax === void 0) return {
+		ok: true,
+		value: {
+			min: null,
+			max: null
+		}
+	};
+	if (clampMin === void 0 || clampMax === void 0) return fail$2("clamp");
+	const min = signedToken(clampMin);
+	const max = signedToken(clampMax);
+	if (min === null || max === null || clampMin > clampMax) return fail$2("clamp");
+	return {
+		ok: true,
+		value: {
+			min,
+			max
+		}
+	};
+}
+function compileCompanions$1(input, target, value) {
+	if (target.path === void 0) return fail$2("target");
+	const path = target.path;
+	return (target.companions ?? []).filter((companion) => companionIncluded$1(companion, input.apply)).reduce((acc, companion) => {
+		if (!acc.ok) return acc;
+		const built = companionField(input, path, companion);
+		if (!built.ok) return {
+			ok: false,
+			reason: built.reason
+		};
+		return {
+			ok: true,
+			value: {
+				...acc.value,
+				[companion.path]: built.value
+			}
+		};
+	}, {
+		ok: true,
+		value: { [path]: value }
+	});
+}
+function companionIncluded$1(companion, apply) {
+	if (companion.kind === "transition-time") return true;
+	return companion.when === "always" || apply === "add";
+}
+function companionField(input, path, companion) {
+	if (companion.kind === "constant") {
+		const expr = constantExpr(companion.value);
+		if (expr === null) return fail$2("scale");
+		return {
+			ok: true,
+			value: literal(expr)
+		};
+	}
+	if (companion.kind === "clock") return {
+		ok: true,
+		value: literal("now")
+	};
+	return transitionField(input, path, companion.sourceChangedAt);
+}
+function transitionField(input, path, sourceChangedAt) {
+	if (sourceChangedAt === "prefer" && input.sourceValueKind === "boolean" && input.changedAtField !== null && isIdentifier(input.changedAtField)) return {
+		ok: true,
+		value: fromRead(refOf$1(input.draft), input.draft.source.cap, input.changedAtField)
+	};
+	if (!isIdentifier(path)) return fail$2("transform");
+	const bindings = { [path]: fromRead(input.device, input.draft.cap, path) };
+	return {
+		ok: true,
+		value: expression(`latchedAt(${path})`, bindings)
+	};
+}
+function refOf$1(draft) {
+	return {
+		addonId: draft.source.addonId,
+		stableId: draft.source.stableId
+	};
+}
+//#endregion
+//#region src/composition/customize/normalize.ts
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, inner]) => [key, sortKeys(inner)]));
+}
+/** Key order is not part of the stored contract. Array order is. */
+function normalizeStored(stored) {
+	return sortKeys(stored);
+}
+function sameStored(a, b) {
+	return JSON.stringify(normalizeStored(a)) === JSON.stringify(normalizeStored(b));
+}
+//#endregion
+//#region src/composition/customize/scalar-decode.ts
+var catalog$3 = CAP_CUSTOMIZE_CATALOG;
+function decodeScalarOverride(input) {
+	const target = catalogTarget$3(input.cap, input.targetId);
+	if (target === null || target.cardinality !== "scalar" || target.path === void 0) return null;
+	if (input.feature.cap !== input.cap || input.feature.kind !== "fields") return null;
+	const outputKind = scalarOutputKind(target.valueKind);
+	if (outputKind === null) return null;
+	const value = input.feature.fields[target.path];
+	const read = readValue(value, outputKind, input.cap, input.targetId);
+	if (read === null) return null;
+	const apply = inferApply$1(target, input.feature.fields);
+	if (apply === null) return null;
+	const changedAtField = inferChangedAt(target, input.feature.fields, read);
+	const sourceUnit = unitFor(target, read.sourceValueKind, read.draft.source.cap);
+	const decoded = {
+		...read,
+		apply,
+		changedAtField,
+		sourceUnit
+	};
+	return reproduces$1(decoded, input.device, input.feature) ? decoded : null;
+}
+function catalogTarget$3(cap, targetId) {
+	const entry = catalog$3[cap];
+	if (entry === void 0) return null;
+	return entry.targets.find((target) => target.id === targetId) ?? null;
+}
+function scalarOutputKind(valueKind) {
+	if (valueKind === "boolean" || valueKind === "number" || valueKind === "string") return valueKind;
+	return null;
+}
+function readValue(field, outputKind, cap, targetId) {
+	if (field === void 0) return null;
+	if (field.kind === "from") return drafted(field, { kind: "identity" }, outputKind, cap, targetId);
+	if (field.kind !== "expression") return null;
+	if (field.expr === "number(x)" && outputKind === "number") return drafted(field, { kind: "identity" }, "string", cap, targetId);
+	if (field.expr === "!x" && outputKind === "boolean") return drafted(field, { kind: "invert" }, "boolean", cap, targetId);
+	const dwell = parseDwell(field.expr);
+	if (dwell !== null) return drafted(field, {
+		kind: "threshold",
+		comparison: dwell.comparison,
+		threshold: dwell.threshold,
+		startDwellMs: dwell.startDwellMs,
+		stopDwellMs: dwell.stopDwellMs
+	}, "number", cap, targetId);
+	const linear = parseLinear(field.expr);
+	if (linear === null || outputKind !== "number") return null;
+	return drafted(field, {
+		kind: "linear",
+		scale: linear.scale,
+		offset: linear.offset,
+		...linear.clampMin === void 0 || linear.clampMax === void 0 ? {} : {
+			clampMin: linear.clampMin,
+			clampMax: linear.clampMax
+		}
+	}, linear.inner === "number(x)" ? "string" : "number", cap, targetId);
+}
+function drafted(field, transform, sourceValueKind, cap, targetId) {
+	const bound = singleFrom(field);
+	if (bound === null) return null;
+	return {
+		sourceValueKind,
+		draft: {
+			kind: "scalar",
+			cap,
+			targetId,
+			source: {
+				addonId: bound.addonId,
+				stableId: bound.stableId,
+				cap: bound.cap,
+				fieldPath: bound.fieldPath
+			},
+			transform
+		}
+	};
+}
+function inferApply$1(target, fields) {
+	const addPaths = (target.companions ?? []).flatMap((companion) => companion.kind !== "transition-time" && companion.when === "add" ? [companion.path] : []);
+	if (addPaths.length === 0) return "replace";
+	const present = addPaths.filter((path) => fields[path] !== void 0);
+	if (present.length === addPaths.length) return "add";
+	if (present.length === 0) return "replace";
+	return null;
+}
+function inferChangedAt(target, fields, read) {
+	if (read.sourceValueKind !== "boolean") return null;
+	const transition = (target.companions ?? []).find((companion) => companion.kind === "transition-time");
+	if (transition === void 0 || transition.sourceChangedAt !== "prefer") return null;
+	const since = fields[transition.path];
+	if (since?.kind !== "from") return null;
+	if (since.cap !== read.draft.source.cap) return null;
+	if (since.source.addonId !== read.draft.source.addonId || since.source.stableId !== read.draft.source.stableId) return null;
+	return since.fieldPath;
+}
+function unitFor(target, valueKind, sourceCap) {
+	if (valueKind === "boolean" && sourceCap === "switch") return null;
+	if (valueKind === "number") return target.sources.find((source) => source.kind === "numeric")?.requiredUnit ?? null;
+	return null;
+}
+function reproduces$1(decoded, device, stored) {
+	const compiled = compileScalarOverride({
+		draft: decoded.draft,
+		device,
+		apply: decoded.apply,
+		sourceValueKind: decoded.sourceValueKind,
+		changedAtField: decoded.changedAtField,
+		sourceUnit: decoded.sourceUnit
+	});
+	if (!compiled.ok) return false;
+	return sameFeature$2(compiled.value, stored);
+}
+function sameFeature$2(compiled, stored) {
+	return sameStored(wrap$2(withoutEnabled(compiled)), wrap$2(withoutEnabled(stored)));
+}
+function withoutEnabled(feature) {
+	const { enabled: _enabled, ...rest } = feature;
+	return rest;
+}
+function wrap$2(feature) {
+	return {
+		family: "composition",
+		target: {
+			addonId: "t",
+			stableId: "t"
+		},
+		feature
+	};
+}
+//#endregion
+//#region src/composition/customize/scalar-status.ts
+function projectScalarAssignment(input) {
+	if (input.stored.kind === "pending") return unanswered$1(input.targetId, "pending", null);
+	if (input.stored.kind === "unknown") return unanswered$1(input.targetId, "unknown", input.stored.reason ?? "unknown");
+	if (input.stored.value === null) return native$2(input.targetId);
+	const decoded = decodeScalarOverride({
+		feature: input.stored.value,
+		device: input.device,
+		cap: input.cap,
+		targetId: input.targetId
+	});
+	if (decoded === null) return {
+		text: "unknown",
+		status: status$1(input.targetId, true, "assigned", "unavailable", "not-canonical")
+	};
+	return projectDecoded$1(input, decoded.apply, sourceLabel(decoded.draft.source.cap, decoded.draft.source.fieldPath));
+}
+function projectDecoded$1(input, apply, label) {
+	if (input.sourcePresence === "pending") return {
+		text: "pending",
+		status: status$1(input.targetId, true, "assigned", "stale", null)
+	};
+	if (input.sourcePresence === "unknown") return {
+		text: "unknown",
+		status: status$1(input.targetId, true, "assigned", "stale", input.sourceUnknownReason ?? "unknown")
+	};
+	if (input.sourcePresence === "absent" && apply === "replace") return {
+		text: "Native · source missing",
+		status: status$1(input.targetId, true, "native", "released", "source-missing")
+	};
+	if (input.sourcePresence === "absent") return {
+		text: `Assigned · ${label}`,
+		status: status$1(input.targetId, true, "assigned", "unavailable", "source-missing")
+	};
+	return {
+		text: `Assigned · ${label}`,
+		status: status$1(input.targetId, true, "assigned", "active", null)
+	};
+}
+function native$2(targetId) {
+	return {
+		text: "Native",
+		status: status$1(targetId, false, "native", "active", null)
+	};
+}
+function unanswered$1(targetId, text, reason) {
+	return {
+		text,
+		status: status$1(targetId, false, "native", text === "pending" ? "unavailable" : "stale", reason)
+	};
+}
+function sourceLabel(cap, fieldPath) {
+	return `${cap}.${fieldPath}`;
+}
+function status$1(targetId, configured, source, state, reason) {
+	return {
+		targetId,
+		configured,
+		source,
+		state,
+		reason
+	};
+}
+//#endregion
+//#region src/composition/customize/event-compile.ts
+var catalog$2 = CAP_CUSTOMIZE_CATALOG;
+function compilePulseOverride(input) {
+	const target = catalogTarget$2(input.draft.cap, input.draft.targetId);
+	if (target === null || target.shape !== "pulse") return fail$1("target");
+	const timestampPath = target.timestampPath;
+	const counterPath = target.counterPath;
+	if (timestampPath === void 0 || counterPath === void 0 || !isIdentifier(timestampPath) || !isIdentifier(counterPath)) return fail$1("path");
+	if (!(target.edges ?? []).includes("rising")) return fail$1("edge");
+	const pairs = pairSources(input);
+	if (!pairs.ok) return pairs;
+	if (pairs.value.length === 0) return fail$1("sources");
+	const debounce = unsignedToken(input.draft.debounceMs);
+	if (debounce === null) return fail$1("debounce");
+	const ordered = pairs.value.toSorted((a, b) => pairKey(a).localeCompare(pairKey(b)));
+	return {
+		ok: true,
+		value: {
+			kind: "fields",
+			cap: input.draft.cap,
+			enabled: input.draft.enabled,
+			fields: {
+				[timestampPath]: expression(pulseExpr(ordered.length, debounce), pulseBindings(ordered)),
+				[counterPath]: expression(`count(${timestampPath})`, { [timestampPath]: fromRead(input.device, input.draft.cap, timestampPath) })
+			}
+		}
+	};
+}
+function compileSpanOverride(input) {
+	const target = catalogTarget$2(input.draft.cap, input.draft.targetId);
+	if (target === null || target.shape !== "span") return fail$1("target");
+	if (target.applyAuthority?.kind !== "camera-sensors") return fail$1("authority");
+	if (input.draft.timeoutMs < 0 || !Number.isFinite(input.draft.timeoutMs)) return fail$1("timeout");
+	if (target.cooldownMs === void 0 && input.draft.cooldownMs !== void 0) return fail$1("cooldown");
+	if (input.draft.cooldownMs !== void 0 && input.draft.cooldownMs < 0) return fail$1("cooldown");
+	const sensors = sensorEntries(input.draft.sources, input.device, target.sourceModes);
+	if (!sensors.ok) return sensors;
+	if (sensors.value.length === 0) return {
+		ok: true,
+		value: {
+			config: null,
+			timeoutMs: input.draft.timeoutMs,
+			cooldownMs: input.draft.cooldownMs
+		}
+	};
+	const parsed = CameraSensorsConfigSchema.safeParse({ sensors: sensors.value });
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		return fail$1(issue === void 0 ? "cameraSensors" : issue.message);
+	}
+	return {
+		ok: true,
+		value: {
+			config: parsed.data,
+			timeoutMs: input.draft.timeoutMs,
+			cooldownMs: input.draft.cooldownMs
+		}
+	};
+}
+function pairSources(input) {
+	if (input.changedAtFields.length !== input.draft.sources.length) return fail$1("changed-at");
+	const pairs = input.draft.sources.map((source, index) => {
+		return {
+			source,
+			changedAtField: input.changedAtFields[index] ?? ""
+		};
+	});
+	if (pairs.some((pair) => pair.changedAtField.length === 0 || pair.source.fieldPath.length === 0)) return fail$1("changed-at");
+	return {
+		ok: true,
+		value: pairs
+	};
+}
+function pairKey(pair) {
+	return `${pair.source.addonId}/${pair.source.stableId}#${pair.source.cap}#${pair.source.fieldPath}`;
+}
+function pulseExpr(count, debounce) {
+	const roses = [];
+	for (let index = 0; index < count; index += 1) roses.push(`rose(active${index}, changed${index}, ${debounce})`);
+	return `latest(${roses.join(", ")})`;
+}
+function pulseBindings(pairs) {
+	const bindings = {};
+	pairs.forEach((pair, index) => {
+		const ref = {
+			addonId: pair.source.addonId,
+			stableId: pair.source.stableId
+		};
+		bindings[`active${index}`] = fromRead(ref, pair.source.cap, pair.source.fieldPath);
+		bindings[`changed${index}`] = fromRead(ref, pair.source.cap, pair.changedAtField);
+	});
+	return bindings;
+}
+function sensorEntries(sources, device, modes) {
+	const entries = [];
+	for (const source of sources) {
+		if (source.addonId === device.addonId && source.stableId === device.stableId) return fail$1("self");
+		const mode = source.mode ?? "in-addition";
+		if (modes !== void 0 && !modes.includes(mode)) return fail$1("mode");
+		if (modes === void 0 && source.mode !== void 0 && source.mode !== "in-addition") return fail$1("mode");
+		entries.push({
+			addonId: source.addonId,
+			stableId: source.stableId,
+			mode
+		});
+	}
+	return {
+		ok: true,
+		value: entries
+	};
+}
+function catalogTarget$2(cap, targetId) {
+	const entry = catalog$2[cap];
+	if (entry === void 0) return null;
+	return entry.targets.find((target) => target.id === targetId) ?? null;
+}
+function fail$1(reason) {
+	return {
+		ok: false,
+		reason
+	};
+}
+//#endregion
+//#region src/composition/customize/event-decode.ts
+var ROSE_SOURCE = String.raw`rose\(active(\d+), changed(\d+), (\d+(?:\.\d+)?)\)`;
+function decodePulseOverride(input) {
+	if (input.feature.cap !== input.cap || input.feature.kind !== "fields") return null;
+	if (input.feature.enabled === void 0) return null;
+	const timestamp = input.feature.fields[input.timestampPath];
+	const counter = input.feature.fields[input.counterPath];
+	if (timestamp === void 0 || counter === void 0) return null;
+	if (Object.keys(input.feature.fields).length !== 2) return null;
+	const edges = readEdges(timestamp);
+	if (edges === null) return null;
+	if (readCount(counter, input) === null) return null;
+	const draft = {
+		kind: "pulse",
+		cap: input.cap,
+		targetId: input.targetId,
+		enabled: input.feature.enabled,
+		debounceMs: edges.debounceMs,
+		sources: edges.sources
+	};
+	const decoded = {
+		draft,
+		changedAtFields: edges.changedAtFields
+	};
+	const compiled = compilePulseOverride({
+		draft,
+		device: input.device,
+		changedAtFields: edges.changedAtFields
+	});
+	if (!compiled.ok) return null;
+	return sameFeature$1(compiled.value, input.feature) ? decoded : null;
+}
+function readEdges(field) {
+	if (field.kind !== "expression" || !field.expr.startsWith("latest(") || !field.expr.endsWith(")")) return null;
+	const inner = field.expr.slice(7, -1);
+	const found = [...inner.matchAll(new RegExp(ROSE_SOURCE, "g"))];
+	if (found.length === 0 || found.map((match) => match[0]).join(", ") !== inner) return null;
+	if (Object.keys(field.bindings).length !== found.length * 2) return null;
+	const rows = found.map((match, index) => readRose(match, index, field.bindings));
+	if (rows.some((row) => row === null)) return null;
+	const edges = rows.filter((row) => row !== null);
+	const debounceMs = edges[0]?.debounceMs;
+	if (debounceMs === void 0 || edges.some((row) => row.debounceMs !== debounceMs)) return null;
+	return {
+		debounceMs,
+		sources: edges.map((row) => row.source),
+		changedAtFields: edges.map((row) => row.changedAtField)
+	};
+}
+function readRose(match, index, bindings) {
+	const activeIndex = Number(match[1]);
+	const changedIndex = Number(match[2]);
+	const debounceMs = Number(match[3]);
+	if (activeIndex !== index || changedIndex !== index || !Number.isFinite(debounceMs)) return null;
+	const active = fromBinding(bindings[`active${index}`]);
+	const changed = fromBinding(bindings[`changed${index}`]);
+	if (active === null || changed === null) return null;
+	if (active.cap !== changed.cap) return null;
+	if (active.source.addonId !== changed.source.addonId) return null;
+	if (active.source.stableId !== changed.source.stableId) return null;
+	return {
+		debounceMs,
+		changedAtField: changed.fieldPath,
+		source: {
+			addonId: active.source.addonId,
+			stableId: active.source.stableId,
+			cap: active.cap,
+			fieldPath: active.fieldPath
+		}
+	};
+}
+function fromBinding(value) {
+	if (value === void 0 || value.kind !== "from") return null;
+	return value;
+}
+function readCount(field, input) {
+	if (field.kind !== "expression" || field.expr !== `count(${input.timestampPath})`) return null;
+	const binding = fromBinding(field.bindings[input.timestampPath]);
+	if (binding === null) return null;
+	if (Object.keys(field.bindings).length !== 1) return null;
+	if (binding.cap !== input.cap || binding.fieldPath !== input.timestampPath) return null;
+	if (binding.source.addonId !== input.device.addonId) return null;
+	if (binding.source.stableId !== input.device.stableId) return null;
+	return true;
+}
+function sameFeature$1(left, right) {
+	return sameStored(wrap$1(left), wrap$1(right));
+}
+function wrap$1(feature) {
+	return {
+		family: "composition",
+		target: {
+			addonId: "t",
+			stableId: "t"
+		},
+		feature
+	};
+}
+//#endregion
+//#region src/composition/customize/event-eval.ts
+var INITIAL_PULSE = {
+	priorActive: void 0,
+	lastPressedAt: null,
+	count: 0,
+	acceptedAt: null
+};
+var INITIAL_SPAN = {
+	open: false,
+	startedAt: null,
+	endedAt: null,
+	quietUntil: null,
+	priorActive: void 0
+};
+function stepPulse(state, sample, debounceMs) {
+	if (sample.kind === "unread" || debounceMs < 0) return state;
+	if (state.priorActive === void 0) return {
+		...state,
+		priorActive: sample.active
+	};
+	if (!sample.active) return {
+		...state,
+		priorActive: false
+	};
+	if (state.priorActive) return state;
+	const at = finite(sample.changedAt);
+	if (at === null) return {
+		...state,
+		priorActive: true
+	};
+	if (state.acceptedAt !== null && at - state.acceptedAt < debounceMs) return {
+		...state,
+		priorActive: true
+	};
+	return {
+		priorActive: true,
+		lastPressedAt: at,
+		count: state.count + 1,
+		acceptedAt: at
+	};
+}
+function stepSpan(state, sample, timing) {
+	const timed = expire(state, timing);
+	if (sample.kind === "unread" || timing.timeoutMs < 0 || timing.cooldownMs < 0) return timed;
+	if (timed.priorActive === void 0) return {
+		...timed,
+		priorActive: sample.active
+	};
+	if (timed.open && timed.priorActive && !sample.active) return finish(timed, finite(sample.changedAt) ?? timing.nowMs, timing.cooldownMs, false);
+	if (!sample.active) return {
+		...timed,
+		priorActive: false
+	};
+	if (timed.priorActive || timed.open) return {
+		...timed,
+		priorActive: true
+	};
+	const at = finite(sample.changedAt) ?? timing.nowMs;
+	if (timed.quietUntil !== null && at < timed.quietUntil) return {
+		...timed,
+		priorActive: true
+	};
+	return {
+		open: true,
+		startedAt: at,
+		endedAt: null,
+		quietUntil: null,
+		priorActive: true
+	};
+}
+function expire(state, timing) {
+	if (!state.open || state.startedAt === null) return state;
+	const deadline = state.startedAt + timing.timeoutMs;
+	if (timing.nowMs < deadline) return state;
+	return finish(state, deadline, timing.cooldownMs, state.priorActive === true);
+}
+function finish(state, endedAt, cooldownMs, priorActive) {
+	return {
+		open: false,
+		startedAt: state.startedAt,
+		endedAt,
+		quietUntil: cooldownMs > 0 ? endedAt + cooldownMs : null,
+		priorActive
+	};
+}
+function finite(value) {
+	return value !== null && Number.isFinite(value) ? value : null;
+}
+//#endregion
+//#region src/composition/customize/event-status.ts
+function projectPulseAssignment(input) {
+	if (input.stored.kind === "pending") return held(input.targetId, "pending", null);
+	if (input.stored.kind === "unknown") return held(input.targetId, "unknown", input.stored.reason ?? "unknown");
+	if (input.stored.value === null) return native$1(input.targetId);
+	const decoded = decodePulseOverride({
+		feature: input.stored.value,
+		device: input.device,
+		cap: input.cap,
+		targetId: input.targetId,
+		timestampPath: input.timestampPath,
+		counterPath: input.counterPath
+	});
+	if (decoded === null) return {
+		text: "unknown",
+		status: row(input.targetId, true, "assigned", "unavailable", "not-canonical")
+	};
+	if (input.sourcePresence === "pending") return {
+		text: "pending",
+		status: row(input.targetId, true, "assigned", "stale", null)
+	};
+	if (input.sourcePresence === "unknown") return {
+		text: "unknown",
+		status: row(input.targetId, true, "assigned", "stale", input.sourceUnknownReason ?? "unknown")
+	};
+	if (input.sourcePresence === "absent" && input.apply === "replace") return {
+		text: "Native · source missing",
+		status: row(input.targetId, true, "native", "released", "source-missing")
+	};
+	if (input.sourcePresence === "absent") return {
+		text: "Assigned · source missing",
+		status: row(input.targetId, true, "assigned", "unavailable", "source-missing")
+	};
+	const source = decoded.draft.sources[0];
+	return {
+		text: `Assigned · ${source === void 0 ? "assigned" : `${source.cap}.${source.fieldPath}`}`,
+		status: row(input.targetId, true, "assigned", "active", null)
+	};
+}
+function projectSpanAssignment(targetId, stored) {
+	if (stored.kind === "pending") return {
+		text: "pending",
+		writable: false,
+		rows: [],
+		status: row(targetId, false, "native", "unavailable", null)
+	};
+	if (stored.kind === "unknown") return {
+		text: "unknown",
+		writable: false,
+		rows: [],
+		status: row(targetId, false, "native", "stale", stored.reason ?? "unknown")
+	};
+	if (stored.value.state === "unreadable") return {
+		text: "unreadable",
+		writable: false,
+		rows: [],
+		status: row(targetId, false, "assigned", "unavailable", stored.value.reason)
+	};
+	if (stored.value.state === "not-configured") return {
+		text: "Native",
+		writable: true,
+		rows: [],
+		status: row(targetId, false, "native", "active", null)
+	};
+	const rows = stored.value.sensors.map(sensorRow);
+	const reason = spanReason(stored.value);
+	return {
+		text: rows.length === 0 ? "Native" : "Assigned",
+		writable: true,
+		rows,
+		status: row(targetId, rows.length > 0, "assigned", "active", reason)
+	};
+}
+function spanReason(status) {
+	if (status.notForwarded !== void 0) return status.notForwarded;
+	if (status.notEnforced !== void 0) return status.notEnforced;
+	return status.sensors.map(attachmentReason).find((reason) => reason !== null) ?? null;
+}
+function sensorRow(sensor) {
+	return {
+		key: `${sensor.addonId}/${sensor.stableId}`,
+		addonId: sensor.addonId,
+		stableId: sensor.stableId,
+		name: sensor.state === "missing" || sensor.state === "unreadable" ? sensor.stableId : sensor.name,
+		mode: sensor.mode,
+		state: sensor.state,
+		reason: attachmentReason(sensor)
+	};
+}
+function attachmentReason(sensor) {
+	switch (sensor.state) {
+		case "ready": return null;
+		case "offline":
+		case "missing":
+		case "unsupported":
+		case "unreadable": return sensor.reason;
+	}
+}
+function native$1(targetId) {
+	return {
+		text: "Native",
+		status: row(targetId, false, "native", "active", null)
+	};
+}
+function held(targetId, text, reason) {
+	return {
+		text,
+		status: row(targetId, false, "native", text === "pending" ? "unavailable" : "stale", reason)
+	};
+}
+function row(targetId, configured, source, state, reason) {
+	return {
+		targetId,
+		configured,
+		source,
+		state,
+		reason
+	};
+}
+//#endregion
+//#region src/composition/customize/keyed-array-expr.ts
+var STEP = /^x == ("(?:\\.|[^"\\])*") \? ("(?:\\.|[^"\\])*"|null) : ([\s\S]+)$/;
+function enumMapExpr(mapping) {
+	const keys = Object.keys(mapping).toSorted();
+	if (keys.length === 0) return null;
+	return keys.reduceRight((rest, key) => {
+		if (rest === null) return null;
+		const value = mapping[key];
+		if (value === void 0) return null;
+		const rhs = value === null ? "null" : JSON.stringify(value);
+		return `x == ${JSON.stringify(key)} ? ${rhs} : ${rest}`;
+	}, "null");
+}
+function parseEnumMap(expr) {
+	const mapping = {};
+	let rest = expr;
+	while (rest !== "null") {
+		const match = STEP.exec(rest);
+		if (match === null || match[1] === void 0 || match[2] === void 0 || match[3] === void 0) return null;
+		const key = jsonString(match[1]);
+		const value = match[2] === "null" ? null : jsonString(match[2]);
+		if (key === null || match[2] !== "null" && value === null) return null;
+		if (Object.prototype.hasOwnProperty.call(mapping, key)) return null;
+		mapping[key] = value;
+		rest = match[3];
+	}
+	return Object.keys(mapping).length === 0 ? null : mapping;
+}
+function enumMapDraft(mapping) {
+	return {
+		kind: "enum-map",
+		mapping: { ...mapping }
+	};
+}
+function jsonString(token) {
+	try {
+		const parsed = JSON.parse(token);
+		return typeof parsed === "string" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/composition/customize/keyed-array-compile.ts
+var catalog$1 = CAP_CUSTOMIZE_CATALOG;
+function compileKeyedArrayOverride(input) {
+	const target = catalogTarget$1(input.cap, input.targetId);
+	if (target === null || target.cardinality !== "keyedArray") return fail("target");
+	if (input.items.length === 0) return fail("items");
+	if (input.items.some((item) => item.draft.cap !== input.cap || item.draft.targetId !== input.targetId)) return fail("target");
+	const keys = input.items.map((item) => item.draft.key);
+	if (new Set(keys).size !== keys.length) return fail("key");
+	const built = input.items.reduce((acc, item) => {
+		if (!acc.ok) return acc;
+		const entry = compileItem(target, item);
+		if (!entry.ok) return entry;
+		return {
+			ok: true,
+			value: {
+				...acc.value,
+				[item.draft.key]: entry.value
+			}
+		};
+	}, {
+		ok: true,
+		value: {}
+	});
+	if (!built.ok) return built;
+	const fields = compileCompanions(target, input.apply);
+	if (!fields.ok) return fields;
+	return {
+		ok: true,
+		value: {
+			kind: "fields",
+			cap: input.cap,
+			fields: fields.value,
+			items: { ...built.value }
+		}
+	};
+}
+/** Put one compiled item into an existing feature. Other items stay as stored. */
+function mergeKeyedArrayItem(current, compiled, key) {
+	const item = compiled.items?.[key];
+	if (item === void 0) return null;
+	return {
+		kind: "fields",
+		cap: compiled.cap,
+		...current?.enabled === void 0 ? {} : { enabled: current.enabled },
+		fields: current === null ? compiled.fields : current.fields,
+		items: {
+			...current?.items,
+			[key]: item
+		}
+	};
+}
+/** The feature without item `key`. Null when that item was the last one. */
+function withoutKeyedArrayItem(feature, key) {
+	const rest = Object.fromEntries(Object.entries(feature.items ?? {}).filter(([name]) => name !== key));
+	if (Object.keys(rest).length === 0) return null;
+	return {
+		...feature,
+		items: rest
+	};
+}
+function fail(reason) {
+	return {
+		ok: false,
+		reason
+	};
+}
+function catalogTarget$1(cap, targetId) {
+	const entry = catalog$1[cap];
+	if (entry === void 0) return null;
+	return entry.targets.find((target) => target.id === targetId) ?? null;
+}
+function compileItem(target, item) {
+	if (!require_composition.COMPOSITION_ITEM_KEY_RE.test(item.draft.key) || item.draft.label.trim() === "") return fail("key");
+	const field = (target.fields ?? []).find((entry) => entry.path === item.draft.fieldPath);
+	if (field === void 0) return fail("field");
+	const source = sourceSpec(field, item);
+	if (source === null) return fail("source-kind");
+	if (source.requiredUnit !== void 0 && item.sourceUnit !== source.requiredUnit) return fail("unit");
+	const allowed = item.draft.transform.kind;
+	if (!source.transformKinds.includes(allowed)) return fail("transform");
+	const value = compileValue(item, field);
+	if (!value.ok) return value;
+	const fields = compileLiterals(target, field, item, value.value);
+	if (!fields.ok) return fields;
+	return {
+		ok: true,
+		value: {
+			label: item.draft.label.trim(),
+			fields: fields.value
+		}
+	};
+}
+function sourceSpec(field, item) {
+	if (item.sourceValueKind === "number") return field.sources.find((source) => source.kind === "numeric") ?? null;
+	if (item.sourceValueKind === "enum" || item.sourceValueKind === "string") return field.sources.find((source) => source.kind === "enum") ?? null;
+	return null;
+}
+function compileValue(item, field) {
+	const read = fromRead(refOf(item.draft), item.draft.source.cap, item.draft.source.fieldPath);
+	const transform = item.draft.transform;
+	if (transform.kind === "identity") return {
+		ok: true,
+		value: read
+	};
+	if (transform.kind === "linear") return linearValue(transform, read);
+	if (transform.kind === "enum-map") return enumValue(transform, read, field);
+	return fail("transform");
+}
+function linearValue(transform, read) {
+	const scale = signedToken(transform.scale);
+	const offset = signedToken(transform.offset);
+	if (scale === null || offset === null) return fail("scale");
+	const clamps = clampTokens(transform.clampMin, transform.clampMax);
+	if (!clamps.ok) return clamps;
+	return {
+		ok: true,
+		value: expression(linearExpr("x", scale, offset, clamps.value.min, clamps.value.max), { x: read })
+	};
+}
+function clampTokens(clampMin, clampMax) {
+	if (clampMin === void 0 && clampMax === void 0) return {
+		ok: true,
+		value: {
+			min: null,
+			max: null
+		}
+	};
+	if (clampMin === void 0 || clampMax === void 0) return fail("clamp");
+	const min = signedToken(clampMin);
+	const max = signedToken(clampMax);
+	if (min === null || max === null || clampMin > clampMax) return fail("clamp");
+	return {
+		ok: true,
+		value: {
+			min,
+			max
+		}
+	};
+}
+function enumValue(transform, read, field) {
+	const allowed = new Set(field.enumValues ?? []);
+	const entries = Object.entries(transform.mapping);
+	if (entries.length === 0) return fail("enum");
+	if (entries.some(([key, value]) => key.length === 0 || value !== null && !allowed.has(value))) return fail("enum");
+	const expr = enumMapExpr(transform.mapping);
+	if (expr === null) return fail("enum");
+	return {
+		ok: true,
+		value: expression(expr, { x: read })
+	};
+}
+function compileLiterals(target, field, item, value) {
+	const required = new Set((field.literals ?? []).map((literalSpec) => literalSpec.path));
+	const traits = new Map((target.traits ?? []).map((trait) => [trait.path, new Set(trait.values)]));
+	if ([...required].filter((path) => !item.literals.some((literalSpec) => literalSpec.path === path)).length > 0) return fail("literal");
+	return item.literals.reduce((acc, entry) => {
+		if (!acc.ok) return acc;
+		if (entry.path === field.path || acc.value[entry.path] !== void 0) return fail("literal");
+		const allowed = allowedLiteral(field, traits, entry.path);
+		if (allowed === null || !allowed.has(entry.value)) return fail("literal");
+		const expr = constantExpr(entry.value);
+		if (expr === null) return fail("literal");
+		return {
+			ok: true,
+			value: {
+				...acc.value,
+				[entry.path]: literal(expr)
+			}
+		};
+	}, {
+		ok: true,
+		value: { [field.path]: value }
+	});
+}
+function allowedLiteral(field, traits, path) {
+	const trait = traits.get(path);
+	if (trait !== void 0) return trait;
+	const required = (field.literals ?? []).find((entry) => entry.path === path);
+	return required === void 0 ? null : new Set(required.values);
+}
+function compileCompanions(target, apply) {
+	return (target.companions ?? []).filter((companion) => companionIncluded(companion, apply)).reduce((acc, companion) => {
+		if (!acc.ok) return acc;
+		if (companion.kind !== "clock") return fail("companion");
+		return {
+			ok: true,
+			value: {
+				...acc.value,
+				[companion.path]: literal("now")
+			}
+		};
+	}, {
+		ok: true,
+		value: {}
+	});
+}
+function companionIncluded(companion, apply) {
+	if (companion.kind === "transition-time") return false;
+	return companion.when === "always" || apply === "add";
+}
+function refOf(draft) {
+	return {
+		addonId: draft.source.addonId,
+		stableId: draft.source.stableId
+	};
+}
+//#endregion
+//#region src/composition/customize/keyed-array-decode.ts
+var catalog = CAP_CUSTOMIZE_CATALOG;
+function readKeyedArrayItems(feature, cap, targetId) {
+	const target = catalogTarget(cap, targetId);
+	if (target === null || target.cardinality !== "keyedArray" || feature.cap !== cap) return null;
+	const apply = inferApply(target, feature.fields);
+	const canonical = apply !== null && companionsMatch(target, feature.fields, apply);
+	const items = Object.entries(feature.items ?? {}).map(([key, item]) => viewOf(target, cap, targetId, key, item, canonical));
+	return {
+		canonical,
+		apply: apply ?? "add",
+		items
+	};
+}
+function decodeKeyedArrayOverride(input) {
+	const read = readKeyedArrayItems(input.feature, input.cap, input.targetId);
+	if (read === null || !read.canonical) return null;
+	if (read.items.some((item) => item.compile === null)) return null;
+	const compiles = read.items.flatMap((item) => item.compile === null ? [] : [item.compile]);
+	const compiled = compileKeyedArrayOverride({
+		cap: input.cap,
+		targetId: input.targetId,
+		device: input.device,
+		apply: read.apply,
+		items: compiles
+	});
+	if (!compiled.ok) return null;
+	return sameFeature(compiled.value, input.feature) ? read : null;
+}
+function viewOf(target, cap, targetId, key, item, canonical) {
+	const blank = {
+		key,
+		label: item.label,
+		recognized: false,
+		compile: null
+	};
+	if (!canonical) return blank;
+	const compile = compileOf(target, cap, targetId, key, item);
+	if (compile === null) return blank;
+	return {
+		key,
+		label: item.label,
+		recognized: true,
+		compile
+	};
+}
+function compileOf(target, cap, targetId, key, item) {
+	const assigned = assignedField(target, item);
+	if (assigned === null) return null;
+	const literals = literalFields(target, assigned.field, item, assigned.path);
+	if (literals === null) return null;
+	const draft = draftOf(cap, targetId, key, item.label, assigned);
+	if (draft === null) return null;
+	const compile = {
+		draft,
+		sourceValueKind: assigned.sourceValueKind,
+		sourceUnit: null,
+		literals
+	};
+	return reproduces(cap, targetId, key, compile, item) ? compile : null;
+}
+function assignedField(target, item) {
+	const paths = Object.keys(item.fields).filter((path) => !isConstant(item.fields[path]));
+	if (paths.length !== 1) return null;
+	const path = paths[0];
+	if (path === void 0) return null;
+	const field = (target.fields ?? []).find((entry) => entry.path === path);
+	const source = item.fields[path];
+	if (field === void 0 || source === void 0) return null;
+	const read = readTransform(source, field);
+	if (read === null) return null;
+	return {
+		path,
+		field,
+		source,
+		...read
+	};
+}
+function readTransform(source, field) {
+	if (source.kind === "from") return field.valueKind === "enum" ? {
+		sourceValueKind: "enum",
+		transform: { kind: "identity" }
+	} : {
+		sourceValueKind: "number",
+		transform: { kind: "identity" }
+	};
+	if (source.kind !== "expression") return null;
+	const mapped = parseEnumMap(source.expr);
+	if (mapped !== null && field.valueKind === "enum") return {
+		sourceValueKind: "enum",
+		transform: enumMapDraft(mapped)
+	};
+	const linear = parseLinear(source.expr);
+	if (linear === null || linear.inner !== "x" || field.valueKind !== "number") return null;
+	return {
+		sourceValueKind: "number",
+		transform: {
+			kind: "linear",
+			scale: linear.scale,
+			offset: linear.offset,
+			...linear.clampMin === void 0 || linear.clampMax === void 0 ? {} : {
+				clampMin: linear.clampMin,
+				clampMax: linear.clampMax
+			}
+		}
+	};
+}
+function literalFields(target, field, item, assignedPath) {
+	const required = new Set((field.literals ?? []).map((entry) => entry.path));
+	const traits = new Set((target.traits ?? []).map((trait) => trait.path));
+	const found = Object.keys(item.fields).filter((path) => path !== assignedPath);
+	if (found.some((path) => !required.has(path) && !traits.has(path))) return null;
+	if ([...required].some((path) => !found.includes(path))) return null;
+	const literals = found.map((path) => literalValue(item.fields[path], path));
+	if (literals.some((entry) => entry === null)) return null;
+	return literals.flatMap((entry) => entry === null ? [] : [entry]);
+}
+function literalValue(source, path) {
+	if (source?.kind !== "expression" || Object.keys(source.bindings).length !== 0) return null;
+	if (!(source.expr.startsWith("\"") && source.expr.endsWith("\""))) return null;
+	try {
+		const parsed = JSON.parse(source.expr);
+		return typeof parsed === "string" ? {
+			path,
+			value: parsed
+		} : null;
+	} catch {
+		return null;
+	}
+}
+function draftOf(cap, targetId, key, label, assigned) {
+	const bound = singleFrom(assigned.source);
+	if (bound === null) return null;
+	return {
+		kind: "keyedArray",
+		cap,
+		targetId,
+		key,
+		label,
+		fieldPath: assigned.path,
+		source: {
+			addonId: bound.addonId,
+			stableId: bound.stableId,
+			cap: bound.cap,
+			fieldPath: bound.fieldPath
+		},
+		transform: assigned.transform
+	};
+}
+function reproduces(cap, targetId, key, compile, item) {
+	const compiled = compileKeyedArrayOverride({
+		cap,
+		targetId,
+		device: {
+			addonId: "t",
+			stableId: "t"
+		},
+		apply: "add",
+		items: [compile]
+	});
+	if (!compiled.ok) return false;
+	const written = compiled.value.items?.[key];
+	if (written === void 0) return false;
+	return JSON.stringify(written) === JSON.stringify(item);
+}
+function isConstant(source) {
+	return source?.kind === "expression" && Object.keys(source.bindings).length === 0;
+}
+function inferApply(target, fields) {
+	const addPaths = (target.companions ?? []).flatMap((companion) => companion.kind !== "transition-time" && companion.when === "add" ? [companion.path] : []);
+	if (addPaths.length === 0) return "replace";
+	const present = addPaths.filter((path) => fields[path] !== void 0);
+	if (present.length === addPaths.length) return "add";
+	if (present.length === 0) return "replace";
+	return null;
+}
+function companionsMatch(target, fields, apply) {
+	const expected = (target.companions ?? []).flatMap((companion) => {
+		if (companion.kind === "transition-time") return [];
+		if (companion.when === "always" || apply === "add") return [companion.path];
+		return [];
+	});
+	if (Object.keys(fields).toSorted().join(",") !== [...expected].toSorted().join(",")) return false;
+	return expected.every((path) => isLiteral(fields[path], "now"));
+}
+function catalogTarget(cap, targetId) {
+	const entry = catalog[cap];
+	if (entry === void 0) return null;
+	return entry.targets.find((target) => target.id === targetId) ?? null;
+}
+function sameFeature(compiled, stored) {
+	return sameStored(wrap(stripEnabled(compiled)), wrap(stripEnabled(stored)));
+}
+function stripEnabled(feature) {
+	const { enabled: _enabled, ...rest } = feature;
+	return rest;
+}
+function wrap(feature) {
+	return {
+		family: "composition",
+		target: {
+			addonId: "t",
+			stableId: "t"
+		},
+		feature
+	};
+}
+//#endregion
+//#region src/composition/customize/keyed-array-status.ts
+function projectKeyedArrayAssignment(input) {
+	if (input.stored.kind === "pending") return unanswered(input.targetId, "pending", null);
+	if (input.stored.kind === "unknown") return unanswered(input.targetId, "unknown", input.stored.reason ?? "unknown");
+	if (input.stored.value === null) return native(input.targetId);
+	const read = readKeyedArrayItems(input.stored.value, input.cap, input.targetId);
+	const count = read?.items.filter((item) => item.recognized).length ?? 0;
+	if (read === null || !read.canonical || count === 0) return {
+		text: "unknown",
+		assignedCount: 0,
+		status: status(input.targetId, true, "assigned", "unavailable", "not-canonical")
+	};
+	return projectDecoded(input, count);
+}
+function projectDecoded(input, count) {
+	const text = `${count} assigned`;
+	if (input.sourcePresence === "pending") return {
+		text: "pending",
+		assignedCount: count,
+		status: status(input.targetId, true, "assigned", "stale", null)
+	};
+	if (input.sourcePresence === "unknown") return {
+		text: "unknown",
+		assignedCount: count,
+		status: status(input.targetId, true, "assigned", "stale", input.sourceUnknownReason ?? "unknown")
+	};
+	if (input.sourcePresence === "absent") return {
+		text,
+		assignedCount: count,
+		status: status(input.targetId, true, "assigned", "unavailable", "source-missing")
+	};
+	return {
+		text,
+		assignedCount: count,
+		status: status(input.targetId, true, "assigned", "active", null)
+	};
+}
+function native(targetId) {
+	return {
+		text: "Native",
+		assignedCount: 0,
+		status: status(targetId, false, "native", "active", null)
+	};
+}
+function unanswered(targetId, text, reason) {
+	return {
+		text,
+		assignedCount: 0,
+		status: status(targetId, false, "native", text === "pending" ? "unavailable" : "stale", reason)
+	};
+}
+function status(targetId, configured, source, state, reason) {
+	return {
+		targetId,
+		configured,
+		source,
+		state,
+		reason
+	};
+}
+//#endregion
 //#region src/generated/scope-presets.ts
 var SCOPE_PRESETS = [
 	{
@@ -111026,6 +112992,7 @@ exports.CAMSTACK_EVENT_PREFIX = CAMSTACK_EVENT_PREFIX;
 exports.CAM_PROFILE_ORDER = require_sleep.CAM_PROFILE_ORDER;
 exports.CAPABILITY_NAMES = CAPABILITY_NAMES;
 exports.CAPABILITY_ROUTER_KEYS = CAPABILITY_ROUTER_KEYS;
+exports.CAP_CUSTOMIZE_CATALOG = CAP_CUSTOMIZE_CATALOG;
 exports.CAP_NAMES_WITH_STATUS = CAP_NAMES_WITH_STATUS;
 exports.CAP_NODE_PIN_CONTEXT_KEY = require_sleep.CAP_NODE_PIN_CONTEXT_KEY;
 exports.CAP_PROVIDER_KIND_MAP = CAP_PROVIDER_KIND_MAP;
@@ -111254,6 +113221,7 @@ exports.CredentialScopeSchema = CredentialScopeSchema;
 exports.CredentialTokenClaimsSchema = CredentialTokenClaimsSchema;
 exports.CustomActionInputSchema = CustomActionInputSchema;
 exports.CustomModelDescriptorSchema = CustomModelDescriptorSchema;
+exports.CustomizeAssignmentStatusSchema = CustomizeAssignmentStatusSchema;
 exports.DATABASE_SNAPSHOT_PARTIAL_SUFFIX = DATABASE_SNAPSHOT_PARTIAL_SUFFIX;
 exports.DATABASE_SNAPSHOT_SUFFIX = DATABASE_SNAPSHOT_SUFFIX;
 exports.DATABASE_SNAPSHOT_TIMEOUT_MS = DATABASE_SNAPSHOT_TIMEOUT_MS;
@@ -111595,6 +113563,8 @@ exports.ICON_ENTRIES = ICON_ENTRIES;
 exports.ICON_KEYS = ICON_KEYS;
 exports.ICON_VIEWER_MODULES = ICON_VIEWER_MODULES;
 exports.INFERENCE_DEVICE_EXCLUSION_REASONS = INFERENCE_DEVICE_EXCLUSION_REASONS;
+exports.INITIAL_PULSE = INITIAL_PULSE;
+exports.INITIAL_SPAN = INITIAL_SPAN;
 exports.INVERTIBLE_CAPS = INVERTIBLE_CAPS;
 exports.IconKeySchema = IconKeySchema;
 exports.ImageContractSchema = ImageContractSchema;
@@ -111776,6 +113746,7 @@ exports.MOTION_CROP_MAX_REGIONS = MOTION_CROP_MAX_REGIONS;
 exports.MOTION_CROP_MOTION_PAD = MOTION_CROP_MOTION_PAD;
 exports.MOTION_CROP_TRACKED_PAD = MOTION_CROP_TRACKED_PAD;
 exports.MOTION_SOURCE_LABELS = MOTION_SOURCE_LABELS;
+exports.MOTION_SPAN_TIMEOUT_MS = MOTION_SPAN_TIMEOUT_MS;
 exports.MOTION_TRIGGER_FEATURE = MOTION_TRIGGER_FEATURE;
 exports.ManagedModelCatalogEntrySchema = ManagedModelCatalogEntrySchema;
 exports.ManagedModelExtraFileSchema = ManagedModelExtraFileSchema;
@@ -112151,6 +114122,7 @@ exports.OsdTemplateBindingSchema = OsdTemplateBindingSchema;
 exports.OsdTemplateFormatSchema = OsdTemplateFormatSchema;
 exports.OsdTemplatePickSchema = OsdTemplatePickSchema;
 exports.OsdTemplateTokenKindSchema = OsdTemplateTokenKindSchema;
+exports.OverrideDraftSchema = OverrideDraftSchema;
 exports.PEER_BYTES_CHUNK_BYTES = require_sleep.PEER_BYTES_CHUNK_BYTES;
 exports.PEER_BYTES_MAX_OUTSTANDING = require_sleep.PEER_BYTES_MAX_OUTSTANDING;
 exports.PEER_BYTES_STALL_MS = require_sleep.PEER_BYTES_STALL_MS;
@@ -112314,6 +114286,7 @@ exports.ROOT_SUPPLIABLE_STEP_IDS = ROOT_SUPPLIABLE_STEP_IDS;
 exports.RUNNING_POWER_START_DELAY_MS = RUNNING_POWER_START_DELAY_MS;
 exports.RUNNING_POWER_STOP_DELAY_MS = RUNNING_POWER_STOP_DELAY_MS;
 exports.RUNNING_POWER_THRESHOLD_WATTS = RUNNING_POWER_THRESHOLD_WATTS;
+exports.RUNNING_STATE_COLD = RUNNING_STATE_COLD;
 exports.RUNTIME_DEFAULTS = require_sleep.RUNTIME_DEFAULTS;
 exports.RUNTIME_STATE_POLICY = RUNTIME_STATE_POLICY;
 exports.RUNTIME_STATE_REFRESH_MISS_COOLDOWN_MS = RUNTIME_STATE_REFRESH_MISS_COOLDOWN_MS;
@@ -112742,6 +114715,7 @@ exports.UninstallNodeResultSchema = UninstallNodeResultSchema;
 exports.UninstallPackageResultSchema = UninstallPackageResultSchema;
 exports.UnitConversionError = UnitConversionError;
 exports.UnknownRecordKindError = require_sleep.UnknownRecordKindError;
+exports.UnreleasedClaimSchema = UnreleasedClaimSchema;
 exports.UnstampedEventMediaCountSchema = UnstampedEventMediaCountSchema;
 exports.UnstampedRowsSchema = UnstampedRowsSchema;
 exports.UpdateBlockerSchema = UpdateBlockerSchema;
@@ -112906,7 +114880,6 @@ exports.buildCapabilityLookup = buildCapabilityLookup;
 exports.buildDeviceAdminUrl = buildDeviceAdminUrl;
 exports.buildDeviceEnrollmentLink = buildDeviceEnrollmentLink;
 exports.buildDeviceSignatureMessage = buildDeviceSignatureMessage;
-exports.buildDoorbellCompositionFeature = buildDoorbellCompositionFeature;
 exports.buildEventKindDescriptor = buildEventKindDescriptor;
 exports.buildFfmpegArgs = require_composition.buildFfmpegArgs;
 exports.buildFrigateClassMap = buildFrigateClassMap;
@@ -112980,6 +114953,10 @@ exports.commitWatchdogRestart = commitWatchdogRestart;
 exports.compareToTarget = compareToTarget;
 exports.compileExpression = require_composition.compileExpression;
 exports.compileExpressionSafe = require_composition.compileExpressionSafe;
+exports.compileKeyedArrayOverride = compileKeyedArrayOverride;
+exports.compilePulseOverride = compilePulseOverride;
+exports.compileScalarOverride = compileScalarOverride;
+exports.compileSpanOverride = compileSpanOverride;
 exports.composeSwitchedOff = composeSwitchedOff;
 exports.composedDeviceRef = require_composition.composedDeviceRef;
 exports.composedDeviceStableId = require_composition.composedDeviceStableId;
@@ -113044,6 +115021,9 @@ exports.dayOfWeekToIndex = dayOfWeekToIndex;
 exports.declarationOwnerNodeId = declarationOwnerNodeId;
 exports.declarationsOf = require_sleep.declarationsOf;
 exports.declareLogChannel = declareLogChannel;
+exports.decodeKeyedArrayOverride = decodeKeyedArrayOverride;
+exports.decodePulseOverride = decodePulseOverride;
+exports.decodeScalarOverride = decodeScalarOverride;
 exports.decodeVectorBase64 = decodeVectorBase64;
 exports.decoderCapability = decoderCapability;
 exports.defaultDeliveryForSection = defaultDeliveryForSection;
@@ -113102,7 +115082,6 @@ exports.dishwasherCapability = dishwasherCapability;
 exports.doActionSelectValue = doActionSelectValue;
 exports.dominantClipLabels = dominantClipLabels;
 exports.doorbellCapability = doorbellCapability;
-exports.doorbellFeatureSources = doorbellFeatureSources;
 exports.droppedConditionsForKind = droppedConditionsForKind;
 exports.edgetpuDelegateDevice = edgetpuDelegateDevice;
 exports.effectiveStepSettings = effectiveStepSettings;
@@ -113280,7 +115259,6 @@ exports.isRemovedModelId = isRemovedModelId;
 exports.isRestoredCap = isRestoredCap;
 exports.isRetiredClearKey = isRetiredClearKey;
 exports.isRootSuppliableStepId = isRootSuppliableStepId;
-exports.isRunningAssignmentFeature = isRunningAssignmentFeature;
 exports.isSameAddonId = isSameAddonId;
 exports.isScheduleActive = isScheduleActive;
 exports.isSecretClear = require_sleep.isSecretClear;
@@ -113355,6 +115333,7 @@ exports.measuredDetectorCells = measuredDetectorCells;
 exports.mediaPlayerCapability = mediaPlayerCapability;
 exports.memoizePinnedFfmpeg = memoizePinnedFfmpeg;
 exports.mergeClipLabels = mergeClipLabels;
+exports.mergeKeyedArrayItem = mergeKeyedArrayItem;
 exports.mergeSecretStatePaths = require_sleep.mergeSecretStatePaths;
 exports.mergeSettingsBags = mergeSettingsBags;
 exports.mergeSourceInfo = mergeSourceInfo;
@@ -113481,6 +115460,10 @@ exports.pressureSensorCapability = pressureSensorCapability;
 exports.principalMayReachAddon = principalMayReachAddon;
 exports.privacyMaskCapability = privacyMaskCapability;
 exports.procedureAuthKey = procedureAuthKey;
+exports.projectKeyedArrayAssignment = projectKeyedArrayAssignment;
+exports.projectPulseAssignment = projectPulseAssignment;
+exports.projectScalarAssignment = projectScalarAssignment;
+exports.projectSpanAssignment = projectSpanAssignment;
 exports.projectSubjectPath = projectSubjectPath;
 exports.providerMotionEvent = providerMotionEvent;
 exports.ptzAutotrackCapability = ptzAutotrackCapability;
@@ -113496,6 +115479,7 @@ exports.readErrorI18n = require_sleep.readErrorI18n;
 exports.readFaceRescoreIntervalMinutes = readFaceRescoreIntervalMinutes;
 exports.readHubMotionDetected = readHubMotionDetected;
 exports.readHubMotionStatus = readHubMotionStatus;
+exports.readKeyedArrayItems = readKeyedArrayItems;
 exports.readMotionTriggeredBy = readMotionTriggeredBy;
 exports.readNativeLeaseOverride = readNativeLeaseOverride;
 exports.readNodePin = require_sleep.readNodePin;
@@ -113598,8 +115582,6 @@ exports.ruleSectionOf = ruleSectionOf;
 exports.ruleSeedForSection = ruleSeedForSection;
 exports.ruleTriggerZoneIds = ruleTriggerZoneIds;
 exports.runInferenceStep = runInferenceStep;
-exports.runningAssignmentFeature = runningAssignmentFeature;
-exports.runningAssignmentRecovered = runningAssignmentRecovered;
 exports.runningFromDishwasherOperation = runningFromDishwasherOperation;
 exports.runningFromLawnMower = runningFromLawnMower;
 exports.runningFromMediaPlayer = runningFromMediaPlayer;
@@ -113662,7 +115644,9 @@ exports.startReachabilityPoll = startReachabilityPoll;
 exports.stateLabel = stateLabel;
 exports.stateVocabularyFor = stateVocabularyFor;
 exports.stepModelRunsOnFormat = stepModelRunsOnFormat;
+exports.stepPulse = stepPulse;
 exports.stepSettingSource = stepSettingSource;
+exports.stepSpan = stepSpan;
 exports.storageAdminCapability = storageAdminCapability;
 exports.storageCapability = storageCapability;
 exports.storageEvictableCapability = storageEvictableCapability;
@@ -113780,6 +115764,7 @@ exports.withLocationMode = withLocationMode;
 exports.withSystemEventClasses = withSystemEventClasses;
 exports.withoutCallerStamp = require_sleep.withoutCallerStamp;
 exports.withoutField = withoutField;
+exports.withoutKeyedArrayItem = withoutKeyedArrayItem;
 exports.writeModelBoundSetting = writeModelBoundSetting;
 exports.zodEntriesToConfigUI = zodEntriesToConfigUI;
 exports.zoneAnalyticsCapability = zoneAnalyticsCapability;