@camstack/types 1.2.264 → 1.2.265

package/dist/index.js

@@ -5547,23 +5547,6 @@ var ExpressionEvalError = class extends Error {
 };
 //#endregion
 //#region src/expression/builtins.ts
-/**
-* Frozen, null-prototype builtin function table for the expression engine
-* (spec §4 rule 4). The table is the SOLE surface of callable functions: the
-* parser rejects any callee not in it, and the evaluator gates each call on an
-* own-property check against it.
-*
-* Because the object has a NULL prototype AND is `Object.freeze`d:
-*  - it cannot be polluted (no `__proto__` / `constructor` write reaches it);
-*  - a lookup for `toString` / `hasOwnProperty` / `constructor` finds NOTHING
-*    (there is no `Object.prototype` in the chain), so those names are not
-*    callable — they are simply "unknown function" at parse time.
-*
-* Every numeric argument is validated as a finite number and every numeric
-* RESULT is re-checked finite, so `/0`, `sqrt(-1)` (→ NaN) and overflow
-* (`pow(10,400)` → Infinity) all raise `ExpressionEvalError` and fail the link
-* closed rather than emitting a garbage value.
-*/
 function asFiniteNumber(value, name, index) {
 	if (typeof value !== "number" || !Number.isFinite(value)) throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a finite number`);
 	return value;
@@ -5579,6 +5562,10 @@ function finiteResult(value, name) {
 function allFiniteNumbers(args, name) {
 	return args.map((a, idx) => asFiniteNumber(a, name, idx));
 }
+function asBoolean$1(value, name, index) {
+	if (typeof value !== "boolean") throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a boolean`);
+	return value;
+}
 var INF = Number.POSITIVE_INFINITY;
 var table = {
 	min: {
@@ -5679,6 +5666,40 @@ var table = {
 			if (from === to) return x;
 			throw new ExpressionEvalError("convert: unit conversion table not installed");
 		}
+	},
+	any: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => args.map((a, i) => asBoolean$1(a, "any", i)).some((b) => b)
+	},
+	all: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => args.map((a, i) => asBoolean$1(a, "all", i)).every((b) => b)
+	},
+	within: {
+		minArgs: 2,
+		maxArgs: 2,
+		apply: (args, hooks) => {
+			const windowMs = asFiniteNumber(args[1], "within", 1);
+			if (windowMs < 0) throw new ExpressionEvalError("within: the window must not be negative");
+			const at = args[0];
+			if (at === null) return false;
+			const ts = asFiniteNumber(at, "within", 0);
+			const now = hooks.now;
+			if (now === void 0 || !Number.isFinite(now)) throw new ExpressionEvalError("within: no clock was supplied to this evaluation");
+			const inside = now - ts <= windowMs;
+			if (inside) hooks.noteDeadline?.(ts + windowMs + 1);
+			return inside;
+		}
+	},
+	latest: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => {
+			const present = args.flatMap((a, i) => a === null ? [] : [asFiniteNumber(a, "latest", i)]);
+			return present.length === 0 ? null : finiteResult(Math.max(...present), "latest");
+		}
 	}
 };
 /** Frozen, null-prototype builtin table. */
@@ -6283,10 +6304,17 @@ function evaluateExpressionSource(expr, bindingValues, now, opts) {
 		...bindingValues,
 		["now"]: now
 	});
+	const hooks = {
+		...opts?.hooks,
+		now
+	};
 	try {
 		return {
 			ok: true,
-			value: evaluateAst(compiled.parsed.ast, scope, opts)
+			value: evaluateAst(compiled.parsed.ast, scope, {
+				...opts,
+				hooks
+			})
 		};
 	} catch (err) {
 		return {
@@ -10098,6 +10126,277 @@ function kebabToCamel(s) {
 	return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 //#endregion
+//#region src/composition/composition.ts
+/**
+* A COMPOSITION: a device assembled from other devices' state (D659).
+*
+* The data half of the composed-devices spec §1. A composition is stored inside
+* a core block (`CoreBlock.source.kind === 'composition'`) and run by the shared
+* `composer` runner. It names a TARGET and, for each capability of the target, a
+* FIELD MAP: every state field has exactly one source.
+*
+* Sources are keyed by `(addonId, stableId)`, NEVER by numeric device id. A
+* resync reissues numeric ids, and a composition that stored them would be
+* orphaned by the first re-adoption (the linked-devices lesson). A `stableId` is
+* unique only within its owning addon, so the owner travels with it.
+*
+* Later slices EXTEND these unions and do not reshape them. The variants a later
+* slice implements are already in the wire shape, and `validateComposition`
+* refuses them BY NAME until then:
+*   target `existing` → slice 2 · feature `passthrough` → slice 3 ·
+*   `commands` (`forward`) → slice 3 · source `code` → slice 4.
+*/
+/** The owner of every composed device: the `composer` builtin. */
+var COMPOSER_ADDON_ID = "composer";
+/** A composed device's stableId is this prefix plus the block id. */
+var COMPOSED_DEVICE_STABLE_ID_PREFIX = "composed-";
+/** A device with more capabilities than this is two devices. */
+var MAX_COMPOSITION_FEATURES = 16;
+var MAX_COMPOSITION_FIELDS_PER_FEATURE = 32;
+/** Longest snippet a `code` source may carry (slice 4). */
+var MAX_COMPOSITION_CODE_LENGTH = 2e4;
+var CompositionSourceRefSchema = zod.z.object({
+	/** The owning addon; `stableId` is unique only within it. */
+	addonId: zod.z.string().min(1),
+	stableId: zod.z.string().min(1)
+});
+/** One field of one capability of one source device. */
+var CompositionFieldReadSchema = zod.z.object({
+	source: CompositionSourceRefSchema,
+	cap: zod.z.string().min(1),
+	/** Dotted path into the source cap's runtime-state slice. */
+	fieldPath: zod.z.string().min(1)
+});
+/** `from`: copy one source field verbatim. It is also an expression's `from` binding. */
+var CompositionFromSourceSchema = CompositionFieldReadSchema.extend({ kind: zod.z.literal("from") });
+/** A constant binding. No device is read. */
+var CompositionLiteralBindingSchema = zod.z.object({
+	kind: zod.z.literal("literal"),
+	value: zod.z.union([
+		zod.z.string(),
+		zod.z.number(),
+		zod.z.boolean(),
+		zod.z.null()
+	])
+});
+var CompositionBindingSchema = zod.z.discriminatedUnion("kind", [CompositionFromSourceSchema, CompositionLiteralBindingSchema]);
+/**
+* `expression`: a formula over named bindings, in the salvaged expression
+* engine. Validated at parse by the SAME function every other consumer runs,
+* so the editor and the store cannot disagree.
+*/
+var CompositionExpressionSourceSchema = zod.z.object({
+	kind: zod.z.literal("expression"),
+	expr: zod.z.string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
+	bindings: zod.z.record(zod.z.string().regex(EXPRESSION_IDENTIFIER_RE), CompositionBindingSchema)
+}).superRefine((src, ctx) => {
+	const err = validateExpressionSource(src);
+	if (err !== null) ctx.addIssue({
+		code: "custom",
+		message: err,
+		path: ["expr"]
+	});
+});
+/** `code`: RESERVED for slice 4 (own runner, one-way eject). */
+var CompositionCodeSourceSchema = zod.z.object({
+	kind: zod.z.literal("code"),
+	code: zod.z.string().min(1).max(MAX_COMPOSITION_CODE_LENGTH)
+});
+var CompositionFieldSourceSchema = zod.z.discriminatedUnion("kind", [
+	CompositionFromSourceSchema,
+	CompositionExpressionSourceSchema,
+	CompositionCodeSourceSchema
+]);
+/** `forward`: RESERVED for slice 3. Argument mapping arrives there as an additive optional `args`. */
+var CompositionForwardCommandSchema = zod.z.object({
+	kind: zod.z.literal("forward"),
+	source: CompositionSourceRefSchema,
+	cap: zod.z.string().min(1),
+	method: zod.z.string().min(1)
+});
+var CompositionCommandTargetSchema = zod.z.discriminatedUnion("kind", [CompositionForwardCommandSchema, CompositionCodeSourceSchema]);
+var CompositionFieldsFeatureSchema = zod.z.object({
+	kind: zod.z.literal("fields"),
+	cap: zod.z.string().min(1),
+	fields: zod.z.record(zod.z.string().min(1), CompositionFieldSourceSchema).refine((fields) => Object.keys(fields).length <= 32, { message: `at most 32 fields per capability` }),
+	/** RESERVED for slice 3; refused by the validator when non-empty. */
+	commands: zod.z.record(zod.z.string().min(1), CompositionCommandTargetSchema).optional()
+});
+/** RESERVED for slice 3: a media / data-plane cap, whole, from one source. */
+var CompositionPassthroughFeatureSchema = zod.z.object({
+	kind: zod.z.literal("passthrough"),
+	cap: zod.z.string().min(1),
+	source: CompositionSourceRefSchema
+});
+var CompositionFeatureSchema = zod.z.discriminatedUnion("kind", [CompositionFieldsFeatureSchema, CompositionPassthroughFeatureSchema]);
+/**
+* A NEW device. It has no `name` of its own: the block's name IS the device's
+* name (2026-08-08). A second copy here would be a second writer of one string (D62).
+*/
+var CompositionNewTargetSchema = zod.z.object({
+	kind: zod.z.literal("new"),
+	type: zod.z.enum(require_sleep.DeviceType),
+	role: zod.z.enum(require_sleep.DeviceRole).optional()
+});
+/** RESERVED for slice 2: customize an existing device. */
+var CompositionExistingTargetSchema = zod.z.object({
+	kind: zod.z.literal("existing"),
+	device: CompositionSourceRefSchema
+});
+var CompositionTargetSchema = zod.z.discriminatedUnion("kind", [CompositionNewTargetSchema, CompositionExistingTargetSchema]);
+var CompositionSchema = zod.z.object({
+	target: CompositionTargetSchema,
+	features: zod.z.array(CompositionFeatureSchema).min(1).max(16)
+}).superRefine((composition, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	composition.features.forEach((feature, index) => {
+		if (seen.has(feature.cap)) ctx.addIssue({
+			code: "custom",
+			message: `capability \`${feature.cap}\` is composed twice — one feature per capability`,
+			path: [
+				"features",
+				index,
+				"cap"
+			]
+		});
+		seen.add(feature.cap);
+	});
+});
+function compositionSourceKey(ref) {
+	return `${ref.addonId}/${ref.stableId}`;
+}
+function compositionSliceKey(ref, cap) {
+	return `${compositionSourceKey(ref)}#${cap}`;
+}
+function compositionReadKey(read) {
+	return `${compositionSliceKey(read.source, read.cap)}.${read.fieldPath}`;
+}
+function composedDeviceStableId(blockId) {
+	return `${COMPOSED_DEVICE_STABLE_ID_PREFIX}${blockId}`;
+}
+function composedDeviceRef(blockId) {
+	return {
+		addonId: COMPOSER_ADDON_ID,
+		stableId: composedDeviceStableId(blockId)
+	};
+}
+/** Every device field a source reads: `from` is one read, an expression is its `from` bindings. */
+function fieldReads(source) {
+	switch (source.kind) {
+		case "from": return [{
+			source: source.source,
+			cap: source.cap,
+			fieldPath: source.fieldPath
+		}];
+		case "expression": return Object.values(source.bindings).flatMap((binding) => binding.kind === "from" ? [{
+			source: binding.source,
+			cap: binding.cap,
+			fieldPath: binding.fieldPath
+		}] : []);
+		case "code": return [];
+	}
+}
+//#endregion
+//#region src/composition/composition-report.ts
+/**
+* What the validator says about a composition and what the composer says about
+* a running one: the wire shapes the API returns (D659).
+*/
+var CompositionProblemCodeSchema = zod.z.enum([
+	"reserved-variant",
+	"unknown-capability",
+	"not-composable",
+	"wrong-device-type",
+	"has-commands",
+	"unknown-field",
+	"nested-field",
+	"missing-field",
+	"kind-mismatch",
+	"may-be-null",
+	"source-missing",
+	"source-unreadable",
+	"source-capability-missing",
+	"source-field-unknown",
+	"expression-invalid",
+	"cycle",
+	"duplicate-target"
+]);
+/** One refusal, named (D391). `path` points into the composition, e.g. `features[0].fields.celsius`. */
+var CompositionProblemSchema = zod.z.object({
+	code: CompositionProblemCodeSchema,
+	path: zod.z.string(),
+	message: zod.z.string()
+});
+var CompositionFieldKindSchema = zod.z.enum([
+	"string",
+	"number",
+	"boolean",
+	"enum"
+]);
+/** How a field says "unavailable": `null` when its schema allows it, else the device goes offline (D393). */
+var CompositionUnavailableModeSchema = zod.z.enum(["null", "offline"]);
+/**
+* `derived` reads a source · `clock` reads only `now`, recomputed when a sibling
+* field of its cap changes value · `constant` reads nothing, computed once.
+*/
+var CompositionFieldRoleSchema = zod.z.enum([
+	"derived",
+	"clock",
+	"constant"
+]);
+var CompositionFieldPlanSchema = zod.z.object({
+	cap: zod.z.string(),
+	path: zod.z.string(),
+	/** Index into `composition.features` this field's capability came from —
+	*  lets a source/cycle problem name its path as `features[N].fields.<path>`
+	*  (the same convention `planComposition`'s own problems already use). */
+	featureIndex: zod.z.number().int().nonnegative(),
+	kind: CompositionFieldKindSchema,
+	nullable: zod.z.boolean(),
+	required: zod.z.boolean(),
+	unavailable: CompositionUnavailableModeSchema,
+	role: CompositionFieldRoleSchema,
+	source: CompositionFieldSourceSchema,
+	reads: zod.z.array(CompositionFieldReadSchema)
+});
+var CompositionValidationSchema = zod.z.object({
+	ok: zod.z.boolean(),
+	problems: zod.z.array(CompositionProblemSchema),
+	fields: zod.z.array(CompositionFieldPlanSchema)
+});
+/** Mirrors `CoreBlockStatus`, pinned by `core-blocks-source.spec.ts` (Task 11). */
+var CompositionRunStatusSchema = zod.z.enum([
+	"stopped",
+	"starting",
+	"running",
+	"failed"
+]);
+var CompositionFieldStateKindSchema = zod.z.enum([
+	"fresh",
+	"stale",
+	"unavailable"
+]);
+var CompositionFieldStateSchema = zod.z.object({
+	cap: zod.z.string(),
+	path: zod.z.string(),
+	state: CompositionFieldStateKindSchema,
+	/** `null` whenever `state === 'unavailable'`; never a plausible stand-in (D393). */
+	value: zod.z.union([
+		zod.z.string(),
+		zod.z.number(),
+		zod.z.boolean(),
+		zod.z.null()
+	]),
+	reason: zod.z.string().optional()
+});
+var CompositionBlockStateSchema = zod.z.object({
+	blockId: zod.z.string(),
+	deviceId: zod.z.number().nullable(),
+	status: CompositionRunStatusSchema,
+	reason: zod.z.string().optional(),
+	fields: zod.z.array(CompositionFieldStateSchema)
+});
+//#endregion
 //#region src/capabilities/core-blocks.cap.ts
 /**
 * core-blocks — user-authored TypeScript, stored in the kernel and executed in
@@ -10183,6 +10482,30 @@ var CoreBlockInputSchema = zod.z.object({
 	*/
 	integrationId: zod.z.string().optional()
 });
+/**
+* What a block IS (D659). Absent means `code` — every row stored before this
+* union keeps working unchanged.
+*  - `code`: the TypeScript in `code`, compiled and run in its own runner;
+*  - `recipe`: RESERVED (automations), stored shape only; refused at run by name;
+*  - `composition`: declarative, run by the shared `composer`; `code` is `''`.
+*/
+var CoreBlockSourceSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({ kind: zod.z.literal("code") }),
+	zod.z.object({
+		kind: zod.z.literal("recipe"),
+		recipe: AutomationRecipeSchema
+	}),
+	zod.z.object({
+		kind: zod.z.literal("composition"),
+		composition: CompositionSchema
+	})
+]);
+/** The client-authored half of a composition block. No `code`, no placement (hub-only; Phase 7). */
+var CompositionBlockInputSchema = zod.z.object({
+	name: zod.z.string().min(1).max(120),
+	enabled: zod.z.boolean(),
+	composition: CompositionSchema
+});
 /** A stored block. */
 var CoreBlockSchema = CoreBlockInputSchema.extend({
 	id: zod.z.string(),
@@ -10198,8 +10521,46 @@ var CoreBlockSchema = CoreBlockInputSchema.extend({
 	*/
 	lastError: zod.z.string().optional(),
 	/** Ms epoch of the last state change. */
-	lastChangedAt: zod.z.number()
+	lastChangedAt: zod.z.number(),
+	/** What the block is. Absent means `code` (D659). */
+	source: CoreBlockSourceSchema.optional()
 });
+function coreBlockSourceKind(block) {
+	return block.source?.kind ?? "code";
+}
+function coreBlockComposition(block) {
+	return block.source?.kind === "composition" ? block.source.composition : null;
+}
+/** What the composer said, or that it could not be asked. Unknown never looks like absent (D315). */
+var CompositionStateReadSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("answered"),
+	state: CompositionBlockStateSchema.nullable()
+}), zod.z.object({
+	kind: zod.z.literal("unreachable"),
+	error: zod.z.string()
+})]);
+/** A stored composition block and what the composer says about it. */
+var CompositionViewSchema = zod.z.object({
+	block: CoreBlockSchema,
+	state: CompositionStateReadSchema
+});
+/**
+* A read of the stored compositions. `not-loaded` while the `core_blocks`
+* table has not been READ: an empty answer then would make "not yet known"
+* look like "none", and invite the operator to recreate what exists (D315).
+*/
+var CompositionsNotLoadedSchema = zod.z.object({
+	state: zod.z.literal("not-loaded"),
+	reason: zod.z.string()
+});
+var CompositionListReadSchema = zod.z.discriminatedUnion("state", [zod.z.object({
+	state: zod.z.literal("loaded"),
+	views: zod.z.array(CompositionViewSchema)
+}), CompositionsNotLoadedSchema]);
+var CompositionGetReadSchema = zod.z.discriminatedUnion("state", [zod.z.object({
+	state: zod.z.literal("loaded"),
+	view: CompositionViewSchema.nullable()
+}), CompositionsNotLoadedSchema]);
 /** What a compile attempt produced. */
 var CoreBlockCompileResultSchema = zod.z.object({
 	ok: zod.z.boolean(),
@@ -10281,7 +10642,119 @@ var coreBlocksCapability = {
 		getTypeDefs: require_sleep.method(zod.z.object({}), zod.z.object({ libs: zod.z.array(zod.z.object({
 			filePath: zod.z.string(),
 			content: zod.z.string()
-		})) }), { auth: "admin" })
+		})) }), { auth: "admin" }),
+		/**
+		* Create a composition block (D659). VALIDATED first against the live
+		* sources and every stored composition; a refusal names every problem by
+		* path and reason (D391) and stores nothing.
+		*/
+		createComposition: require_sleep.method(zod.z.object({ block: CompositionBlockInputSchema }), zod.z.object({ block: CoreBlockSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		/**
+		* Patch a composition block. A changed `composition` is validated exactly
+		* as on create. `expectedUpdatedAt` is the `updatedAt` the caller READ: a
+		* block changed since is refused by name, never silently overwritten.
+		*/
+		updateComposition: require_sleep.method(zod.z.object({
+			blockId: zod.z.string(),
+			expectedUpdatedAt: zod.z.number(),
+			block: CompositionBlockInputSchema.partial()
+		}), zod.z.object({ block: CoreBlockSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		/** One composition and the composer's state for it, or `not-loaded` (D315). */
+		getComposition: require_sleep.method(zod.z.object({ blockId: zod.z.string() }), CompositionGetReadSchema, { auth: "admin" }),
+		listCompositions: require_sleep.method(zod.z.object({}), CompositionListReadSchema, { auth: "admin" }),
+		/**
+		* Validate without saving — the same verdict the save reaches. A mutation
+		* for its body size; it writes nothing, so its access is `view`.
+		*/
+		validateComposition: require_sleep.method(zod.z.object({
+			composition: CompositionSchema,
+			blockId: zod.z.string().optional()
+		}), CompositionValidationSchema, {
+			kind: "mutation",
+			auth: "admin",
+			access: "view"
+		})
+	}
+};
+//#endregion
+//#region src/capabilities/composer.cap.ts
+/**
+* composer — runs every DECLARATIVE composition (D659).
+*
+* Internal and admin-only: its one caller is `core-blocks`' supervisor, which
+* sends the WHOLE set of composition blocks on every converge (idempotent),
+* and reads their state for the API. Nothing else talks to it.
+*/
+/** The composer's runner id, `resolveRunnerId(decl, 'composer')`; pinned by `composer-manifest.spec.ts`. */
+var COMPOSER_RUNNER_ID = COMPOSER_ADDON_ID;
+var ComposerBlockSchema = zod.z.object({
+	id: zod.z.string().min(1),
+	name: zod.z.string().min(1).max(120),
+	enabled: zod.z.boolean(),
+	updatedAt: zod.z.number(),
+	composition: CompositionSchema
+});
+/**
+* A stored composition row that no longer PARSES — a schema a release
+* tightened, a row written by a newer build. Sent by id so the composer keeps
+* its device as a placeholder and reports the block `failed` naming the parse
+* error. Leaving it out would read, twice, exactly like a delete (D49).
+*/
+var ComposerUnreadableBlockSchema = zod.z.object({
+	id: zod.z.string().min(1),
+	/** The row's stored name column; null when even that is unreadable (the device keeps the name it has). */
+	name: zod.z.string().nullable(),
+	/** The parse error, in the operator's words. */
+	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(),
+	/** False when the `core_blocks` read failed: then nothing may be withdrawn (D49). */
+	storeLoaded: zod.z.boolean(),
+	blocks: zod.z.array(ComposerBlockSchema),
+	/** 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)
+});
+var ComposerBlockVerdictSchema = zod.z.object({
+	blockId: zod.z.string(),
+	status: CompositionRunStatusSchema,
+	reason: zod.z.string().optional()
+});
+var ComposerApplyResultSchema = zod.z.object({
+	blocks: zod.z.array(ComposerBlockVerdictSchema),
+	/**
+	* False when the composer declared and withdrew NOTHING (store not loaded,
+	* 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()
+});
+var composerCapability = {
+	name: "composer",
+	scope: "system",
+	mode: "singleton",
+	internal: true,
+	methods: {
+		/**
+		* Not `apply`: tRPC reserves `apply`, `call` and `then` as router keys, and
+		* `router({})` throws on one — every cap router is built at boot.
+		*/
+		applyBlocks: require_sleep.method(ComposerApplyInputSchema, ComposerApplyResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getStates: require_sleep.method(zod.z.object({ blockIds: zod.z.array(zod.z.string()) }), zod.z.object({ states: zod.z.array(CompositionBlockStateSchema) }), { auth: "admin" })
 	}
 };
 //#endregion
@@ -18851,8 +19324,8 @@ var NcTestResultSchema = zod.z.object({
 	className: zod.z.string().optional(),
 	label: zod.z.string().optional()
 });
-/** The rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts` is the
-*  same union; the template-vars spec pins the two together. `mixed` is DERIVED
+/** The rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts` is
+*  `z.infer` of this schema — one shape, no twin. `mixed` is DERIVED
 *  (a stored system rule whose kinds span families, D637) and never authored. */
 var NcRuleKindSchema = zod.z.enum([
 	"detection",
@@ -44703,6 +45176,720 @@ function createDeviceExtensionProvider(options) {
 	};
 }
 //#endregion
+//#region src/composition/composition-graph.ts
+/**
+* The field graph across every composition, and the cycles in it (D659).
+*
+* A node is ONE field of ONE device (`<addon>/<stableId>#<cap>.<field>`); an
+* edge points from a composed field to each field it reads. A cycle, direct or
+* through another composition, is refused at save by name (spec §2).
+*
+* The graph is built for ONE save: the CANDIDATE composition (the one being
+* validated) plus every STORED composition. The candidate ALWAYS replaces any
+* stored peer that targets the same device, regardless of where that stored
+* peer sits in `stored` — whether a save introduces or removes a cycle must
+* never depend on array order. Two DIFFERENT stored peers that (wrongly)
+* target the same device are corrupted state, not a cycle to resolve by
+* picking one silently; that is refused by name (D391).
+*
+* `findCompositionCycles` reports at least one cycle per cycle-SET (the DFS
+* marks a node `done` after its first expansion) — enough to refuse a save,
+* not to enumerate every elementary cycle through a shared node. A dotted
+* `fieldPath` is matched only as an exact string: a write to `state.value` and
+* a read of `state` would not connect (no nested field writes exist yet).
+*/
+/** Two stored compositions both target the same device — refused by name, never silently resolved. */
+var CompositionGraphError = class extends Error {};
+function peerEdges(peer) {
+	return peer.composition.features.flatMap((feature) => feature.kind !== "fields" ? [] : Object.entries(feature.fields).map(([path, source]) => [compositionReadKey({
+		source: peer.target,
+		cap: feature.cap,
+		fieldPath: path
+	}), fieldReads(source).map(compositionReadKey)]));
+}
+/**
+* Every peer that actually takes part in the graph: each stored peer minus
+* whichever one targets the same device as the candidate (the candidate
+* replaces it — this drop happens before any edge is built, so the
+* candidate's old edges never enter the map to begin with), plus the
+* candidate itself, exactly once. Throws {@link CompositionGraphError} if two
+* DIFFERENT stored peers (neither of them the candidate's own old version)
+* target the same device.
+*/
+function resolvedPeers(candidate, stored) {
+	const candidateKey = compositionSourceKey(candidate.target);
+	const survivors = /* @__PURE__ */ new Map();
+	for (const peer of stored) {
+		const key = compositionSourceKey(peer.target);
+		if (key === candidateKey) continue;
+		if (survivors.has(key)) throw new CompositionGraphError(`two stored compositions both target device \`${key}\` — refusing to build the field graph`);
+		survivors.set(key, peer);
+	}
+	return [...survivors.values(), candidate];
+}
+function compositionEdges(candidate, stored) {
+	const edges = resolvedPeers(candidate, stored).flatMap(peerEdges);
+	return new Map(edges);
+}
+function findCompositionCycles(candidate, stored) {
+	const edges = compositionEdges(candidate, stored);
+	const marks = /* @__PURE__ */ new Map();
+	const found = /* @__PURE__ */ new Map();
+	const visit = (node, stack) => {
+		const mark = marks.get(node);
+		if (mark === "done") return;
+		if (mark === "visiting") {
+			const path = [...stack.slice(stack.indexOf(node)), node];
+			const id = [...new Set(path)].toSorted().join("|");
+			if (!found.has(id)) found.set(id, { path });
+			return;
+		}
+		marks.set(node, "visiting");
+		for (const next of edges.get(node) ?? []) visit(next, [...stack, node]);
+		marks.set(node, "done");
+	};
+	for (const node of edges.keys()) visit(node, []);
+	return [...found.values()];
+}
+//#endregion
+//#region src/composition/evaluate-field.ts
+function describeRead(read) {
+	return `${compositionSourceKey(read.source)} ${read.cap}.${read.fieldPath}`;
+}
+function fromReading(reading, read) {
+	if (reading.state === "unavailable") return {
+		state: "unavailable",
+		value: null,
+		reason: `${describeRead(read)}: ${reading.reason}`,
+		fatal: reading.fatal
+	};
+	return {
+		state: reading.state,
+		value: reading.value,
+		reason: reading.state === "stale" ? `${describeRead(read)}: ${reading.reason}` : null,
+		deadline: null
+	};
+}
+function expressionOutcome(source, read, now) {
+	const values = {};
+	const staleReasons = [];
+	let fatalUnavailable = null;
+	let nonFatalUnavailable = null;
+	for (const [name, binding] of Object.entries(source.bindings)) {
+		if (binding.kind === "literal") {
+			values[name] = binding.value;
+			continue;
+		}
+		const reading = read(binding);
+		if (reading.state === "unavailable") {
+			const outcome = {
+				state: "unavailable",
+				value: null,
+				reason: `binding \`${name}\` (${describeRead(binding)}): ${reading.reason}`,
+				fatal: reading.fatal
+			};
+			if (reading.fatal) {
+				fatalUnavailable = outcome;
+				break;
+			}
+			if (nonFatalUnavailable === null) nonFatalUnavailable = outcome;
+			continue;
+		}
+		values[name] = reading.value;
+		if (reading.state === "stale") staleReasons.push(`\`${name}\`: ${reading.reason}`);
+	}
+	if (fatalUnavailable !== null) return fatalUnavailable;
+	if (nonFatalUnavailable !== null) return nonFatalUnavailable;
+	const deadlines = [];
+	const result = evaluateExpressionSource(source.expr, values, now, { hooks: { noteDeadline: (at) => deadlines.push(at) } });
+	if (!result.ok) return {
+		state: "unavailable",
+		value: null,
+		reason: `the expression failed: ${result.error}`,
+		fatal: false
+	};
+	return {
+		state: staleReasons.length > 0 ? "stale" : "fresh",
+		value: result.value,
+		reason: staleReasons.length > 0 ? staleReasons.join("; ") : null,
+		deadline: deadlines.length > 0 ? Math.min(...deadlines) : null
+	};
+}
+function evaluateCompositionField(input) {
+	const { source } = input;
+	switch (source.kind) {
+		case "from": return fromReading(input.read(source), source);
+		case "expression": return expressionOutcome(source, input.read, input.now);
+		case "code": return {
+			state: "unavailable",
+			value: null,
+			reason: "code fields are not runnable in the composer — they arrive in slice 4",
+			fatal: true
+		};
+	}
+}
+//#endregion
+//#region src/composition/examples.ts
+/**
+* The worked composed-device example: a ROOM. Temperature is the average of N
+* sensors, and occupancy is any motion within the last five minutes. It is the
+* slice-1 acceptance case and the template an author starts from (Phase 4
+* §4 item 4 asked for one).
+*/
+var ROOM_OCCUPANCY_WINDOW_MS = 3e5;
+var ROOM_EXAMPLE_TEMPERATURE_SOURCES = [
+	{
+		addonId: "provider-homeassistant",
+		stableId: "sensor.living_room_temperature"
+	},
+	{
+		addonId: "provider-homeassistant",
+		stableId: "sensor.sofa_temperature"
+	},
+	{
+		addonId: "provider-homeassistant",
+		stableId: "sensor.window_temperature"
+	}
+];
+var ROOM_EXAMPLE_MOTION_SOURCES = [{
+	addonId: "provider-homeassistant",
+	stableId: "binary_sensor.living_room_motion"
+}, {
+	addonId: "provider-homeassistant",
+	stableId: "binary_sensor.living_room_presence"
+}];
+function from(source, cap, fieldPath) {
+	return {
+		kind: "from",
+		source,
+		cap,
+		fieldPath
+	};
+}
+function named(prefix, sources, cap, fieldPath) {
+	return Object.fromEntries(sources.map((s, i) => [`${prefix}${i + 1}`, from(s, cap, fieldPath)]));
+}
+function roomCompositionExample(input) {
+	const t = named("t", input.temperatureSources, "temperature-sensor", "celsius");
+	const f = named("f", input.temperatureSources, "temperature-sensor", "lastFetchedAt");
+	const d = named("d", input.motionSources, "motion", "detected");
+	const m = named("m", input.motionSources, "motion", "lastDetectedAt");
+	const windows = Object.keys(m).map((name) => `within(${name}, ${input.occupancyWindowMs})`);
+	return CompositionSchema.parse({
+		target: {
+			kind: "new",
+			type: require_sleep.DeviceType.Sensor
+		},
+		features: [{
+			kind: "fields",
+			cap: "temperature-sensor",
+			fields: {
+				celsius: {
+					kind: "expression",
+					expr: `round(avg(${Object.keys(t).join(", ")}), 1)`,
+					bindings: t
+				},
+				lastFetchedAt: {
+					kind: "expression",
+					expr: `max(${Object.keys(f).join(", ")})`,
+					bindings: f
+				}
+			}
+		}, {
+			kind: "fields",
+			cap: "binary",
+			fields: {
+				on: {
+					kind: "expression",
+					expr: `any(${[...Object.keys(d), ...windows].join(", ")})`,
+					bindings: {
+						...d,
+						...m
+					}
+				},
+				lastChangedAt: {
+					kind: "expression",
+					expr: "now",
+					bindings: {}
+				}
+			}
+		}]
+	});
+}
+//#endregion
+//#region src/composition/expression-kinds.ts
+var NUMBER = {
+	kind: "fixed",
+	result: ["number"]
+};
+var BOOLEAN = {
+	kind: "fixed",
+	result: ["boolean"]
+};
+/** One rule per builtin. `expression-kinds.spec.ts` fails for a builtin missing here. */
+var BUILTIN_RESULT_KINDS = Object.freeze({
+	min: NUMBER,
+	max: NUMBER,
+	abs: NUMBER,
+	floor: NUMBER,
+	ceil: NUMBER,
+	sqrt: NUMBER,
+	round: NUMBER,
+	pow: NUMBER,
+	clamp: NUMBER,
+	avg: NUMBER,
+	sum: NUMBER,
+	age: NUMBER,
+	convert: NUMBER,
+	coalesce: { kind: "coalesce" },
+	any: BOOLEAN,
+	all: BOOLEAN,
+	within: BOOLEAN,
+	latest: {
+		kind: "fixed",
+		result: ["number", "null"]
+	}
+});
+var KindInferenceError = class extends Error {};
+function kindOfValue(value) {
+	if (value === null) return "null";
+	if (typeof value === "number") return "number";
+	if (typeof value === "string") return "string";
+	return "boolean";
+}
+function only(kind) {
+	return new Set([kind]);
+}
+function union(...sets) {
+	return new Set(sets.flatMap((s) => [...s]));
+}
+function withoutNull(set) {
+	return new Set([...set].filter((k) => k !== "null"));
+}
+function binaryKinds(op, left, right) {
+	if (op === "+") {
+		const all = [...left, ...right];
+		if (all.every((k) => k === "string")) return only("string");
+		if (all.every((k) => k === "number")) return only("number");
+		return new Set(["number", "string"]);
+	}
+	if (op === "-" || op === "*" || op === "/" || op === "%") return only("number");
+	return only("boolean");
+}
+/** "exactly N" / "at least N" / "N–M", for an arity refusal that says what IS allowed. */
+function arityRange(builtin) {
+	if (builtin.minArgs === builtin.maxArgs) return `exactly ${builtin.minArgs}`;
+	if (builtin.maxArgs === Number.POSITIVE_INFINITY) return `at least ${builtin.minArgs}`;
+	return `${builtin.minArgs}–${builtin.maxArgs}`;
+}
+function callKinds(callee, args) {
+	const builtin = EXPRESSION_BUILTINS[callee];
+	if (builtin !== void 0 && (args.length < builtin.minArgs || args.length > builtin.maxArgs)) throw new KindInferenceError(`${callee}: wrong number of arguments (${args.length}); expected ${arityRange(builtin)}`);
+	const rule = BUILTIN_RESULT_KINDS[callee];
+	if (rule === void 0) throw new KindInferenceError(`no result-kind rule for builtin '${callee}'`);
+	if (rule.kind === "fixed") return new Set(rule.result);
+	const nonNull = union(...args.map(withoutNull));
+	return args.every((a) => a.has("null")) ? union(nonNull, only("null")) : nonNull;
+}
+function kindsOf(node, bindings) {
+	switch (node.kind) {
+		case "literal": return only(kindOfValue(node.value));
+		case "identifier": {
+			if (node.name === "now") return only("number");
+			const bound = bindings.get(node.name);
+			if (bound === void 0) throw new KindInferenceError(`unbound identifier '${node.name}'`);
+			return bound;
+		}
+		case "unary": return only(node.op === "!" ? "boolean" : "number");
+		case "binary": return binaryKinds(node.op, kindsOf(node.left, bindings), kindsOf(node.right, bindings));
+		case "logical": return union(kindsOf(node.left, bindings), kindsOf(node.right, bindings));
+		case "conditional": return union(kindsOf(node.consequent, bindings), kindsOf(node.alternate, bindings));
+		case "call": return callKinds(node.callee, node.args.map((a) => kindsOf(a, bindings)));
+	}
+}
+function inferExpressionKinds(input) {
+	const compiled = compileExpressionSafe(input.expr);
+	if (!compiled.ok) return {
+		ok: false,
+		error: compiled.error
+	};
+	try {
+		return {
+			ok: true,
+			kinds: kindsOf(compiled.parsed.ast, input.bindingKinds)
+		};
+	} catch (err) {
+		if (err instanceof KindInferenceError) return {
+			ok: false,
+			error: err.message
+		};
+		throw err;
+	}
+}
+//#endregion
+//#region src/device/schema-fields.ts
+/** Unwrap ZodNullable / ZodOptional / ZodDefault wrappers to reach the inner type.
+*  Zod v4 exposes `.unwrap()` on all three wrapper classes. */
+function unwrapSchema(schema) {
+	let s = schema;
+	while (s instanceof zod.z.ZodNullable || s instanceof zod.z.ZodOptional || s instanceof zod.z.ZodDefault) s = s.unwrap();
+	return s;
+}
+function leafKind(schema) {
+	const s = unwrapSchema(schema);
+	if (s instanceof zod.z.ZodEnum) return {
+		kind: "enum",
+		enumValues: s.options
+	};
+	if (s instanceof zod.z.ZodNumber) return { kind: "number" };
+	if (s instanceof zod.z.ZodString) return { kind: "string" };
+	if (s instanceof zod.z.ZodBoolean) return { kind: "boolean" };
+	return null;
+}
+/** Walk a cap status schema into flat wireable leaf fields (dotted paths).
+*  Recurses into nested ZodObject (unwrapping nullable/optional/default first),
+*  so fields with null live values are still offered. Arrays / unknown shapes
+*  are skipped — never throws. */
+function enumerateSchemaFields(schema, prefix = "") {
+	const root = unwrapSchema(schema);
+	if (!(root instanceof zod.z.ZodObject)) return [];
+	const out = [];
+	const shape = root.shape;
+	for (const [key, field] of Object.entries(shape)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		const inner = unwrapSchema(field);
+		if (inner instanceof zod.z.ZodObject) {
+			out.push(...enumerateSchemaFields(inner, path));
+			continue;
+		}
+		const leaf = leafKind(field);
+		if (leaf) out.push({
+			path,
+			kind: leaf.kind,
+			...leaf.enumValues ? { enumValues: leaf.enumValues } : {}
+		});
+	}
+	return out;
+}
+/** Enumerate the per-item wireable fields of an item-array cap (see
+*  `CapabilityStatusItemArray`): the item schema's leaf fields, minus the
+*  `keyField` (the key comes from the link's `itemKey`, never from a wired
+*  source), each tagged `item: true` so the authoring UI collects an
+*  `itemKey` alongside the field. Never throws. */
+function enumerateItemArrayFields(itemArray) {
+	return enumerateSchemaFields(itemArray.itemSchema).filter((f) => f.path !== itemArray.keyField).map((f) => ({
+		...f,
+		item: true
+	}));
+}
+//#endregion
+//#region src/composition/state-fields.ts
+/**
+* What a capability's state field IS: kind, nullability, whether required. The
+* validator needs nullability, which `enumerateSchemaFields` does not report,
+* and that decides a field's unavailable mode (D393).
+*/
+function fieldAt(schema, path) {
+	let current = schema;
+	for (const segment of path.split(".")) {
+		const container = unwrapSchema(current);
+		if (!(container instanceof zod.z.ZodObject)) return null;
+		const next = container.shape[segment];
+		if (!(next instanceof zod.z.ZodType)) return null;
+		current = next;
+	}
+	return current;
+}
+function describeStateField(schema, path) {
+	const leaf = enumerateSchemaFields(schema).find((f) => f.path === path);
+	if (leaf === void 0) return null;
+	const field = fieldAt(schema, path);
+	if (field === null) return null;
+	return {
+		path,
+		kind: leaf.kind,
+		nullable: field.safeParse(null).success,
+		required: !field.safeParse(void 0).success,
+		...leaf.enumValues === void 0 ? {} : { enumValues: leaf.enumValues }
+	};
+}
+function describeTopLevelStateFields(schema) {
+	return new Map(enumerateSchemaFields(schema).filter((f) => !f.path.includes(".")).flatMap((f) => {
+		const described = describeStateField(schema, f.path);
+		return described === null ? [] : [[f.path, described]];
+	}));
+}
+/** Top-level keys a value MUST carry: those whose schema refuses `undefined`. */
+function requiredTopLevelKeys(schema) {
+	const root = unwrapSchema(schema);
+	if (!(root instanceof zod.z.ZodObject)) return [];
+	return Object.entries(root.shape).flatMap(([key, field]) => field instanceof zod.z.ZodType && !field.safeParse(void 0).success ? [key] : []);
+}
+//#endregion
+//#region src/composition/validate-composition.ts
+function buildCapabilityLookup(defs) {
+	const byName = new Map(defs.map((d) => [d.name, d]));
+	return (capName) => byName.get(capName) ?? null;
+}
+/** Caps every `BaseDevice` registers on itself; a second registration throws. */
+var BASE_DEVICE_CAPS = new Set(["device-status", "feature-probe"]);
+var PENDING_SELF = {
+	addonId: COMPOSER_ADDON_ID,
+	stableId: `${COMPOSED_DEVICE_STABLE_ID_PREFIX}(unsaved)`
+};
+function problem(code, path, message) {
+	return {
+		code,
+		path,
+		message
+	};
+}
+function refused(...problems) {
+	return {
+		problems,
+		fields: []
+	};
+}
+function readKinds(read, lookupCap) {
+	const def = lookupCap(read.cap);
+	const schema = def?.runtimeState ?? def?.status?.schema;
+	if (def === null || schema === void 0) return {
+		ok: false,
+		code: "source-field-unknown",
+		message: `no capability \`${read.cap}\` with state to read`
+	};
+	const field = describeStateField(schema, read.fieldPath);
+	if (field === null) return {
+		ok: false,
+		code: "source-field-unknown",
+		message: `\`${read.cap}\` has no field \`${read.fieldPath}\``
+	};
+	const base = field.kind === "enum" ? "string" : field.kind;
+	return {
+		ok: true,
+		kinds: new Set(field.nullable ? [base, "null"] : [base])
+	};
+}
+function sourceKinds(source, lookupCap) {
+	if (source.kind === "from") return readKinds(source, lookupCap);
+	if (source.kind === "code") return {
+		ok: false,
+		code: "reserved-variant",
+		message: "code fields arrive in slice 4"
+	};
+	const bindingKinds = /* @__PURE__ */ new Map();
+	for (const [name, binding] of Object.entries(source.bindings)) {
+		if (binding.kind === "literal") {
+			bindingKinds.set(name, new Set([kindOfValue(binding.value)]));
+			continue;
+		}
+		const kinds = readKinds(binding, lookupCap);
+		if (!kinds.ok) return {
+			...kinds,
+			message: `binding \`${name}\`: ${kinds.message}`
+		};
+		bindingKinds.set(name, kinds.kinds);
+	}
+	const inferred = inferExpressionKinds({
+		expr: source.expr,
+		bindingKinds
+	});
+	return inferred.ok ? {
+		ok: true,
+		kinds: inferred.kinds
+	} : {
+		ok: false,
+		code: "expression-invalid",
+		message: inferred.error
+	};
+}
+function compatibility(cap, target, kinds, at) {
+	const allowed = target.kind === "enum" ? "string" : target.kind;
+	const offending = [...kinds].filter((k) => k !== "null" && k !== allowed);
+	const problems = [];
+	if (offending.length > 0) problems.push(problem("kind-mismatch", at, `\`${cap}.${target.path}\` is a ${target.kind}; this source can produce ${offending.join(" or ")}`));
+	if (kinds.has("null") && !target.nullable) problems.push(problem("may-be-null", at, `\`${cap}.${target.path}\` cannot be null and this source can produce null — wrap it in coalesce(…) or pick a non-null source`));
+	return problems;
+}
+/**
+* A string a source produces WITHOUT reading any device — a field-level
+* `expression` source whose compiled AST is a bare string literal (`"red"`,
+* never `a` or `a + "x"`). Anything else that can only produce `'string'` at
+* the kind level (a `from` read of an enum-typed source field, a computed
+* expression) is NOT checked against the target's `enumValues` here: the
+* kind inference already collapsed it to the coarse `'string'` kind, losing
+* whichever enum it actually came from, so membership can only be judged at
+* write time against the runtime-state schema. Known limitation — see the
+* fix report for Task 6 round 1.
+*/
+function literalStringValue(source) {
+	if (source.kind !== "expression") return null;
+	const compiled = compileExpressionSafe(source.expr);
+	if (!compiled.ok) return null;
+	const ast = compiled.parsed.ast;
+	return ast.kind === "literal" && typeof ast.value === "string" ? ast.value : null;
+}
+/**
+* An enum target whose source is a save-time-KNOWN string literal outside its
+* `enumValues` is refused now rather than left to fail the write later. A
+* dynamic source (a `from` read, a non-literal expression) is left to
+* runtime — see {@link literalStringValue}.
+*/
+function enumLiteralProblem(cap, target, source, at) {
+	if (target.kind !== "enum" || target.enumValues === void 0) return null;
+	const value = literalStringValue(source);
+	if (value === null || target.enumValues.includes(value)) return null;
+	const allowed = target.enumValues.map((v) => `\`${v}\``).join(", ");
+	return problem("kind-mismatch", at, `\`${cap}.${target.path}\` accepts only ${allowed}; this source is the literal \`${value}\``);
+}
+function roleOf(source) {
+	if (source.kind !== "expression") return "derived";
+	if (fieldReads(source).length > 0) return "derived";
+	const compiled = compileExpressionSafe(source.expr);
+	return compiled.ok && compiled.parsed.identifiers.has("now") ? "clock" : "constant";
+}
+function planFeature(feature, featureIndex, target, lookupCap) {
+	const at = `features[${featureIndex}]`;
+	const def = lookupCap(feature.cap);
+	if (def === null) return refused(problem("unknown-capability", `${at}.cap`, `no capability is named \`${feature.cap}\``));
+	if (BASE_DEVICE_CAPS.has(def.name)) return refused(problem("not-composable", `${at}.cap`, `\`${def.name}\` is registered by every device itself — it cannot be composed`));
+	const state = def.runtimeState;
+	if (def.scope !== "device" || state === void 0) return refused(problem("not-composable", `${at}.cap`, `\`${def.name}\` has no per-device state to compose`));
+	const capProblems = [];
+	if (def.deviceTypes !== void 0 && !def.deviceTypes.includes(target.type)) capProblems.push(problem("wrong-device-type", `${at}.cap`, `\`${def.name}\` is not offered on a \`${target.type}\` device (it allows ${def.deviceTypes.join(", ")})`));
+	const served = Object.entries(def.methods).filter(([, m]) => m.systemOnly !== true).map(([name]) => `\`${name}\``);
+	if (served.length > 0) capProblems.push(problem("has-commands", `${at}.cap`, `\`${def.name}\` has ${served.join(", ")}, which a composed device cannot serve until commands arrive (slice 3)`));
+	if (feature.commands !== void 0 && Object.keys(feature.commands).length > 0) capProblems.push(problem("reserved-variant", `${at}.commands`, "commands (`forward`) arrive in slice 3"));
+	const targetFields = describeTopLevelStateFields(state);
+	for (const key of requiredTopLevelKeys(state)) if (!targetFields.has(key)) capProblems.push(problem("not-composable", `${at}.fields`, `\`${def.name}.${key}\` is not a scalar — nested fields arrive in a later slice`));
+	else if (!(key in feature.fields)) capProblems.push(problem("missing-field", `${at}.fields.${key}`, `\`${def.name}.${key}\` is required and has no source`));
+	const perField = Object.entries(feature.fields).map(([path, source]) => {
+		const fieldAt = `${at}.fields.${path}`;
+		if (path.includes(".")) return refused(problem("nested-field", fieldAt, `\`${path}\` is nested — nested fields arrive in a later slice`));
+		const tf = targetFields.get(path);
+		if (tf === void 0) return refused(problem("unknown-field", fieldAt, `\`${def.name}\` has no field \`${path}\``));
+		const kinds = sourceKinds(source, lookupCap);
+		if (!kinds.ok) return refused(problem(kinds.code, fieldAt, kinds.message));
+		const plan = {
+			cap: def.name,
+			path,
+			featureIndex,
+			kind: tf.kind,
+			nullable: tf.nullable,
+			required: tf.required,
+			unavailable: tf.nullable ? "null" : "offline",
+			role: roleOf(source),
+			source,
+			reads: [...fieldReads(source)]
+		};
+		const enumProblem = enumLiteralProblem(def.name, tf, source, fieldAt);
+		return {
+			problems: [...compatibility(def.name, tf, kinds.kinds, fieldAt), ...enumProblem === null ? [] : [enumProblem]],
+			fields: [plan]
+		};
+	});
+	return {
+		problems: [...capProblems, ...perField.flatMap((r) => r.problems)],
+		fields: perField.flatMap((r) => r.fields)
+	};
+}
+function planComposition(composition, lookupCap) {
+	const target = composition.target;
+	if (target.kind === "existing") return refused(problem("reserved-variant", "target", "an EXISTING device as the target arrives in slice 2 — this release composes new devices only"));
+	const results = composition.features.map((feature, index) => {
+		const at = `features[${index}]`;
+		if (feature.kind === "passthrough") return refused(problem("reserved-variant", at, `whole-capability passthrough of \`${feature.cap}\` arrives in slice 3`));
+		return planFeature(feature, index, target, lookupCap);
+	});
+	return {
+		problems: results.flatMap((r) => r.problems),
+		fields: results.flatMap((r) => r.fields)
+	};
+}
+function compositionSourceRefs(composition) {
+	const refs = composition.features.flatMap((f) => f.kind === "fields" ? Object.values(f.fields).flatMap(fieldReads).map((r) => r.source) : []);
+	return [...new Map(refs.map((r) => [compositionSourceKey(r), r])).values()];
+}
+function sourceProblems(fields, ctx) {
+	const selfKey = ctx.self === null ? null : compositionSourceKey(ctx.self);
+	return fields.flatMap((field) => field.reads.flatMap((read) => {
+		const at = `features[${field.featureIndex}].fields.${field.path}`;
+		const key = compositionSourceKey(read.source);
+		if (key === selfKey) return fields.some((f) => f.cap === read.cap && f.path === read.fieldPath) ? [] : [problem("source-field-unknown", at, `this device has no composed field \`${read.cap}.${read.fieldPath}\``)];
+		const desc = ctx.sources.get(key);
+		if (desc === void 0 || desc.kind === "unreadable") return [problem("source-unreadable", at, `could not read source \`${key}\` (${desc === void 0 ? "it was not read" : desc.error}) — the save is refused rather than stored unchecked`)];
+		if (desc.kind === "absent") return [problem("source-missing", at, `source \`${key}\` does not exist`)];
+		if (!desc.caps.has(read.cap)) return [problem("source-capability-missing", at, `source \`${key}\` (device ${desc.deviceId}) has no \`${read.cap}\``)];
+		return [];
+	}));
+}
+/**
+* A cycle's node keys are `compositionReadKey` strings:
+* `<addonId>/<stableId>#<cap>.<fieldPath>`. When a node belongs to the
+* CANDIDATE itself (this composition being saved), pull its `cap`/`fieldPath`
+* back out so the refusal can point at that exact field, matching the
+* documented `features[N].fields.<path>` convention — slice 1 has no nested
+* field writes, so splitting `rest` on the FIRST `.` is exact.
+*/
+function candidateFieldOfNode(nodeKey, candidateKey) {
+	const prefix = `${candidateKey}#`;
+	if (!nodeKey.startsWith(prefix)) return null;
+	const rest = nodeKey.slice(prefix.length);
+	const dot = rest.indexOf(".");
+	if (dot === -1) return null;
+	return {
+		cap: rest.slice(0, dot),
+		fieldPath: rest.slice(dot + 1)
+	};
+}
+/** The first node of a cycle's path that is one of THIS composition's own
+*  planned fields, as a documented-convention path; `'features'` when the
+*  cycle runs entirely through other stored compositions. */
+function cyclePath(nodePath, candidateKey, fields) {
+	for (const nodeKey of nodePath) {
+		const hit = candidateFieldOfNode(nodeKey, candidateKey);
+		if (hit === null) continue;
+		const field = fields.find((f) => f.cap === hit.cap && f.path === hit.fieldPath);
+		if (field !== void 0) return `features[${field.featureIndex}].fields.${field.path}`;
+	}
+	return "features";
+}
+/**
+* Cycle check runs against the CANDIDATE (this composition, targeting `self`
+* when it already exists, else a placeholder that cannot collide with a
+* stored target) plus every OTHER stored composition. Two stored peers that
+* (wrongly) share a target are corrupted state — `findCompositionCycles`
+* throws `CompositionGraphError` rather than silently picking one, and this
+* is refused BY NAME (D391) instead of escaping as an uncaught throw.
+*/
+function cycleProblems(composition, ctx, fields) {
+	const candidate = {
+		target: ctx.self ?? PENDING_SELF,
+		composition
+	};
+	const candidateKey = compositionSourceKey(candidate.target);
+	try {
+		return findCompositionCycles(candidate, ctx.peers).map((c) => problem("cycle", cyclePath(c.path, candidateKey, fields), `a field reads itself: ${c.path.join(" → ")}`));
+	} catch (err) {
+		if (err instanceof CompositionGraphError) return [problem("duplicate-target", "features", err.message)];
+		throw err;
+	}
+}
+function validateComposition(composition, ctx) {
+	const plan = planComposition(composition, ctx.lookupCap);
+	const cycles = cycleProblems(composition, ctx, plan.fields);
+	const problems = [
+		...plan.problems,
+		...sourceProblems(plan.fields, ctx),
+		...cycles
+	];
+	return {
+		ok: problems.length === 0,
+		problems,
+		fields: [...plan.fields]
+	};
+}
+//#endregion
 //#region src/catalogs/device-state-vocabulary.ts
 /**
 * Most specific first. Extending this list is how a new device kind becomes
@@ -48855,62 +50042,6 @@ function createRuntimeStateBridge(params) {
 	};
 }
 //#endregion
-//#region src/device/schema-fields.ts
-/** Unwrap ZodNullable / ZodOptional / ZodDefault wrappers to reach the inner type.
-*  Zod v4 exposes `.unwrap()` on all three wrapper classes. */
-function unwrap(schema) {
-	let s = schema;
-	while (s instanceof zod.z.ZodNullable || s instanceof zod.z.ZodOptional || s instanceof zod.z.ZodDefault) s = s.unwrap();
-	return s;
-}
-function leafKind(schema) {
-	const s = unwrap(schema);
-	if (s instanceof zod.z.ZodEnum) return {
-		kind: "enum",
-		enumValues: s.options
-	};
-	if (s instanceof zod.z.ZodNumber) return { kind: "number" };
-	if (s instanceof zod.z.ZodString) return { kind: "string" };
-	if (s instanceof zod.z.ZodBoolean) return { kind: "boolean" };
-	return null;
-}
-/** Walk a cap status schema into flat wireable leaf fields (dotted paths).
-*  Recurses into nested ZodObject (unwrapping nullable/optional/default first),
-*  so fields with null live values are still offered. Arrays / unknown shapes
-*  are skipped — never throws. */
-function enumerateSchemaFields(schema, prefix = "") {
-	const root = unwrap(schema);
-	if (!(root instanceof zod.z.ZodObject)) return [];
-	const out = [];
-	const shape = root.shape;
-	for (const [key, field] of Object.entries(shape)) {
-		const path = prefix ? `${prefix}.${key}` : key;
-		const inner = unwrap(field);
-		if (inner instanceof zod.z.ZodObject) {
-			out.push(...enumerateSchemaFields(inner, path));
-			continue;
-		}
-		const leaf = leafKind(field);
-		if (leaf) out.push({
-			path,
-			kind: leaf.kind,
-			...leaf.enumValues ? { enumValues: leaf.enumValues } : {}
-		});
-	}
-	return out;
-}
-/** Enumerate the per-item wireable fields of an item-array cap (see
-*  `CapabilityStatusItemArray`): the item schema's leaf fields, minus the
-*  `keyField` (the key comes from the link's `itemKey`, never from a wired
-*  source), each tagged `item: true` so the authoring UI collects an
-*  `itemKey` alongside the field. Never throws. */
-function enumerateItemArrayFields(itemArray) {
-	return enumerateSchemaFields(itemArray.itemSchema).filter((f) => f.path !== itemArray.keyField).map((f) => ({
-		...f,
-		item: true
-	}));
-}
-//#endregion
 //#region src/device/system-mirror.ts
 var STATE_CHANGED_CATEGORY = "device.state-changed";
 var BINDING_CHANGED_CATEGORY = "capability.binding-changed";
@@ -49803,6 +50934,7 @@ var CAPABILITY_NAMES = {
 	carbonMonoxide: "carbon-monoxide",
 	climateControl: "climate-control",
 	color: "color",
+	composer: "composer",
 	connectionTest: "connection-test",
 	connectivity: "connectivity",
 	consumables: "consumables",
@@ -50063,6 +51195,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "color",
 		name: "color"
 	},
+	{
+		key: "composer",
+		name: "composer"
+	},
 	{
 		key: "connectionTest",
 		name: "connection-test"
@@ -50622,6 +51758,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	carbonMonoxideCapability,
 	climateControlCapability,
 	colorCapability,
+	composerCapability,
 	connectionTestCapability,
 	connectivityCapability,
 	consumablesCapability,
@@ -51697,6 +52834,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"composer.applyBlocks": {
+		capName: "composer",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"composer.getStates": {
+		capName: "composer",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"connectionTest.describeTest": {
 		capName: "connection-test",
 		capScope: "system",
@@ -51757,6 +52906,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"coreBlocks.createComposition": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"coreBlocks.delete": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -51769,6 +52924,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"coreBlocks.getComposition": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"coreBlocks.getTypeDefs": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -51781,6 +52942,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"coreBlocks.listCompositions": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"coreBlocks.restart": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -51799,6 +52966,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"coreBlocks.updateComposition": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"coreBlocks.validateComposition": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"cover.close": {
 		capName: "cover",
 		capScope: "device",
@@ -57858,6 +59037,7 @@ var KNOWN_CAP_NAMES = [
 	"carbon-monoxide",
 	"climate-control",
 	"color",
+	"composer",
 	"connection-test",
 	"connectivity",
 	"consumables",
@@ -58095,6 +59275,7 @@ var SYSTEM_CAP_NAMES = [
 	"auth-provider",
 	"backup",
 	"broker",
+	"composer",
 	"connection-test",
 	"core-blocks",
 	"custom-model-registry",
@@ -60920,7 +62101,12 @@ function createSystemProxy(api) {
 			setEnabled: (input) => dispatch("coreBlocks", "setEnabled", "mutation", input),
 			restart: (input) => dispatch("coreBlocks", "restart", "mutation", input),
 			compile: (input) => dispatch("coreBlocks", "compile", "mutation", input),
-			getTypeDefs: (input) => dispatch("coreBlocks", "getTypeDefs", "query", input)
+			getTypeDefs: (input) => dispatch("coreBlocks", "getTypeDefs", "query", input),
+			createComposition: (input) => dispatch("coreBlocks", "createComposition", "mutation", input),
+			updateComposition: (input) => dispatch("coreBlocks", "updateComposition", "mutation", input),
+			getComposition: (input) => dispatch("coreBlocks", "getComposition", "query", input),
+			listCompositions: (input) => dispatch("coreBlocks", "listCompositions", "query", input),
+			validateComposition: (input) => dispatch("coreBlocks", "validateComposition", "mutation", input)
 		},
 		decoder: {
 			supportsCodec: (input) => dispatch("decoder", "supportsCodec", "query", input),
@@ -67157,11 +68343,13 @@ exports.AutomationControlStatusSchema = AutomationControlStatusSchema;
 exports.AutomationRecipeSchema = AutomationRecipeSchema;
 exports.AutomationTriggerSchema = AutomationTriggerSchema;
 exports.AvailableIntegrationTypeSchema = AvailableIntegrationTypeSchema;
+exports.BASE_DEVICE_CAPS = BASE_DEVICE_CAPS;
 exports.BASE_LIVE_EGRESS_PROFILE = BASE_LIVE_EGRESS_PROFILE;
 exports.BATTERY_DEVICE_PROFILE = BATTERY_DEVICE_PROFILE;
 exports.BATTERY_UNREACHABLE_AFTER_MS = BATTERY_UNREACHABLE_AFTER_MS;
 exports.BIRTH_DECISION_DEFAULT_LIMIT = BIRTH_DECISION_DEFAULT_LIMIT;
 exports.BOOT_RECOVERY_BACKOFF_MS = require_sleep.BOOT_RECOVERY_BACKOFF_MS;
+exports.BUILTIN_RESULT_KINDS = BUILTIN_RESULT_KINDS;
 exports.BackgroundRunRegistry = BackgroundRunRegistry;
 exports.BacklightModeSchema = BacklightModeSchema;
 exports.BackupDestinationInfoSchema = BackupDestinationInfoSchema;
@@ -67229,6 +68417,9 @@ exports.CLUSTER_MODEL_SECTION_ID = CLUSTER_MODEL_SECTION_ID;
 exports.CLUSTER_STEP_SETTING_FIELDS = CLUSTER_STEP_SETTING_FIELDS;
 exports.COCO_80_LABELS = COCO_80_LABELS;
 exports.COCO_TO_MACRO = COCO_TO_MACRO;
+exports.COMPOSED_DEVICE_STABLE_ID_PREFIX = COMPOSED_DEVICE_STABLE_ID_PREFIX;
+exports.COMPOSER_ADDON_ID = COMPOSER_ADDON_ID;
+exports.COMPOSER_RUNNER_ID = COMPOSER_RUNNER_ID;
 exports.CONNECTION_TEST_TIMEOUT_MS = CONNECTION_TEST_TIMEOUT_MS;
 exports.CONTAINER_CHILD_PRIORITY = CONTAINER_CHILD_PRIORITY;
 exports.CORE_BLOCKS_ADDON_ID = CORE_BLOCKS_ADDON_ID;
@@ -67297,6 +68488,45 @@ exports.ClusterModelChoiceSchema = ClusterModelChoiceSchema;
 exports.CollectionColumnSchema = CollectionColumnSchema;
 exports.CollectionIndexSchema = CollectionIndexSchema;
 exports.ColorStatusSchema = ColorStatusSchema;
+exports.ComposerApplyInputSchema = ComposerApplyInputSchema;
+exports.ComposerApplyResultSchema = ComposerApplyResultSchema;
+exports.ComposerBlockSchema = ComposerBlockSchema;
+exports.ComposerBlockVerdictSchema = ComposerBlockVerdictSchema;
+exports.ComposerUnreadableBlockSchema = ComposerUnreadableBlockSchema;
+exports.CompositionBindingSchema = CompositionBindingSchema;
+exports.CompositionBlockInputSchema = CompositionBlockInputSchema;
+exports.CompositionBlockStateSchema = CompositionBlockStateSchema;
+exports.CompositionCodeSourceSchema = CompositionCodeSourceSchema;
+exports.CompositionCommandTargetSchema = CompositionCommandTargetSchema;
+exports.CompositionExistingTargetSchema = CompositionExistingTargetSchema;
+exports.CompositionExpressionSourceSchema = CompositionExpressionSourceSchema;
+exports.CompositionFeatureSchema = CompositionFeatureSchema;
+exports.CompositionFieldKindSchema = CompositionFieldKindSchema;
+exports.CompositionFieldPlanSchema = CompositionFieldPlanSchema;
+exports.CompositionFieldReadSchema = CompositionFieldReadSchema;
+exports.CompositionFieldRoleSchema = CompositionFieldRoleSchema;
+exports.CompositionFieldSourceSchema = CompositionFieldSourceSchema;
+exports.CompositionFieldStateKindSchema = CompositionFieldStateKindSchema;
+exports.CompositionFieldStateSchema = CompositionFieldStateSchema;
+exports.CompositionFieldsFeatureSchema = CompositionFieldsFeatureSchema;
+exports.CompositionForwardCommandSchema = CompositionForwardCommandSchema;
+exports.CompositionFromSourceSchema = CompositionFromSourceSchema;
+exports.CompositionGetReadSchema = CompositionGetReadSchema;
+exports.CompositionGraphError = CompositionGraphError;
+exports.CompositionListReadSchema = CompositionListReadSchema;
+exports.CompositionLiteralBindingSchema = CompositionLiteralBindingSchema;
+exports.CompositionNewTargetSchema = CompositionNewTargetSchema;
+exports.CompositionPassthroughFeatureSchema = CompositionPassthroughFeatureSchema;
+exports.CompositionProblemCodeSchema = CompositionProblemCodeSchema;
+exports.CompositionProblemSchema = CompositionProblemSchema;
+exports.CompositionRunStatusSchema = CompositionRunStatusSchema;
+exports.CompositionSchema = CompositionSchema;
+exports.CompositionSourceRefSchema = CompositionSourceRefSchema;
+exports.CompositionStateReadSchema = CompositionStateReadSchema;
+exports.CompositionTargetSchema = CompositionTargetSchema;
+exports.CompositionUnavailableModeSchema = CompositionUnavailableModeSchema;
+exports.CompositionValidationSchema = CompositionValidationSchema;
+exports.CompositionViewSchema = CompositionViewSchema;
 exports.ConfigEntrySchema = ConfigEntrySchema;
 exports.ConfigSectionWithValuesSchema = ConfigSectionWithValuesSchema;
 exports.ConfigTabDeclarationSchema = ConfigTabDeclarationSchema;
@@ -67316,6 +68546,7 @@ exports.CoreBlockCompileResultSchema = CoreBlockCompileResultSchema;
 exports.CoreBlockInputSchema = CoreBlockInputSchema;
 exports.CoreBlockPlacementSchema = CoreBlockPlacementSchema;
 exports.CoreBlockSchema = CoreBlockSchema;
+exports.CoreBlockSourceSchema = CoreBlockSourceSchema;
 exports.CoreBlockStatusSchema = CoreBlockStatusSchema;
 exports.CoverStateSchema = CoverStateSchema;
 exports.CoverStatusSchema = CoverStatusSchema;
@@ -67648,6 +68879,9 @@ exports.MAX_BIRTH_DECISION_RECORDS = MAX_BIRTH_DECISION_RECORDS;
 exports.MAX_BIRTH_LATENCY_PROXY_MS = MAX_BIRTH_LATENCY_PROXY_MS;
 exports.MAX_CLIP_EVENT_IDS = MAX_CLIP_EVENT_IDS;
 exports.MAX_CLIP_LABELS = MAX_CLIP_LABELS;
+exports.MAX_COMPOSITION_CODE_LENGTH = MAX_COMPOSITION_CODE_LENGTH;
+exports.MAX_COMPOSITION_FEATURES = MAX_COMPOSITION_FEATURES;
+exports.MAX_COMPOSITION_FIELDS_PER_FEATURE = MAX_COMPOSITION_FIELDS_PER_FEATURE;
 exports.MAX_CONDITION_DEPTH = MAX_CONDITION_DEPTH;
 exports.MAX_CONDITION_LEAVES = MAX_CONDITION_LEAVES;
 exports.MAX_EXPRESSION_AST_NODES = MAX_EXPRESSION_AST_NODES;
@@ -68014,6 +69248,9 @@ exports.REDACTED_SECRET = REDACTED_SECRET;
 exports.RESERVED_BINDING_NAMES = RESERVED_BINDING_NAMES;
 exports.RESERVED_COLLECTION_SOURCES = RESERVED_COLLECTION_SOURCES;
 exports.RESTORED_CAP_NAMES = RESTORED_CAP_NAMES;
+exports.ROOM_EXAMPLE_MOTION_SOURCES = ROOM_EXAMPLE_MOTION_SOURCES;
+exports.ROOM_EXAMPLE_TEMPERATURE_SOURCES = ROOM_EXAMPLE_TEMPERATURE_SOURCES;
+exports.ROOM_OCCUPANCY_WINDOW_MS = ROOM_OCCUPANCY_WINDOW_MS;
 exports.ROOT_BUCKET_KEY = ROOT_BUCKET_KEY;
 exports.RUNTIME_DEFAULTS = RUNTIME_DEFAULTS;
 exports.RUNTIME_STATE_POLICY = RUNTIME_STATE_POLICY;
@@ -68411,6 +69648,7 @@ exports.brightnessCapability = brightnessCapability;
 exports.brokerCapability = brokerCapability;
 exports.buildAddonRouteProvider = buildAddonRouteProvider;
 exports.buildAudioArgs = require_canonical_hash.buildAudioArgs;
+exports.buildCapabilityLookup = buildCapabilityLookup;
 exports.buildDeviceAdminUrl = buildDeviceAdminUrl;
 exports.buildEventKindDescriptor = buildEventKindDescriptor;
 exports.buildFfmpegArgs = require_canonical_hash.buildFfmpegArgs;
@@ -68450,6 +69688,14 @@ exports.compareToTarget = compareToTarget;
 exports.compileExpression = compileExpression;
 exports.compileExpressionSafe = compileExpressionSafe;
 exports.composeSwitchedOff = composeSwitchedOff;
+exports.composedDeviceRef = composedDeviceRef;
+exports.composedDeviceStableId = composedDeviceStableId;
+exports.composerCapability = composerCapability;
+exports.compositionEdges = compositionEdges;
+exports.compositionReadKey = compositionReadKey;
+exports.compositionSliceKey = compositionSliceKey;
+exports.compositionSourceKey = compositionSourceKey;
+exports.compositionSourceRefs = compositionSourceRefs;
 exports.conditionDepth = conditionDepth;
 exports.conditionExclusionReason = conditionExclusionReason;
 exports.conditionVisibleForKind = conditionVisibleForKind;
@@ -68461,7 +69707,9 @@ exports.contactCapability = contactCapability;
 exports.controlCapability = controlCapability;
 exports.convertUnit = convertUnit;
 exports.coreBlockAddonId = coreBlockAddonId;
+exports.coreBlockComposition = coreBlockComposition;
 exports.coreBlockIdFromAddonId = coreBlockIdFromAddonId;
+exports.coreBlockSourceKind = coreBlockSourceKind;
 exports.coreBlocksCapability = coreBlocksCapability;
 exports.cosineSimilarity = cosineSimilarity;
 exports.countConditionLeaves = countConditionLeaves;
@@ -68500,8 +69748,10 @@ exports.describeCustomActions = require_sleep.describeCustomActions;
 exports.describeModelVariant = describeModelVariant;
 exports.describeOnboardClamp = describeOnboardClamp;
 exports.describeOnboardRefusal = describeOnboardRefusal;
+exports.describeStateField = describeStateField;
 exports.describeSystemEventDeliveryProblem = describeSystemEventDeliveryProblem;
 exports.describeSystemEventFamilyProblem = describeSystemEventFamilyProblem;
+exports.describeTopLevelStateFields = describeTopLevelStateFields;
 exports.detectAccessRole = detectAccessRole;
 exports.detectionPipelineCapability = detectionPipelineCapability;
 exports.deviceAdminLinkCapability = deviceAdminLinkCapability;
@@ -68541,6 +69791,7 @@ exports.enumerateItemArrayFields = enumerateItemArrayFields;
 exports.enumerateSchemaFields = enumerateSchemaFields;
 exports.errMsg = require_err_msg.errMsg;
 exports.evaluateAst = evaluateAst;
+exports.evaluateCompositionField = evaluateCompositionField;
 exports.evaluateExpressionSource = evaluateExpressionSource;
 exports.evaluatePoolMemory = evaluatePoolMemory;
 exports.evaluateSensorEdge = evaluateSensorEdge;
@@ -68561,7 +69812,9 @@ exports.failureContributionCapability = failureContributionCapability;
 exports.failureRate = failureRate;
 exports.fanControlCapability = fanControlCapability;
 exports.featureProbeCapability = featureProbeCapability;
+exports.fieldReads = fieldReads;
 exports.filesystemBrowseCapability = filesystemBrowseCapability;
+exports.findCompositionCycles = findCompositionCycles;
 exports.findTimezone = findTimezone;
 exports.floodCapability = floodCapability;
 exports.foldSnapshotByFunction = foldSnapshotByFunction;
@@ -68585,6 +69838,7 @@ exports.humiditySensorCapability = humiditySensorCapability;
 exports.hydrateSchema = require_sleep.hydrateSchema;
 exports.imageCapability = imageCapability;
 exports.imageSettingsCapability = imageSettingsCapability;
+exports.inferExpressionKinds = inferExpressionKinds;
 exports.inferModelProvider = inferModelProvider;
 exports.initialPoolMemoryState = initialPoolMemoryState;
 exports.integrationsCapability = integrationsCapability;
@@ -68634,6 +69888,7 @@ exports.isVoidInput = isVoidInput;
 exports.ituDbfsFromPreEpoch = ituDbfsFromPreEpoch;
 exports.jobKindSchema = jobKindSchema;
 exports.kebabToCamel = kebabToCamel;
+exports.kindOfValue = kindOfValue;
 exports.kindsForDiscriminator = kindsForDiscriminator;
 exports.knownValues = knownValues;
 exports.lawnMowerControlCapability = lawnMowerControlCapability;
@@ -68736,6 +69991,7 @@ exports.pipelineAnalyticsCapability = pipelineAnalyticsCapability;
 exports.pipelineExecutorCapability = pipelineExecutorCapability;
 exports.pipelineOrchestratorCapability = pipelineOrchestratorCapability;
 exports.pipelineRunnerCapability = pipelineRunnerCapability;
+exports.planComposition = planComposition;
 exports.plateGalleryCapability = plateGalleryCapability;
 exports.platformProbeCapability = platformProbeCapability;
 exports.poolMemoryThreshold = poolMemoryThreshold;
@@ -68766,6 +70022,7 @@ exports.recordingOnboardCapability = recordingOnboardCapability;
 exports.recordingSignalCapability = recordingSignalCapability;
 exports.rectsToCells = rectsToCells;
 exports.reducePoints = reducePoints;
+exports.requiredTopLevelKeys = requiredTopLevelKeys;
 exports.requiresPython = requiresPython;
 exports.reservedSourceOwner = reservedSourceOwner;
 exports.resetPoolBaseline = resetPoolBaseline;
@@ -68795,6 +70052,7 @@ exports.resolveStreamMaps = require_canonical_hash.resolveStreamMaps;
 exports.resolveVariantModelId = resolveVariantModelId;
 exports.resolveViewableDeviceIds = resolveViewableDeviceIds;
 exports.roleSpec = roleSpec;
+exports.roomCompositionExample = roomCompositionExample;
 exports.ruleBelongsToAlarm = ruleBelongsToAlarm;
 exports.ruleEditorSectionsForKind = ruleEditorSectionsForKind;
 exports.ruleKindOf = ruleKindOf;
@@ -68900,6 +70158,7 @@ exports.updateCapability = updateCapability;
 exports.userManagementCapability = userManagementCapability;
 exports.userPasskeysCapability = userPasskeysCapability;
 exports.vacuumControlCapability = vacuumControlCapability;
+exports.validateComposition = validateComposition;
 exports.validateExpressionSource = validateExpressionSource;
 exports.validateRecipeBounds = validateRecipeBounds;
 exports.valveCapability = valveCapability;