@camstack/system 1.2.307 → 1.2.309

package/dist/{dist-D3ch99WD.js → dist-BhO9eYKO.js}

@@ -6549,6 +6549,49 @@ var ModelProviderIdSchema = zod.z.enum([
 	"scrypted",
 	"custom"
 ]);
+var ModelLicenseRecordSchema = zod.z.object({
+	/** SPDX id of the WEIGHTS' terms, a `LicenseRef-*` for non-SPDX terms, or `UNKNOWN`. */
+	weights: zod.z.string().min(1),
+	/** SPDX id of the upstream code that defines / trained the network. */
+	code: zod.z.string().min(1).optional(),
+	/** Training data whose terms add obligations (attribution, non-commercial). */
+	data: zod.z.object({
+		name: zod.z.string().min(1),
+		terms: zod.z.string().min(1),
+		url: zod.z.string().url().optional()
+	}).optional(),
+	/** The project the weights come from. Required on built-in entries (guard). */
+	upstream: zod.z.object({
+		name: zod.z.string().min(1),
+		url: zod.z.string().url()
+	}).optional(),
+	/** Where the licence text governing the weights is published. */
+	url: zod.z.string().url().optional(),
+	/** Attribution the licence REQUIRES, verbatim. */
+	attribution: zod.z.string().min(1).optional(),
+	/** What CamStack changed. Required when `hosting` is `camstack-hf` (guard). */
+	modifications: zod.z.string().min(1).optional(),
+	/** Who serves the file a node downloads. */
+	hosting: zod.z.enum([
+		"camstack-hf",
+		"third-party",
+		"built-in"
+	]).optional(),
+	/** True when the weights or their data forbid commercial use. */
+	nonCommercial: zod.z.boolean().optional()
+});
+/**
+* The licence of a model, as a record rather than a bare SPDX string: a
+* permissive CODE licence routinely sits on top of restrictive WEIGHTS or
+* DATA, and the obligations (attribution, modification notices, source offers)
+* are per upstream. A persisted custom-model row written when this field was a
+* string still parses — the string is lifted into `{ weights }`.
+*
+* Every licence surface (the admin "Models and licenses" page,
+* `THIRD_PARTY_MODELS.md`, the Hugging Face model table) is GENERATED from
+* these records by `scripts/gen-model-licenses.ts` (D661).
+*/
+var ModelLicenseSchema = zod.z.preprocess((value) => typeof value === "string" ? { weights: value } : value, ModelLicenseRecordSchema);
 var ModelCatalogEntrySchema = zod.z.object({
 	id: zod.z.string(),
 	name: zod.z.string(),
@@ -6637,11 +6680,11 @@ var ModelCatalogEntrySchema = zod.z.object({
 		p95LatencyMs: zod.z.record(zod.z.string(), zod.z.number()).optional()
 	}).optional(),
 	/**
-	* SPDX-ish license id of the model weights (e.g. `AGPL-3.0` for Ultralytics
-	* YOLO26, `GPL-3.0` for YOLOv9, `Apache-2.0` for D-FINE/RF-DETR). Matters for
-	* the retraining addon and any future commercial distribution.
+	* The model's licence record — see {@link ModelLicenseSchema}. Optional in
+	* the schema (a custom model's author may state none); REQUIRED and complete
+	* on every built-in catalog entry (`scripts/check-catalog-licence.ts`).
 	*/
-	license: zod.z.string().optional(),
+	license: ModelLicenseSchema.optional(),
 	/**
 	* Variant-selector grouping. The UI groups models by `family` + `tier` and
 	* offers `precision` / `optimization` as variant axes WITHIN a tier — so all
@@ -6755,23 +6798,6 @@ var ExpressionEvalError = class extends Error {
 		this.name = "ExpressionEvalError";
 	}
 };
-/**
-* 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;
@@ -6787,6 +6813,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: {
@@ -6887,9 +6917,44 @@ 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");
+		}
 	}
 };
-Object.freeze(Object.assign(Object.create(null), table));
+/** Frozen, null-prototype builtin table. */
+var EXPRESSION_BUILTINS = Object.freeze(Object.assign(Object.create(null), table));
 /** The set of valid builtin names — used by the parser to reject unknown
 *  callees at parse time (immediate author feedback). */
 var EXPRESSION_BUILTIN_NAMES = new Set(Object.keys(table));
@@ -7302,7 +7367,118 @@ function getCached(source) {
 function compileExpressionSafe(source) {
 	return getCached(source);
 }
-Object.freeze({});
+/**
+* Tree-walking evaluator for the safe expression mini-language.
+*
+* SECURITY (spec §4 rule 2/5):
+*  - The scope is an `Object.create(null)` copy of ONLY the caller's own
+*    enumerable binding entries, so `name in scope` is a pure own-key check and
+*    `constructor` / `__proto__` / `toString` are plain unknown identifiers.
+*  - Performs ZERO I/O and never touches `globalThis` / `Date` / `Math`
+*    directly — the only external calls are into the frozen builtin table.
+*  - The grammar has no loops/recursion/lambdas, so a walk is O(nodeCount) by
+*    construction; the step counter is defense-in-depth for a crafted max-size
+*    AST. Nothing blocks: there are no timers, awaits or unbounded loops.
+*/
+var EMPTY_HOOKS = Object.freeze({});
+/** Build a null-prototype scope from own-enumerable binding entries. Inherited
+*  keys of the input (e.g. from a `{__proto__: {...}}` payload) are NOT copied,
+*  so nothing smuggles in via the prototype chain. */
+function createExpressionScope(bindings) {
+	const scope = Object.create(null);
+	for (const key of Object.keys(bindings)) if (Object.prototype.hasOwnProperty.call(bindings, key)) scope[key] = bindings[key];
+	return scope;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+/** JS truthiness of a primitive value. */
+function truthy(value) {
+	return Boolean(value);
+}
+function requireFinite(value, context) {
+	if (!Number.isFinite(value)) throw new ExpressionEvalError(`${context} produced a non-finite result`);
+	return value;
+}
+function step(ctx) {
+	ctx.steps += 1;
+	if (ctx.steps > ctx.maxSteps) throw new ExpressionEvalError("expression evaluation step budget exceeded");
+}
+function evalNode(node, ctx) {
+	step(ctx);
+	switch (node.kind) {
+		case "literal": return node.value;
+		case "identifier":
+			if (!(node.name in ctx.scope)) throw new ExpressionEvalError(`unknown identifier: ${node.name}`);
+			return ctx.scope[node.name];
+		case "unary": return evalUnary(node.op, evalNode(node.operand, ctx));
+		case "binary": return evalBinary(node.op, evalNode(node.left, ctx), evalNode(node.right, ctx));
+		case "logical": {
+			const left = evalNode(node.left, ctx);
+			if (node.op === "&&") return truthy(left) ? evalNode(node.right, ctx) : left;
+			return truthy(left) ? left : evalNode(node.right, ctx);
+		}
+		case "conditional": return truthy(evalNode(node.test, ctx)) ? evalNode(node.consequent, ctx) : evalNode(node.alternate, ctx);
+		case "call": return evalCall(node.callee, node.args.map((a) => evalNode(a, ctx)), ctx.hooks);
+	}
+}
+function evalUnary(op, operand) {
+	if (op === "!") return !truthy(operand);
+	if (!isFiniteNumber(operand)) throw new ExpressionEvalError("unary \"-\" requires a finite number");
+	return requireFinite(-operand, "unary \"-\"");
+}
+function evalBinary(op, left, right) {
+	switch (op) {
+		case "==": return left === right;
+		case "!=": return left !== right;
+		case "+":
+			if (typeof left === "string" && typeof right === "string") return left + right;
+			if (isFiniteNumber(left) && isFiniteNumber(right)) return requireFinite(left + right, "\"+\"");
+			throw new ExpressionEvalError("\"+\" requires two numbers or two strings");
+		case "-":
+		case "*":
+		case "/":
+		case "%":
+			if (!isFiniteNumber(left) || !isFiniteNumber(right)) throw new ExpressionEvalError(`"${op}" requires two finite numbers`);
+			return requireFinite(op === "-" ? left - right : op === "*" ? left * right : op === "/" ? left / right : left % right, `"${op}"`);
+		case "<":
+		case "<=":
+		case ">":
+		case ">=":
+			if (isFiniteNumber(left) && isFiniteNumber(right)) return op === "<" ? left < right : op === "<=" ? left <= right : op === ">" ? left > right : left >= right;
+			if (typeof left === "string" && typeof right === "string") return op === "<" ? left < right : op === "<=" ? left <= right : op === ">" ? left > right : left >= right;
+			throw new ExpressionEvalError(`"${op}" requires two numbers or two strings`);
+	}
+}
+function evalCall(callee, args, hooks) {
+	if (!Object.prototype.hasOwnProperty.call(EXPRESSION_BUILTINS, callee)) throw new ExpressionEvalError(`unknown function: ${callee}`);
+	const builtin = EXPRESSION_BUILTINS[callee];
+	if (args.length < builtin.minArgs || args.length > builtin.maxArgs) throw new ExpressionEvalError(`${callee}: wrong number of arguments (${args.length})`);
+	return builtin.apply(args, hooks);
+}
+/** Evaluate an AST node against a scope. Throws `ExpressionEvalError` on any
+*  runtime failure (unknown identifier, type mismatch, non-finite result,
+*  step-budget exhaustion). */
+function evaluateAst(node, scope, opts) {
+	return evalNode(node, {
+		scope,
+		hooks: opts?.hooks ?? EMPTY_HOOKS,
+		maxSteps: opts?.maxSteps ?? 4096,
+		steps: 0
+	});
+}
+/**
+* Coerce an untrusted `getByPath` / mirror read to an `ExpressionValue`.
+* Non-primitive values (objects, arrays, `undefined`, functions, bigint,
+* symbol) and non-finite numbers become `undefined` so the caller can apply
+* its binding-miss policy (→ `null`). `null` itself is a valid value.
+*/
+function toExpressionValue(raw) {
+	if (raw === null) return null;
+	if (typeof raw === "string") return raw;
+	if (typeof raw === "boolean") return raw;
+	if (typeof raw === "number") return Number.isFinite(raw) ? raw : void 0;
+}
 /**
 * Author-time validation. Returns `null` when the source is valid, else a
 * human-readable error message. Checks: the expression compiles; binding count
@@ -7328,6 +7504,42 @@ function validateExpressionSource(src) {
 	return null;
 }
 /**
+* Shared read-path evaluation. Builds a null-proto scope from `bindingValues`
+* plus the injected `now` (supplied by the caller for determinism and
+* testability), compiles via the LRU, and evaluates. Any failure (parse or
+* eval) returns `{ ok: false }` — the caller treats that as "skip this
+* derivation", never as a throw that takes the pass down.
+*/
+function evaluateExpressionSource(expr, bindingValues, now, opts) {
+	const compiled = compileExpressionSafe(expr);
+	if (!compiled.ok) return {
+		ok: false,
+		error: compiled.error
+	};
+	const scope = createExpressionScope({
+		...bindingValues,
+		["now"]: now
+	});
+	const hooks = {
+		...opts?.hooks,
+		now
+	};
+	try {
+		return {
+			ok: true,
+			value: evaluateAst(compiled.parsed.ast, scope, {
+				...opts,
+				hooks
+			})
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: err instanceof ExpressionEvalError ? err.message : String(err)
+		};
+	}
+}
+/**
 * What an expression's named bindings READ from.
 *
 * Salvaged verbatim from the deleted device-link mechanism. Wiring's source
@@ -7527,7 +7739,7 @@ var AutomationActionSchema = zod.z.discriminatedUnion("kind", [
 		code: zod.z.string().min(1).max(2e4)
 	})
 ]);
-zod.z.object({
+var AutomationRecipeSchema = zod.z.object({
 	triggers: zod.z.array(AutomationTriggerSchema),
 	conditions: AutomationConditionSchema.optional(),
 	actions: zod.z.array(AutomationActionSchema)
@@ -10551,6 +10763,270 @@ function kebabToCamel(s) {
 	return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 /**
+* 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-";
+/** 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(DeviceType),
+	role: zod.z.enum(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 [];
+	}
+}
+/**
+* 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)
+});
+/**
 * core-blocks — user-authored TypeScript, stored in the kernel and executed in
 * its own process.
 *
@@ -10634,6 +11110,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(),
@@ -10649,8 +11149,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(),
@@ -10732,7 +11270,116 @@ var coreBlocksCapability = {
 		getTypeDefs: 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: 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: 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: method(zod.z.object({ blockId: zod.z.string() }), CompositionGetReadSchema, { auth: "admin" }),
+		listCompositions: 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: method(zod.z.object({
+			composition: CompositionSchema,
+			blockId: zod.z.string().optional()
+		}), CompositionValidationSchema, {
+			kind: "mutation",
+			auth: "admin",
+			access: "view"
+		})
+	}
+};
+/**
+* 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 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: method(ComposerApplyInputSchema, 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()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getStates: method(zod.z.object({ blockIds: zod.z.array(zod.z.string()) }), zod.z.object({ states: zod.z.array(CompositionBlockStateSchema) }), { auth: "admin" })
 	}
 };
 /**
@@ -18285,8 +18932,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",
@@ -41624,6 +42271,620 @@ function createDeviceExtensionProvider(options) {
 	};
 }
 /**
+* 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()];
+}
+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
+		};
+	}
+}
+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;
+	}
+}
+/** 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
+	}));
+}
+/**
+* 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] : []);
+}
+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]
+	};
+}
+/**
 * Runtime defaults -- used by ConfigManager.get() for backward compatibility
 * until Plan B wires all runtime settings to the system_settings SQL table.
 *
@@ -44325,60 +45586,6 @@ var DISPLAY_ICON_VOCABULARY = [
 DISPLAY_ICON_VOCABULARY.map((e) => e.key);
 DISPLAY_ICON_VOCABULARY.filter((e) => e.aliasOf === void 0).map((e) => e.key);
 new Map(DISPLAY_ICON_VOCABULARY.map((e) => [e.key, e]));
-/** 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
-	}));
-}
 /**
 * Runtime list of cap names with status. Used by the settings
 * aggregator to enumerate caps whose `status` should be polled +
@@ -44500,6 +45707,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	carbonMonoxideCapability,
 	climateControlCapability,
 	colorCapability,
+	composerCapability,
 	connectionTestCapability,
 	connectivityCapability,
 	consumablesCapability,
@@ -45573,6 +46781,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",
@@ -45633,6 +46853,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",
@@ -45645,6 +46871,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",
@@ -45657,6 +46889,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",
@@ -45675,6 +46913,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",
@@ -55151,6 +56401,18 @@ Object.defineProperty(exports, "CAP_NAMES_WITH_STATUS", {
 		return CAP_NAMES_WITH_STATUS;
 	}
 });
+Object.defineProperty(exports, "COMPOSER_ADDON_ID", {
+	enumerable: true,
+	get: function() {
+		return COMPOSER_ADDON_ID;
+	}
+});
+Object.defineProperty(exports, "COMPOSER_RUNNER_ID", {
+	enumerable: true,
+	get: function() {
+		return COMPOSER_RUNNER_ID;
+	}
+});
 Object.defineProperty(exports, "CORE_BLOCKS_ADDON_ID", {
 	enumerable: true,
 	get: function() {
@@ -55445,6 +56707,12 @@ Object.defineProperty(exports, "batteryCapability", {
 		return batteryCapability;
 	}
 });
+Object.defineProperty(exports, "buildCapabilityLookup", {
+	enumerable: true,
+	get: function() {
+		return buildCapabilityLookup;
+	}
+});
 Object.defineProperty(exports, "buildFfmpegArgs", {
 	enumerable: true,
 	get: function() {
@@ -55469,18 +56737,66 @@ Object.defineProperty(exports, "collectSecretConfigKeys", {
 		return collectSecretConfigKeys;
 	}
 });
+Object.defineProperty(exports, "composedDeviceRef", {
+	enumerable: true,
+	get: function() {
+		return composedDeviceRef;
+	}
+});
+Object.defineProperty(exports, "composedDeviceStableId", {
+	enumerable: true,
+	get: function() {
+		return composedDeviceStableId;
+	}
+});
+Object.defineProperty(exports, "composerCapability", {
+	enumerable: true,
+	get: function() {
+		return composerCapability;
+	}
+});
+Object.defineProperty(exports, "compositionSliceKey", {
+	enumerable: true,
+	get: function() {
+		return compositionSliceKey;
+	}
+});
+Object.defineProperty(exports, "compositionSourceKey", {
+	enumerable: true,
+	get: function() {
+		return compositionSourceKey;
+	}
+});
+Object.defineProperty(exports, "compositionSourceRefs", {
+	enumerable: true,
+	get: function() {
+		return compositionSourceRefs;
+	}
+});
 Object.defineProperty(exports, "coreBlockAddonId", {
 	enumerable: true,
 	get: function() {
 		return coreBlockAddonId;
 	}
 });
+Object.defineProperty(exports, "coreBlockComposition", {
+	enumerable: true,
+	get: function() {
+		return coreBlockComposition;
+	}
+});
 Object.defineProperty(exports, "coreBlockIdFromAddonId", {
 	enumerable: true,
 	get: function() {
 		return coreBlockIdFromAddonId;
 	}
 });
+Object.defineProperty(exports, "coreBlockSourceKind", {
+	enumerable: true,
+	get: function() {
+		return coreBlockSourceKind;
+	}
+});
 Object.defineProperty(exports, "coreBlocksCapability", {
 	enumerable: true,
 	get: function() {
@@ -55595,6 +56911,12 @@ Object.defineProperty(exports, "errMsg", {
 		return errMsg;
 	}
 });
+Object.defineProperty(exports, "evaluateCompositionField", {
+	enumerable: true,
+	get: function() {
+		return evaluateCompositionField;
+	}
+});
 Object.defineProperty(exports, "evaluateSensorEdge", {
 	enumerable: true,
 	get: function() {
@@ -55835,6 +57157,12 @@ Object.defineProperty(exports, "parseStreamParamsFormPatch", {
 		return parseStreamParamsFormPatch;
 	}
 });
+Object.defineProperty(exports, "planComposition", {
+	enumerable: true,
+	get: function() {
+		return planComposition;
+	}
+});
 Object.defineProperty(exports, "platformProbeCapability", {
 	enumerable: true,
 	get: function() {
@@ -55979,12 +57307,24 @@ Object.defineProperty(exports, "streamQualityLabel", {
 		return streamQualityLabel;
 	}
 });
+Object.defineProperty(exports, "toExpressionValue", {
+	enumerable: true,
+	get: function() {
+		return toExpressionValue;
+	}
+});
 Object.defineProperty(exports, "userManagementCapability", {
 	enumerable: true,
 	get: function() {
 		return userManagementCapability;
 	}
 });
+Object.defineProperty(exports, "validateComposition", {
+	enumerable: true,
+	get: function() {
+		return validateComposition;
+	}
+});
 Object.defineProperty(exports, "vectorDimFromBase64", {
 	enumerable: true,
 	get: function() {