@camstack/addon-model-studio 1.1.177 → 1.1.179

package/dist/model-studio.addon.mjs

@@ -10275,6 +10275,16 @@ var ModelCatalogEntrySchema = object({
 	*/
 	postprocessor: custom().optional(),
 	/**
+	* Per-MODEL default confidence floor. Absent ⇒ the step's
+	* `StepDefinition.defaultConfidence` applies. A score is a property of one
+	* model's output scale, not of the step slot it sits in: YuNet's
+	* `sqrt(cls·obj)` is not SCRFD's score, and inheriting SCRFD's 0.5 filled the
+	* face gallery with wheels and hands (D662, amends D645). An operator's
+	* explicit value still wins over it. Resolved in ONE place —
+	* `addon-pipeline/.../registry/effective-confidence.ts`.
+	*/
+	defaultConfidence: number().min(0).max(1).optional(),
+	/**
 	* When true, the executor produces a landmark-aligned crop (similarity warp
 	* onto the canonical template) before this step runs, instead of a plain
 	* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
@@ -10408,23 +10418,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;
@@ -10440,6 +10433,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: {
@@ -10540,6 +10537,40 @@ var table = {
 			if (from === to) return x;
 			throw new ExpressionEvalError("convert: unit conversion table not installed");
 		}
+	},
+	any: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => args.map((a, i) => asBoolean$1(a, "any", i)).some((b) => b)
+	},
+	all: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => args.map((a, i) => asBoolean$1(a, "all", i)).every((b) => b)
+	},
+	within: {
+		minArgs: 2,
+		maxArgs: 2,
+		apply: (args, hooks) => {
+			const windowMs = asFiniteNumber(args[1], "within", 1);
+			if (windowMs < 0) throw new ExpressionEvalError("within: the window must not be negative");
+			const at = args[0];
+			if (at === null) return false;
+			const ts = asFiniteNumber(at, "within", 0);
+			const now = hooks.now;
+			if (now === void 0 || !Number.isFinite(now)) throw new ExpressionEvalError("within: no clock was supplied to this evaluation");
+			const inside = now - ts <= windowMs;
+			if (inside) hooks.noteDeadline?.(ts + windowMs + 1);
+			return inside;
+		}
+	},
+	latest: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => {
+			const present = args.flatMap((a, i) => a === null ? [] : [asFiniteNumber(a, "latest", i)]);
+			return present.length === 0 ? null : finiteResult(Math.max(...present), "latest");
+		}
 	}
 };
 Object.freeze(Object.assign(Object.create(null), table));
@@ -11154,7 +11185,7 @@ var AutomationActionSchema = discriminatedUnion("kind", [
 		code: string().min(1).max(2e4)
 	})
 ]);
-object({
+var AutomationRecipeSchema = object({
 	triggers: array(AutomationTriggerSchema),
 	conditions: AutomationConditionSchema.optional(),
 	actions: array(AutomationActionSchema)
@@ -13222,6 +13253,195 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
 	}),
 	lastChangedAt: number()
 });
+/** 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 = object({
+	/** The owning addon; `stableId` is unique only within it. */
+	addonId: string().min(1),
+	stableId: string().min(1)
+});
+/** One field of one capability of one source device. */
+var CompositionFieldReadSchema = object({
+	source: CompositionSourceRefSchema,
+	cap: string().min(1),
+	/** Dotted path into the source cap's runtime-state slice. */
+	fieldPath: string().min(1)
+});
+/** `from`: copy one source field verbatim. It is also an expression's `from` binding. */
+var CompositionFromSourceSchema = CompositionFieldReadSchema.extend({ kind: literal("from") });
+var CompositionBindingSchema = discriminatedUnion("kind", [CompositionFromSourceSchema, object({
+	kind: literal("literal"),
+	value: union([
+		string(),
+		number(),
+		boolean(),
+		_null()
+	])
+})]);
+/**
+* `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 = object({
+	kind: literal("expression"),
+	expr: string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
+	bindings: record(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 = object({
+	kind: literal("code"),
+	code: string().min(1).max(MAX_COMPOSITION_CODE_LENGTH)
+});
+var CompositionFieldSourceSchema = discriminatedUnion("kind", [
+	CompositionFromSourceSchema,
+	CompositionExpressionSourceSchema,
+	CompositionCodeSourceSchema
+]);
+var CompositionCommandTargetSchema = discriminatedUnion("kind", [object({
+	kind: literal("forward"),
+	source: CompositionSourceRefSchema,
+	cap: string().min(1),
+	method: string().min(1)
+}), CompositionCodeSourceSchema]);
+var CompositionFeatureSchema = discriminatedUnion("kind", [object({
+	kind: literal("fields"),
+	cap: string().min(1),
+	fields: record(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: record(string().min(1), CompositionCommandTargetSchema).optional()
+}), object({
+	kind: literal("passthrough"),
+	cap: string().min(1),
+	source: CompositionSourceRefSchema
+})]);
+var CompositionSchema = object({
+	target: discriminatedUnion("kind", [object({
+		kind: literal("new"),
+		type: _enum(DeviceType),
+		role: _enum(DeviceRole).optional()
+	}), object({
+		kind: literal("existing"),
+		device: CompositionSourceRefSchema
+	})]),
+	features: 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);
+	});
+});
+/** One refusal, named (D391). `path` points into the composition, e.g. `features[0].fields.celsius`. */
+var CompositionProblemSchema = object({
+	code: _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"
+	]),
+	path: string(),
+	message: string()
+});
+var CompositionFieldKindSchema = _enum([
+	"string",
+	"number",
+	"boolean",
+	"enum"
+]);
+/** How a field says "unavailable": `null` when its schema allows it, else the device goes offline (D393). */
+var CompositionUnavailableModeSchema = _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 = _enum([
+	"derived",
+	"clock",
+	"constant"
+]);
+var CompositionFieldPlanSchema = object({
+	cap: string(),
+	path: 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: number().int().nonnegative(),
+	kind: CompositionFieldKindSchema,
+	nullable: boolean(),
+	required: boolean(),
+	unavailable: CompositionUnavailableModeSchema,
+	role: CompositionFieldRoleSchema,
+	source: CompositionFieldSourceSchema,
+	reads: array(CompositionFieldReadSchema)
+});
+var CompositionValidationSchema = object({
+	ok: boolean(),
+	problems: array(CompositionProblemSchema),
+	fields: array(CompositionFieldPlanSchema)
+});
+/** Mirrors `CoreBlockStatus`, pinned by `core-blocks-source.spec.ts` (Task 11). */
+var CompositionRunStatusSchema = _enum([
+	"stopped",
+	"starting",
+	"running",
+	"failed"
+]);
+var CompositionFieldStateKindSchema = _enum([
+	"fresh",
+	"stale",
+	"unavailable"
+]);
+var CompositionFieldStateSchema = object({
+	cap: string(),
+	path: string(),
+	state: CompositionFieldStateKindSchema,
+	/** `null` whenever `state === 'unavailable'`; never a plausible stand-in (D393). */
+	value: union([
+		string(),
+		number(),
+		boolean(),
+		_null()
+	]),
+	reason: string().optional()
+});
+var CompositionBlockStateSchema = object({
+	blockId: string(),
+	deviceId: number().nullable(),
+	status: CompositionRunStatusSchema,
+	reason: string().optional(),
+	fields: array(CompositionFieldStateSchema)
+});
 /** Where a block runs. The operator chooses — a block driving a device on an
 *  agent is the reason placement is not fixed to the hub. */
 var CoreBlockPlacementSchema = union([literal("hub"), string().min(1)]);
@@ -13248,6 +13468,30 @@ var CoreBlockInputSchema = object({
 	*/
 	integrationId: 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 = discriminatedUnion("kind", [
+	object({ kind: literal("code") }),
+	object({
+		kind: literal("recipe"),
+		recipe: AutomationRecipeSchema
+	}),
+	object({
+		kind: literal("composition"),
+		composition: CompositionSchema
+	})
+]);
+/** The client-authored half of a composition block. No `code`, no placement (hub-only; Phase 7). */
+var CompositionBlockInputSchema = object({
+	name: string().min(1).max(120),
+	enabled: boolean(),
+	composition: CompositionSchema
+});
 /** A stored block. */
 var CoreBlockSchema = CoreBlockInputSchema.extend({
 	id: string(),
@@ -13263,8 +13507,38 @@ var CoreBlockSchema = CoreBlockInputSchema.extend({
 	*/
 	lastError: string().optional(),
 	/** Ms epoch of the last state change. */
-	lastChangedAt: number()
+	lastChangedAt: number(),
+	/** What the block is. Absent means `code` (D659). */
+	source: CoreBlockSourceSchema.optional()
+});
+/** A stored composition block and what the composer says about it. */
+var CompositionViewSchema = object({
+	block: CoreBlockSchema,
+	state: discriminatedUnion("kind", [object({
+		kind: literal("answered"),
+		state: CompositionBlockStateSchema.nullable()
+	}), object({
+		kind: literal("unreachable"),
+		error: string()
+	})])
+});
+/**
+* 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 = object({
+	state: literal("not-loaded"),
+	reason: string()
 });
+var CompositionListReadSchema = discriminatedUnion("state", [object({
+	state: literal("loaded"),
+	views: array(CompositionViewSchema)
+}), CompositionsNotLoadedSchema]);
+var CompositionGetReadSchema = discriminatedUnion("state", [object({
+	state: literal("loaded"),
+	view: CompositionViewSchema.nullable()
+}), CompositionsNotLoadedSchema]);
 /** What a compile attempt produced. */
 var CoreBlockCompileResultSchema = object({
 	ok: boolean(),
@@ -13302,7 +13576,72 @@ method(object({}), object({ blocks: array(CoreBlockSchema) }), { auth: "admin" }
 }), method(object({}), object({ libs: array(object({
 	filePath: string(),
 	content: string()
-})) }), { auth: "admin" });
+})) }), { auth: "admin" }), method(object({ block: CompositionBlockInputSchema }), object({ block: CoreBlockSchema }), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({
+	blockId: string(),
+	expectedUpdatedAt: number(),
+	block: CompositionBlockInputSchema.partial()
+}), object({ block: CoreBlockSchema }), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({ blockId: string() }), CompositionGetReadSchema, { auth: "admin" }), method(object({}), CompositionListReadSchema, { auth: "admin" }), method(object({
+	composition: CompositionSchema,
+	blockId: string().optional()
+}), CompositionValidationSchema, {
+	kind: "mutation",
+	auth: "admin",
+	access: "view"
+});
+var ComposerBlockSchema = object({
+	id: string().min(1),
+	name: string().min(1).max(120),
+	enabled: boolean(),
+	updatedAt: 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 = object({
+	id: string().min(1),
+	/** The row's stored name column; null when even that is unreadable (the device keeps the name it has). */
+	name: string().nullable(),
+	/** The parse error, in the operator's words. */
+	error: string()
+});
+method(object({
+	/** The shared Blocks integration; null until `core-blocks` has reconciled it. */
+	integrationId: string().nullable(),
+	/** False when the `core_blocks` read failed: then nothing may be withdrawn (D49). */
+	storeLoaded: boolean(),
+	blocks: array(ComposerBlockSchema),
+	/** Operator restarts: rebuild these runtimes and re-resolve their sources. Stores nothing (D62). */
+	restartBlockIds: array(string()),
+	/** Composition rows that exist but do not parse: held, never withdrawn, reported failed. */
+	unreadableBlocks: array(ComposerUnreadableBlockSchema)
+}), object({
+	blocks: array(object({
+		blockId: string(),
+		status: CompositionRunStatusSchema,
+		reason: string().optional()
+	})),
+	/**
+	* 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: boolean()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ blockIds: array(string()) }), object({ states: array(CompositionBlockStateSchema) }), { auth: "admin" });
 /**
 * `custom-model-registry` — collection cap exposing operator-registered
 * custom detection models. Each provider (today: `addon-model-studio`)
@@ -19069,8 +19408,8 @@ var NcTestResultSchema = object({
 	className: string().optional(),
 	label: 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 = _enum([
 	"detection",
@@ -21688,7 +22027,15 @@ var RebuildObjectEmbeddingsInput = object({
 	* force is logged at start and finish so a deliberately slow pass reads
 	* differently from a stalled one.
 	*/
-	pacingMs: number().int().nonnegative().optional()
+	pacingMs: number().int().nonnegative().optional(),
+	/**
+	* Re-embed ONLY the tracks whose vector is ALREADY in the pinned model's
+	* space (D664) — the in-space skip inverted. It exists to redo vectors
+	* written from the wrong box, which a normal pass would skip as done
+	* forever. Requires `maxTracks`: a forced pass without a bound is refused
+	* (`force-requires-max-tracks`).
+	*/
+	force: boolean().optional()
 });
 /**
 * Result of emptying the CLIP index.
@@ -21724,6 +22071,7 @@ var WipeObjectEmbeddingsResultSchema = object({
 *    - `reads-disagree` — the two reads named different choices.
 *  - `not-a-clip-model` — the CONFIRMED id has no CLIP metadata, so there is no
 *    index to fill and no dimension to check against (D649).
+*  - `force-requires-max-tracks` — `force: true` with no `maxTracks` (D664).
 */
 var RebuildObjectEmbeddingsRefusalSchema = _enum([
 	"stores-unavailable",
@@ -21731,7 +22079,8 @@ var RebuildObjectEmbeddingsRefusalSchema = _enum([
 	"method-unavailable",
 	"read-failed",
 	"reads-disagree",
-	"not-a-clip-model"
+	"not-a-clip-model",
+	"force-requires-max-tracks"
 ]);
 /**
 * Acknowledgement that a rebuild STARTED.
@@ -21756,11 +22105,32 @@ var RebuildStatusSchema = object({
 	running: boolean(),
 	scanned: number(),
 	rebuilt: number(),
-	/** Tracks whose key frame is gone — nothing to re-embed from. */
+	/** Tracks whose key frame is gone — nothing to re-embed from. Pixels ONLY:
+	*  `missingEvent` is its own field since D664, never summed in. */
 	missingKeyFrame: number(),
-	/** Tracks with no usable detection box. */
+	/** Tracks with no object event at all (D664). */
+	missingEvent: number(),
+	/** Tracks with no box measured on the pixels to cut — see `boxSource.refused`. */
 	missingBbox: number(),
 	/**
+	* Which rule placed each judged track's box (D664): the key frame row's own
+	* `subjectBox`, `track.positions` at exactly its instant (older key frames),
+	* the event box (a key frame recovered from the recording, at the event's
+	* instant), or `refused` by name — the reasons are in the tagged log lines.
+	*/
+	boxSource: object({
+		subjectBox: number(),
+		positions: number(),
+		event: number(),
+		refused: number()
+	}),
+	/** Tracks skipped because their vector is already in the pinned space. */
+	alreadyInSpace: number(),
+	/** Whether the current / last pass was a `force` pass; `null` before any (D664). */
+	force: boolean().nullable(),
+	/** In-space tracks a `force` pass selected for re-embedding. */
+	forcedInSpace: number(),
+	/**
 	* Tracks an executing node REFUSED rather than broke on — an unreadable key
 	* frame, a step that threw. Separate from `failed` because the remedy is
 	* different, and because a whole camera silently contributing zero vectors
@@ -22265,7 +22635,8 @@ var PipelineModelOptionSchema = object({
 	})),
 	group: ModelVariantGroupSchema.optional(),
 	legacy: boolean().optional(),
-	provider: ModelProviderIdSchema.optional()
+	provider: ModelProviderIdSchema.optional(),
+	defaultConfidence: number().optional()
 });
 var ConfigFieldBridge = custom();
 var PipelineAddonSchemaSchema = object({
@@ -35140,6 +35511,38 @@ DeviceType.Camera, method(object({
 	detection: array(ZoneRuleSchema).readonly(),
 	package: array(ZoneRuleSchema).readonly()
 });
+var NUMBER = {
+	kind: "fixed",
+	result: ["number"]
+};
+var BOOLEAN = {
+	kind: "fixed",
+	result: ["boolean"]
+};
+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"]
+	}
+});
+`${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
 /**
 * Accessory device helpers — shared across drivers.
 *
@@ -37448,6 +37851,18 @@ 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",
@@ -37508,6 +37923,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"coreBlocks.createComposition": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"coreBlocks.delete": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -37520,6 +37941,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"coreBlocks.getComposition": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"coreBlocks.getTypeDefs": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -37532,6 +37959,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"coreBlocks.listCompositions": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"coreBlocks.restart": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -37550,6 +37983,18 @@ 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",

package/dist/{player-overlays-ClBjPU73.mjs → player-overlays-D2YtQYEE.mjs}

@@ -1,5 +1,5 @@
 import { h as e, l as t, u as n, y as r } from "./_virtual_mf___mfe_internal__addon_model_studio_page__loadShare__react__loadShare__.js-DJDHChgO.mjs";
-import { o as i, s as a } from "./responsive-DlMFoaeo.mjs";
+import { o as i, s as a } from "./responsive-i8VV1SdO.mjs";
 import { n as o, r as s, t as c } from "./_virtual_mf___mfe_internal__addon_model_studio_page__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-ds_Ehzaa.mjs";
 var l = a("chevron-down", [["path", {
 	d: "m6 9 6 6 6-6",

package/dist/remoteEntry.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_model_studio_page__remoteEntry_js-C_0n96Ey.mjs";
+import { n as e, t } from "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_model_studio_page__remoteEntry_js-DgFB1f3m.mjs";
 export { t as get, e as init };

package/dist/{responsive-DlMFoaeo.mjs → responsive-i8VV1SdO.mjs}

@@ -1,6 +1,6 @@
 import { c as e, g as t, h as n, l as r, n as i, p as a, r as o, t as s, u as c, y as l } from "./_virtual_mf___mfe_internal__addon_model_studio_page__loadShare__react__loadShare__.js-DJDHChgO.mjs";
 import "./_virtual_mf___mfe_internal__addon_model_studio_page__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-ds_Ehzaa.mjs";
-import { n as u } from "./_virtual_mf___mfe_internal__addon_model_studio_page__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-CIxAEvWm.mjs";
+import { n as u } from "./_virtual_mf___mfe_internal__addon_model_studio_page__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-B8ssxRgI.mjs";
 //#region ../../node_modules/lucide-react/dist/esm/shared/src/utils/mergeClasses.js
 l();
 var d = (...e) => e.filter((e, t, n) => !!e && e.trim() !== "" && n.indexOf(e) === t).join(" ").trim(), f = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), p = (e) => e.replace(/^([A-Z])|[\s-_]+(\w)/g, (e, t, n) => n ? n.toUpperCase() : t.toLowerCase()), m = (e) => {

package/dist/{scene-monitor-copy-CTpOVqsU.mjs → scene-monitor-copy-BktPixFQ.mjs}

@@ -1,5 +1,5 @@
 import { c as e, h as t, p as n, y as r } from "./_virtual_mf___mfe_internal__addon_model_studio_page__loadShare__react__loadShare__.js-DJDHChgO.mjs";
-import { s as i } from "./responsive-DlMFoaeo.mjs";
+import { s as i } from "./responsive-i8VV1SdO.mjs";
 var a = i("camera", [["path", {
 	d: "M13.997 4a2 2 0 0 1 1.76 1.05l.486.9A2 2 0 0 0 18.003 7H20a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9a2 2 0 0 1 2-2h1.997a2 2 0 0 0 1.759-1.048l.489-.904A2 2 0 0 1 10.004 4z",
 	key: "18u6gg"

package/dist/{square-C3Zmy4Ca.mjs → square-COwEP7Tf.mjs}

@@ -1,4 +1,4 @@
-import { s as e } from "./responsive-DlMFoaeo.mjs";
+import { s as e } from "./responsive-i8VV1SdO.mjs";
 var t = e("eye-off", [
 	["path", {
 		d: "M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49",

package/dist/{trash-2-BD__w_cV.mjs → trash-2-9RsOz0YH.mjs}

@@ -1,4 +1,4 @@
-import { s as e } from "./responsive-DlMFoaeo.mjs";
+import { s as e } from "./responsive-i8VV1SdO.mjs";
 var t = e("trash-2", [
 	["path", {
 		d: "M10 11v6",