@camstack/addon-post-analysis 1.2.288 → 1.2.290

package/dist/{clip-model-registry-eFgKIlKE.js → clip-model-registry--sFeijO7.js}

@@ -10205,6 +10205,48 @@ var ModelProviderIdSchema = _enum([
 	"scrypted",
 	"custom"
 ]);
+/**
+* The licence of a model, as a record rather than a bare SPDX string: a
+* permissive CODE licence routinely sits on top of restrictive WEIGHTS or
+* DATA, and the obligations (attribution, modification notices, source offers)
+* are per upstream. A persisted custom-model row written when this field was a
+* string still parses — the string is lifted into `{ weights }`.
+*
+* Every licence surface (the admin "Models and licenses" page,
+* `THIRD_PARTY_MODELS.md`, the Hugging Face model table) is GENERATED from
+* these records by `scripts/gen-model-licenses.ts` (D661).
+*/
+var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { weights: value } : value, object({
+	/** SPDX id of the WEIGHTS' terms, a `LicenseRef-*` for non-SPDX terms, or `UNKNOWN`. */
+	weights: string().min(1),
+	/** SPDX id of the upstream code that defines / trained the network. */
+	code: string().min(1).optional(),
+	/** Training data whose terms add obligations (attribution, non-commercial). */
+	data: object({
+		name: string().min(1),
+		terms: string().min(1),
+		url: string().url().optional()
+	}).optional(),
+	/** The project the weights come from. Required on built-in entries (guard). */
+	upstream: object({
+		name: string().min(1),
+		url: string().url()
+	}).optional(),
+	/** Where the licence text governing the weights is published. */
+	url: string().url().optional(),
+	/** Attribution the licence REQUIRES, verbatim. */
+	attribution: string().min(1).optional(),
+	/** What CamStack changed. Required when `hosting` is `camstack-hf` (guard). */
+	modifications: string().min(1).optional(),
+	/** Who serves the file a node downloads. */
+	hosting: _enum([
+		"camstack-hf",
+		"third-party",
+		"built-in"
+	]).optional(),
+	/** True when the weights or their data forbid commercial use. */
+	nonCommercial: boolean().optional()
+}));
 var ModelCatalogEntrySchema = object({
 	id: string(),
 	name: string(),
@@ -10260,6 +10302,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):
@@ -10293,11 +10345,11 @@ var ModelCatalogEntrySchema = object({
 		p95LatencyMs: record(string(), number()).optional()
 	}).optional(),
 	/**
-	* SPDX-ish license id of the model weights (e.g. `AGPL-3.0` for Ultralytics
-	* YOLO26, `GPL-3.0` for YOLOv9, `Apache-2.0` for D-FINE/RF-DETR). Matters for
-	* the retraining addon and any future commercial distribution.
+	* The model's licence record — see {@link ModelLicenseSchema}. Optional in
+	* the schema (a custom model's author may state none); REQUIRED and complete
+	* on every built-in catalog entry (`scripts/check-catalog-licence.ts`).
 	*/
-	license: string().optional(),
+	license: ModelLicenseSchema.optional(),
 	/**
 	* Variant-selector grouping. The UI groups models by `family` + `tier` and
 	* offers `precision` / `optimization` as variant axes WITHIN a tier — so all
@@ -10392,23 +10444,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;
@@ -10424,6 +10459,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: {
@@ -10524,6 +10563,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));
@@ -11138,7 +11211,7 @@ var AutomationActionSchema = discriminatedUnion("kind", [
 		code: string().min(1).max(2e4)
 	})
 ]);
-object({
+var AutomationRecipeSchema = object({
 	triggers: array(AutomationTriggerSchema),
 	conditions: AutomationConditionSchema.optional(),
 	actions: array(AutomationActionSchema)
@@ -13314,6 +13387,195 @@ var cameraStreamsCapability = {
 function kebabToCamel(s) {
 	return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
+/** 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)]);
@@ -13340,6 +13602,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(),
@@ -13355,8 +13641,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(),
@@ -13394,7 +13710,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`)
@@ -19438,8 +19819,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",
@@ -24071,7 +24452,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({
@@ -39985,6 +40367,38 @@ var zoneRulesCapability = {
 	*/
 	durability: "restored"
 };
+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}`;
 /**
 * Most specific first. Extending this list is how a new device kind becomes
 * gateable; nothing else needs to change.
@@ -43386,6 +43800,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",
@@ -43446,6 +43872,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",
@@ -43458,6 +43890,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",
@@ -43470,6 +43908,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",
@@ -43488,6 +43932,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",
@@ -54115,6 +54571,43 @@ async function readClusterModelPinStrict(api, stepId) {
 		reason: choice.reason
 	};
 }
+var APPLE_MOBILECLIP_AMLR = {
+	weights: "LicenseRef-Apple-AMLR",
+	code: "MIT",
+	upstream: {
+		name: "Apple ml-mobileclip",
+		url: "https://github.com/apple/ml-mobileclip"
+	},
+	url: "https://github.com/apple/ml-mobileclip/blob/main/LICENSE_MODELS",
+	attribution: "Apple Machine Learning Research Model is licensed under the Apple Machine Learning Research Model License Agreement.",
+	modifications: "model derivative: vision encoders converted to OpenVINO IR and CoreML FP16",
+	hosting: "camstack-hf",
+	nonCommercial: true
+};
+var APPLE_MOBILECLIP_TEXT_AMLR = {
+	...APPLE_MOBILECLIP_AMLR,
+	modifications: "model derivative: text encoders quantised to INT8 ONNX and converted to OpenVINO IR"
+};
+var SIGLIP2_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	data: {
+		name: "WebLI",
+		terms: "Google internal, not released"
+	},
+	upstream: {
+		name: "Google SigLIP 2 (google/siglip2-base-patch16-224)",
+		url: "https://huggingface.co/google/siglip2-base-patch16-224"
+	},
+	url: "https://huggingface.co/google/siglip2-base-patch16-224",
+	attribution: "SigLIP 2 © Google LLC, Apache-2.0.",
+	modifications: "input scaling y = 2x - 1 baked ahead of the patch embedding; converted to OpenVINO IR and CoreML FP16, an FP32 ONNX hosted as the verification reference (scripts/build-siglip2-model.py)",
+	hosting: "camstack-hf"
+};
+var SIGLIP2_TEXT_APACHE = {
+	...SIGLIP2_APACHE,
+	modifications: "input sliced to the model's 64 positions in the graph; ONNX weights FP16, OpenVINO IR and CoreML FP16; a Lowercase normalizer prepended to the Gemma tokenizer (scripts/build-siglip2-model.py)"
+};
 //#endregion
 //#region src/embedding-encoder/catalogs/embedding-models.ts
 var HF_REPO = "camstack/camstack-models";
@@ -54190,6 +54683,7 @@ var SIGLIP2_META = {
 var CLIP_IMAGE_MODELS = [
 	{
 		id: "mobileclip-s1",
+		license: APPLE_MOBILECLIP_AMLR,
 		name: "MobileCLIP S1",
 		description: "Apple MobileCLIP S1 — balanced vision encoder, 512-dim, 256×256 (fp16 OpenVINO/CoreML)",
 		inputSize: {
@@ -54212,6 +54706,7 @@ var CLIP_IMAGE_MODELS = [
 	},
 	{
 		id: "mobileclip-s2",
+		license: APPLE_MOBILECLIP_AMLR,
 		name: "MobileCLIP S2",
 		description: "Apple MobileCLIP S2 — high-accuracy vision encoder, 512-dim, 256×256 (fp16 OpenVINO/CoreML)",
 		inputSize: {
@@ -54234,6 +54729,7 @@ var CLIP_IMAGE_MODELS = [
 	},
 	{
 		id: "siglip2-b16-224",
+		license: SIGLIP2_APACHE,
 		name: "SigLIP2 B/16",
 		description: "Google SigLIP2 base, patch 16, 224×224 — Apache-2.0 vision encoder, 768-dim (fp16 OpenVINO/CoreML)",
 		inputSize: {
@@ -54242,7 +54738,6 @@ var CLIP_IMAGE_MODELS = [
 		},
 		labels: [],
 		inputNormalization: "none",
-		license: "Apache-2.0",
 		clip: SIGLIP2_META,
 		formats: {
 			openvino: ovFormat(hf("clip/siglip2/openvino/camstack-siglip2-b16-224-vision.xml"), 186),
@@ -54266,6 +54761,7 @@ var CLIP_IMAGE_MODELS = [
 var CLIP_TEXT_MODELS = [
 	{
 		id: "mobileclip-s1-text",
+		license: APPLE_MOBILECLIP_TEXT_AMLR,
 		name: "MobileCLIP S1 Text Encoder",
 		description: "Text encoder for MobileCLIP S1, 512-dim, int8 quantized (61 MB)",
 		inputSize: {
@@ -54284,6 +54780,7 @@ var CLIP_TEXT_MODELS = [
 	},
 	{
 		id: "mobileclip-s2-text",
+		license: APPLE_MOBILECLIP_TEXT_AMLR,
 		name: "MobileCLIP S2 Text Encoder",
 		description: "Text encoder for MobileCLIP S2, 512-dim, int8 quantized (61 MB)",
 		inputSize: {
@@ -54302,6 +54799,7 @@ var CLIP_TEXT_MODELS = [
 	},
 	{
 		id: "siglip2-b16-224-text",
+		license: SIGLIP2_TEXT_APACHE,
 		name: "SigLIP2 B/16 Text Encoder",
 		description: "Text encoder for SigLIP2 B/16, 768-dim, fp16 (565 MB)",
 		inputSize: {
@@ -54309,7 +54807,6 @@ var CLIP_TEXT_MODELS = [
 			height: 0
 		},
 		labels: [],
-		license: "Apache-2.0",
 		formats: {
 			onnx: {
 				url: hf("clip/siglip2/onnx/camstack-siglip2-b16-224-text.onnx"),