@camstack/system 1.2.308 → 1.2.309

package/dist/{dist-DygWCI8k.mjs → dist-BEuQPDk_.mjs}

@@ -6798,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;
@@ -6830,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: {
@@ -6930,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));
@@ -7345,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
@@ -7371,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
@@ -7570,7 +7739,7 @@ var AutomationActionSchema = z.discriminatedUnion("kind", [
 		code: z.string().min(1).max(2e4)
 	})
 ]);
-z.object({
+var AutomationRecipeSchema = z.object({
 	triggers: z.array(AutomationTriggerSchema),
 	conditions: AutomationConditionSchema.optional(),
 	actions: z.array(AutomationActionSchema)
@@ -10594,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 = z.object({
+	/** The owning addon; `stableId` is unique only within it. */
+	addonId: z.string().min(1),
+	stableId: z.string().min(1)
+});
+/** One field of one capability of one source device. */
+var CompositionFieldReadSchema = z.object({
+	source: CompositionSourceRefSchema,
+	cap: z.string().min(1),
+	/** Dotted path into the source cap's runtime-state slice. */
+	fieldPath: z.string().min(1)
+});
+/** `from`: copy one source field verbatim. It is also an expression's `from` binding. */
+var CompositionFromSourceSchema = CompositionFieldReadSchema.extend({ kind: z.literal("from") });
+/** A constant binding. No device is read. */
+var CompositionLiteralBindingSchema = z.object({
+	kind: z.literal("literal"),
+	value: z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null()
+	])
+});
+var CompositionBindingSchema = 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 = z.object({
+	kind: z.literal("expression"),
+	expr: z.string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
+	bindings: z.record(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 = z.object({
+	kind: z.literal("code"),
+	code: z.string().min(1).max(MAX_COMPOSITION_CODE_LENGTH)
+});
+var CompositionFieldSourceSchema = z.discriminatedUnion("kind", [
+	CompositionFromSourceSchema,
+	CompositionExpressionSourceSchema,
+	CompositionCodeSourceSchema
+]);
+/** `forward`: RESERVED for slice 3. Argument mapping arrives there as an additive optional `args`. */
+var CompositionForwardCommandSchema = z.object({
+	kind: z.literal("forward"),
+	source: CompositionSourceRefSchema,
+	cap: z.string().min(1),
+	method: z.string().min(1)
+});
+var CompositionCommandTargetSchema = z.discriminatedUnion("kind", [CompositionForwardCommandSchema, CompositionCodeSourceSchema]);
+var CompositionFieldsFeatureSchema = z.object({
+	kind: z.literal("fields"),
+	cap: z.string().min(1),
+	fields: z.record(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: z.record(z.string().min(1), CompositionCommandTargetSchema).optional()
+});
+/** RESERVED for slice 3: a media / data-plane cap, whole, from one source. */
+var CompositionPassthroughFeatureSchema = z.object({
+	kind: z.literal("passthrough"),
+	cap: z.string().min(1),
+	source: CompositionSourceRefSchema
+});
+var CompositionFeatureSchema = 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 = z.object({
+	kind: z.literal("new"),
+	type: z.enum(DeviceType),
+	role: z.enum(DeviceRole).optional()
+});
+/** RESERVED for slice 2: customize an existing device. */
+var CompositionExistingTargetSchema = z.object({
+	kind: z.literal("existing"),
+	device: CompositionSourceRefSchema
+});
+var CompositionTargetSchema = z.discriminatedUnion("kind", [CompositionNewTargetSchema, CompositionExistingTargetSchema]);
+var CompositionSchema = z.object({
+	target: CompositionTargetSchema,
+	features: 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 = 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 = z.object({
+	code: CompositionProblemCodeSchema,
+	path: z.string(),
+	message: z.string()
+});
+var CompositionFieldKindSchema = 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 = 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 = z.enum([
+	"derived",
+	"clock",
+	"constant"
+]);
+var CompositionFieldPlanSchema = z.object({
+	cap: z.string(),
+	path: 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: z.number().int().nonnegative(),
+	kind: CompositionFieldKindSchema,
+	nullable: z.boolean(),
+	required: z.boolean(),
+	unavailable: CompositionUnavailableModeSchema,
+	role: CompositionFieldRoleSchema,
+	source: CompositionFieldSourceSchema,
+	reads: z.array(CompositionFieldReadSchema)
+});
+var CompositionValidationSchema = z.object({
+	ok: z.boolean(),
+	problems: z.array(CompositionProblemSchema),
+	fields: z.array(CompositionFieldPlanSchema)
+});
+/** Mirrors `CoreBlockStatus`, pinned by `core-blocks-source.spec.ts` (Task 11). */
+var CompositionRunStatusSchema = z.enum([
+	"stopped",
+	"starting",
+	"running",
+	"failed"
+]);
+var CompositionFieldStateKindSchema = z.enum([
+	"fresh",
+	"stale",
+	"unavailable"
+]);
+var CompositionFieldStateSchema = z.object({
+	cap: z.string(),
+	path: z.string(),
+	state: CompositionFieldStateKindSchema,
+	/** `null` whenever `state === 'unavailable'`; never a plausible stand-in (D393). */
+	value: z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null()
+	]),
+	reason: z.string().optional()
+});
+var CompositionBlockStateSchema = z.object({
+	blockId: z.string(),
+	deviceId: z.number().nullable(),
+	status: CompositionRunStatusSchema,
+	reason: z.string().optional(),
+	fields: z.array(CompositionFieldStateSchema)
+});
+/**
 * core-blocks — user-authored TypeScript, stored in the kernel and executed in
 * its own process.
 *
@@ -10677,6 +11110,30 @@ var CoreBlockInputSchema = z.object({
 	*/
 	integrationId: 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 = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("code") }),
+	z.object({
+		kind: z.literal("recipe"),
+		recipe: AutomationRecipeSchema
+	}),
+	z.object({
+		kind: z.literal("composition"),
+		composition: CompositionSchema
+	})
+]);
+/** The client-authored half of a composition block. No `code`, no placement (hub-only; Phase 7). */
+var CompositionBlockInputSchema = z.object({
+	name: z.string().min(1).max(120),
+	enabled: z.boolean(),
+	composition: CompositionSchema
+});
 /** A stored block. */
 var CoreBlockSchema = CoreBlockInputSchema.extend({
 	id: z.string(),
@@ -10692,8 +11149,46 @@ var CoreBlockSchema = CoreBlockInputSchema.extend({
 	*/
 	lastError: z.string().optional(),
 	/** Ms epoch of the last state change. */
-	lastChangedAt: z.number()
+	lastChangedAt: 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 = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("answered"),
+	state: CompositionBlockStateSchema.nullable()
+}), z.object({
+	kind: z.literal("unreachable"),
+	error: z.string()
+})]);
+/** A stored composition block and what the composer says about it. */
+var CompositionViewSchema = 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 = z.object({
+	state: z.literal("not-loaded"),
+	reason: z.string()
+});
+var CompositionListReadSchema = z.discriminatedUnion("state", [z.object({
+	state: z.literal("loaded"),
+	views: z.array(CompositionViewSchema)
+}), CompositionsNotLoadedSchema]);
+var CompositionGetReadSchema = z.discriminatedUnion("state", [z.object({
+	state: z.literal("loaded"),
+	view: CompositionViewSchema.nullable()
+}), CompositionsNotLoadedSchema]);
 /** What a compile attempt produced. */
 var CoreBlockCompileResultSchema = z.object({
 	ok: z.boolean(),
@@ -10775,7 +11270,116 @@ var coreBlocksCapability = {
 		getTypeDefs: method(z.object({}), z.object({ libs: z.array(z.object({
 			filePath: z.string(),
 			content: 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(z.object({ block: CompositionBlockInputSchema }), 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(z.object({
+			blockId: z.string(),
+			expectedUpdatedAt: z.number(),
+			block: CompositionBlockInputSchema.partial()
+		}), 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(z.object({ blockId: z.string() }), CompositionGetReadSchema, { auth: "admin" }),
+		listCompositions: method(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(z.object({
+			composition: CompositionSchema,
+			blockId: 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 = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1).max(120),
+	enabled: z.boolean(),
+	updatedAt: 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 = z.object({
+	id: z.string().min(1),
+	/** The row's stored name column; null when even that is unreadable (the device keeps the name it has). */
+	name: z.string().nullable(),
+	/** The parse error, in the operator's words. */
+	error: z.string()
+});
+var ComposerApplyInputSchema = z.object({
+	/** The shared Blocks integration; null until `core-blocks` has reconciled it. */
+	integrationId: z.string().nullable(),
+	/** False when the `core_blocks` read failed: then nothing may be withdrawn (D49). */
+	storeLoaded: z.boolean(),
+	blocks: z.array(ComposerBlockSchema),
+	/** Operator restarts: rebuild these runtimes and re-resolve their sources. Stores nothing (D62). */
+	restartBlockIds: z.array(z.string()),
+	/** Composition rows that exist but do not parse: held, never withdrawn, reported failed. */
+	unreadableBlocks: z.array(ComposerUnreadableBlockSchema)
+});
+var ComposerBlockVerdictSchema = z.object({
+	blockId: z.string(),
+	status: CompositionRunStatusSchema,
+	reason: 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, z.object({
+			blocks: 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: z.boolean()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getStates: method(z.object({ blockIds: z.array(z.string()) }), z.object({ states: z.array(CompositionBlockStateSchema) }), { auth: "admin" })
 	}
 };
 /**
@@ -18328,8 +18932,8 @@ var NcTestResultSchema = z.object({
 	className: z.string().optional(),
 	label: 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 = z.enum([
 	"detection",
@@ -41667,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 z.ZodNullable || s instanceof z.ZodOptional || s instanceof z.ZodDefault) s = s.unwrap();
+	return s;
+}
+function leafKind(schema) {
+	const s = unwrapSchema(schema);
+	if (s instanceof z.ZodEnum) return {
+		kind: "enum",
+		enumValues: s.options
+	};
+	if (s instanceof z.ZodNumber) return { kind: "number" };
+	if (s instanceof z.ZodString) return { kind: "string" };
+	if (s instanceof 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 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 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 z.ZodObject)) return null;
+		const next = container.shape[segment];
+		if (!(next instanceof 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 z.ZodObject)) return [];
+	return Object.entries(root.shape).flatMap(([key, field]) => field instanceof 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.
 *
@@ -44368,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 z.ZodNullable || s instanceof z.ZodOptional || s instanceof z.ZodDefault) s = s.unwrap();
-	return s;
-}
-function leafKind(schema) {
-	const s = unwrap(schema);
-	if (s instanceof z.ZodEnum) return {
-		kind: "enum",
-		enumValues: s.options
-	};
-	if (s instanceof z.ZodNumber) return { kind: "number" };
-	if (s instanceof z.ZodString) return { kind: "string" };
-	if (s instanceof 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 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 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 +
@@ -44543,6 +45707,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	carbonMonoxideCapability,
 	climateControlCapability,
 	colorCapability,
+	composerCapability,
 	connectionTestCapability,
 	connectivityCapability,
 	consumablesCapability,
@@ -45616,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",
@@ -45676,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",
@@ -45688,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",
@@ -45700,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",
@@ -45718,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",
@@ -55146,4 +56353,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { decodeVectorBase64 as $, scoreRuntimes as $t, ScopedTokenSchema as A, emitDownForOwnedCaps as An, locationIconKey as At, authProviderCapability as B, resolveCapMount as Bn, objectInputDeclaresAddonId as Bt, RECORDING_SOURCE_CAMSTACK_ADDON as C, ReadinessRegistry as Cn, isSourceCap as Ct, SOURCE_CAPS as D, asNumber as Dn, legacyModeOf as Dt, RecordingStatusSchema as E, asJsonObject as En, legacyAutoLinkIds as Et, UserRecordSchema as F, isEvent as Fn, mayWriteToLocation as Ft, cameraGridLayoutCapability as G, ptzAutotrackCapability as Gt, bareAddonId as H, sleep as Hn, parseStreamParamsFormPatch as Ht, addonPagesCapability as I, nodePin as In, metricsProviderCapability as It, coreBlockIdFromAddonId as J, resolveLocationMode as Jt, collectSecretConfigKeys as K, reducePoints as Kt, addonSettingsCapability as L, parseJsonObject as Ln, modeMayWrite as Lt, StorageLocationModeSchema as M, expandCapMethods as Mn, logLevelAtMost as Mt, StorageLocationTypeSchema as N, hydrateSchema as Nn, looseSchema as Nt, STORAGE_ACCESS_FALLBACK as O, asString as On, lifecycleJobSchema as Ot, StorageMigrationJobSchema as P, isDeviceConfigCap as Pn, mayReadLocation as Pt, declarationOwnerNodeId as Q, scopesAllowDeviceCap as Qt, addonWidgetsCapability as R, parseJsonUnknown as Rn, motionCapability as Rt, MOTION_CLOSE_AFTER_MS as S, DeviceType as Sn, isSameAddonId as St, RUNTIME_DEFAULTS as T, WELL_KNOWN_TAB_MAP as Tn, kebabToCamel as Tt, batteryCapability as U, EventCategory as Un, platformProbeCapability as Ut, backupCapability as V, scopeKey as Vn, objectInputDeclaresRequiredDeviceId as Vt, buildStreamParamsConfigSchema as W, procedureAuthKey as Wt, createDeviceExtensionProvider as X, runtimeStatePolicyFor as Xt, coreBlocksCapability as Y, resolveMethodAuth as Yt, dataStoreProviderCapability as Z, scopesAllowAddon as Zt, LOG_LEVEL_RANK as _, DATAPLANE_SECRET_HEADER as _n, gbToBytes as _t, BatteryStatusSchema as a, storageOccupancyCapability as an, deviceStatusCapability as at, METHOD_ACCESS_MAP as b, DeviceFeature as bn, isLocationEnabled as bt, CORE_BLOCKS_ADDON_ID as c, streamQualityLabel as cn, enumerateItemArrayFields as ct, DAY_NAMES as d, vectorIndexDimConflictError as dn, evictionPolicyOfLocation as dt, settingsStoreCapability as en, defineExtensionSlotProvider as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, vectorStoreCapability as fn, expandContainer as ft, FIRST_LEVEL_MACRO_CLASSES as g, BaseAddon as gn, formatMinutes as gt, DeviceStatusSchema as h, buildFfmpegArgs as hn, foldSnapshotByFunction as ht, BaseDevice as i, storageMigrationCapability as in, deviceStateCapability as it, StorageCleanupJobSchema as j, emitReadiness as jn, logDestinationCapability as jt, STREAM_PROFILE_META as k, createEvent as kn, localNetworkCapability as kt, CORE_BLOCK_ADDON_PREFIX as l, userManagementCapability as ln, enumerateSchemaFields as lt, DeclaredDevices as m, errMsg as mn, filesystemBrowseCapability as mt, AlertSchema as n, snapshotCapability as nn, deviceExtensionCapability as nt, CAMERA_SWITCH_ORDER as o, storageProviderCapability as on, doorbellCapability as ot, DERIVED_CAMERA_SILENCED_CAP_NAMES as p, withLocationMode as pn, extractNestedAddonId as pt, coreBlockAddonId as q, resolveBucketMs as qt, ApiKeyRecordSchema as r, storageCapability as rn, deviceManagerCapability as rt, CAP_NAMES_WITH_STATUS as s, streamCatalogCapability as sn, enumerateInferenceDevices as st, ALL_CAPABILITY_DEFINITIONS as t, siteZoneKey as tn, deriveBatteryPresence as tt, CoreBlockSchema as u, vectorDimFromBase64 as un, evaluateSensorEdge as ut, LegacyStorageLocationDefaultSchema as v, DEVICE_SETTINGS_CONTRIBUTION_METHODS as vn, isArrayOutputSchema as vt, REDACTED_SECRET as w, ReadinessTimeoutError as wn, isVoidInput as wt, MINUTES_PER_DAY as x, DeviceRole as xn, isObjectInput as xt, LocationIconIdSchema as y, DEVICE_STATUS_METHOD as yn, isCollectionArrayMethod as yt, alertsCapability as z, readinessKey as zn, normalizeUnit as zt };
+export { compositionSliceKey as $, parseJsonUnknown as $n, objectInputDeclaresRequiredDeviceId as $t, STORAGE_ACCESS_FALLBACK as A, buildFfmpegArgs as An, isArrayOutputSchema as At, addonWidgetsCapability as B, WELL_KNOWN_TAB_MAP as Bn, lifecycleJobSchema as Bt, MINUTES_PER_DAY as C, userManagementCapability as Cn, evictionPolicyOfLocation as Ct, RUNTIME_DEFAULTS as D, vectorStoreCapability as Dn, foldSnapshotByFunction as Dt, REDACTED_SECRET as E, vectorIndexDimConflictError as En, filesystemBrowseCapability as Et, StorageLocationTypeSchema as F, DeviceFeature as Fn, isSourceCap as Ft, batteryCapability as G, emitDownForOwnedCaps as Gn, looseSchema as Gt, authProviderCapability as H, asNumber as Hn, locationIconKey as Ht, StorageMigrationJobSchema as I, DeviceRole as In, isVoidInput as It, cameraGridLayoutCapability as J, hydrateSchema as Jn, metricsProviderCapability as Jt, buildCapabilityLookup as K, emitReadiness as Kn, mayReadLocation as Kt, UserRecordSchema as L, DeviceType as Ln, kebabToCamel as Lt, ScopedTokenSchema as M, DATAPLANE_SECRET_HEADER as Mn, isLocationEnabled as Mt, StorageCleanupJobSchema as N, DEVICE_SETTINGS_CONTRIBUTION_METHODS as Nn, isObjectInput as Nt, RecordingStatusSchema as O, withLocationMode as On, formatMinutes as Ot, StorageLocationModeSchema as P, DEVICE_STATUS_METHOD as Pn, isSameAddonId as Pt, composerCapability as Q, parseJsonObject as Qn, objectInputDeclaresAddonId as Qt, addonPagesCapability as R, ReadinessRegistry as Rn, legacyAutoLinkIds as Rt, METHOD_ACCESS_MAP as S, toExpressionValue as Sn, evaluateSensorEdge as St, RECORDING_SOURCE_CAMSTACK_ADDON as T, vectorDimFromBase64 as Tn, extractNestedAddonId as Tt, backupCapability as U, asString as Un, logDestinationCapability as Ut, alertsCapability as V, asJsonObject as Vn, localNetworkCapability as Vt, bareAddonId as W, createEvent as Wn, logLevelAtMost as Wt, composedDeviceRef as X, isEvent as Xn, motionCapability as Xt, collectSecretConfigKeys as Y, isDeviceConfigCap as Yn, modeMayWrite as Yt, composedDeviceStableId as Z, nodePin as Zn, normalizeUnit as Zt, DeviceStatusSchema as _, storageMigrationCapability as _n, doorbellCapability as _t, BatteryStatusSchema as a, reducePoints as an, coreBlockSourceKind as at, LegacyStorageLocationDefaultSchema as b, streamCatalogCapability as bn, enumerateSchemaFields as bt, COMPOSER_ADDON_ID as c, resolveMethodAuth as cn, dataStoreProviderCapability as ct, CORE_BLOCK_ADDON_PREFIX as d, scopesAllowDeviceCap as dn, defineExtensionSlotProvider as dt, parseStreamParamsFormPatch as en, readinessKey as er, compositionSourceKey as et, CoreBlockSchema as f, scoreRuntimes as fn, deriveBatteryPresence as ft, DeclaredDevices as g, storageCapability as gn, deviceStatusCapability as gt, DERIVED_CAMERA_SILENCED_CAP_NAMES as h, snapshotCapability as hn, deviceStateCapability as ht, BaseDevice as i, ptzAutotrackCapability as in, EventCategory as ir, coreBlockIdFromAddonId as it, STREAM_PROFILE_META as j, BaseAddon as jn, isCollectionArrayMethod as jt, SOURCE_CAPS as k, errMsg as kn, gbToBytes as kt, COMPOSER_RUNNER_ID as l, runtimeStatePolicyFor as ln, declarationOwnerNodeId as lt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as m, siteZoneKey as mn, deviceManagerCapability as mt, AlertSchema as n, platformProbeCapability as nn, scopeKey as nr, coreBlockAddonId as nt, CAMERA_SWITCH_ORDER as o, resolveBucketMs as on, coreBlocksCapability as ot, DAY_NAMES as p, settingsStoreCapability as pn, deviceExtensionCapability as pt, buildStreamParamsConfigSchema as q, expandCapMethods as qn, mayWriteToLocation as qt, ApiKeyRecordSchema as r, procedureAuthKey as rn, sleep as rr, coreBlockComposition as rt, CAP_NAMES_WITH_STATUS as s, resolveLocationMode as sn, createDeviceExtensionProvider as st, ALL_CAPABILITY_DEFINITIONS as t, planComposition as tn, resolveCapMount as tr, compositionSourceRefs as tt, CORE_BLOCKS_ADDON_ID as u, scopesAllowAddon as un, decodeVectorBase64 as ut, FIRST_LEVEL_MACRO_CLASSES as v, storageOccupancyCapability as vn, enumerateInferenceDevices as vt, MOTION_CLOSE_AFTER_MS as w, validateComposition as wn, expandContainer as wt, LocationIconIdSchema as x, streamQualityLabel as xn, evaluateCompositionField as xt, LOG_LEVEL_RANK as y, storageProviderCapability as yn, enumerateItemArrayFields as yt, addonSettingsCapability as z, ReadinessTimeoutError as zn, legacyModeOf as zt };