@camstack/addon-pipeline 1.2.622 → 1.2.623

package/dist/{dist-DUFGDd_2.js → dist-BVo3wa7s.js}

@@ -4724,10 +4724,10 @@ var ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 			return array(this);
 		},
 		or(arg) {
-			return union([this, arg]);
+			return union$1([this, arg]);
 		},
 		and(arg) {
-			return intersection(this, arg);
+			return intersection$1(this, arg);
 		},
 		transform(tx) {
 			return pipe(this, transform(tx));
@@ -5198,7 +5198,7 @@ var ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
 	inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
 	inst.options = def.options;
 });
-function union(options, params) {
+function union$1(options, params) {
 	return new ZodUnion({
 		type: "union",
 		options,
@@ -5222,7 +5222,7 @@ var ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def)
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
 });
-function intersection(left, right) {
+function intersection$1(left, right) {
 	return new ZodIntersection({
 		type: "intersection",
 		left,
@@ -8180,7 +8180,7 @@ var RecordIndexSchema = object({
 	fields: array(RecordFieldPathSchema).min(1).max(4),
 	unique: boolean().optional()
 }).strict();
-var RecordRetentionSchema = union([
+var RecordRetentionSchema = union$1([
 	object({
 		ttlMs: number().int().positive(),
 		from: _enum(["at", "write"])
@@ -8333,7 +8333,7 @@ var CAM_PROFILE_ORDER = [
 * the operator picked. Today's one user is the audio analyser, whose rule is
 * "the lowest AVAILABLE native rung" (D537).
 */
-var AudioStreamPickSchema = union([CamProfileSchema, literal("auto")]);
+var AudioStreamPickSchema = union$1([CamProfileSchema, literal("auto")]);
 var CamStreamKindSchema = _enum([
 	"pull-rtsp",
 	"pull-rtmp",
@@ -8765,7 +8765,7 @@ var ContributionSectionSchema = object({
 	description: string().optional(),
 	style: _enum(["card", "accordion"]).optional(),
 	defaultCollapsed: boolean().optional(),
-	columns: union([
+	columns: union$1([
 		literal(1),
 		literal(2),
 		literal(3),
@@ -8929,7 +8929,7 @@ var HF_REPO = "camstack/camstack-models";
 `${HF_REPO}`;
 object({
 	code: string().regex(/^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/),
-	params: record(string(), union([string(), number()])).optional()
+	params: record(string(), union$1([string(), number()])).optional()
 });
 var CamstackError = class extends Error {
 	i18nCode;
@@ -11032,7 +11032,7 @@ var CompositionFieldReadSchema = object({
 var CompositionFromSourceSchema = CompositionFieldReadSchema.extend({ kind: literal("from") });
 var CompositionBindingSchema = discriminatedUnion("kind", [CompositionFromSourceSchema, object({
 	kind: literal("literal"),
-	value: union([
+	value: union$1([
 		string(),
 		number(),
 		boolean(),
@@ -11227,7 +11227,7 @@ var EncodeProfileSchema = object({
 		*/
 		singleSlicePerFrame: boolean().optional()
 	}),
-	audio: union([literal("passthrough"), object({
+	audio: union$1([literal("passthrough"), object({
 		codec: _enum([
 			"opus",
 			"aac",
@@ -11237,7 +11237,7 @@ var EncodeProfileSchema = object({
 		]),
 		bitrateKbps: number().int().positive().optional(),
 		sampleRateHz: number().int().positive().optional(),
-		channels: union([literal(1), literal(2)]).optional()
+		channels: union$1([literal(1), literal(2)]).optional()
 	})]),
 	/**
 	* ffmpeg input-side args, inserted between the fixed global flags
@@ -13982,7 +13982,7 @@ var StorageDrainProgressSchema = object({
 *
 * The orchestrator's `resolveRef(ref)` handles both cases.
 */
-var StorageLocationRefSchema = union([StorageLocationTypeSchema, string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/)]);
+var StorageLocationRefSchema = union$1([StorageLocationTypeSchema, string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/)]);
 /**
 * `StorageLocationDeclaration` — a single storage-location entry declared by
 * an addon in its `package.json` under `camstack.storageLocations`.
@@ -15338,7 +15338,7 @@ var ViewerFeatureIdSchema = _enum([
 	"scenes"
 ]);
 /** Which devices a viewer reaches: `allow` minus `block`. */
-var ViewerDeviceAllowSchema = union([literal("*"), array(number().int().nonnegative())]);
+var ViewerDeviceAllowSchema = union$1([literal("*"), array(number().int().nonnegative())]);
 /**
 * The viewer grant, stored as ONE row of a user's `scopes`. A principal that
 * holds it is decided by the viewer rules ALONE — any other row it carries is
@@ -15402,8 +15402,8 @@ var MethodAccessSchema = _enum([
 * `access` is REQUIRED with min 1 element. `admin` bypass is the
 * "give me everything" escape; there is no wildcard scope.
 */
-var AllowedProviderSchema = union([literal("*"), array(string())]);
-var AllowedDevicesSchema = record(string(), union([literal("*"), array(string())]));
+var AllowedProviderSchema = union$1([literal("*"), array(string())]);
+var AllowedDevicesSchema = record(string(), union$1([literal("*"), array(string())]));
 var CapScopeSchema = _enum(["device", "system"]);
 /**
 * DeviceSelector (scope model v3 — 2026-08-12).
@@ -15509,7 +15509,7 @@ var TokenScopeSchema = preprocess(migrateLegacyTokenScope, discriminatedUnion("t
 * own rules alone. Kept apart from {@link TokenScope} so every surface that
 * edits capability rows (the scope picker, token minting) keeps its shape.
 */
-var UserScopeSchema = union([ViewerTokenScopeSchema, TokenScopeSchema]);
+var UserScopeSchema = union$1([ViewerTokenScopeSchema, TokenScopeSchema]);
 object({
 	id: string(),
 	username: string(),
@@ -15558,7 +15558,7 @@ var AddonRoutesScopeSchema = object({
 	access: array(MethodAccessSchema).min(1)
 });
 var PreferencesSelfScopeSchema = object({ type: literal("preferences-self") });
-var CredentialScopeSchema = union([
+var CredentialScopeSchema = union$1([
 	literal("*"),
 	ShareViewScopeSchema,
 	AddonRoutesScopeSchema,
@@ -15792,7 +15792,7 @@ object({
 	/** The app executes it itself, silently (D858). */
 	app: AppLoginPathSchema.nullable()
 });
-var ExpressionBindingSourceSchema = union([
+var ExpressionBindingSourceSchema = union$1([
 	object({
 		kind: literal("field").optional(),
 		sourceKey: string(),
@@ -15801,7 +15801,7 @@ var ExpressionBindingSourceSchema = union([
 	}),
 	object({
 		kind: literal("literal"),
-		value: union([
+		value: union$1([
 			string(),
 			number(),
 			boolean(),
@@ -15844,11 +15844,11 @@ var AutomationConditionLeafSchema = object({
 	cap: string().min(1),
 	fieldPath: string().min(1),
 	operator: AutomationConditionOperatorSchema,
-	value: union([
+	value: union$1([
 		string(),
 		number(),
 		boolean(),
-		array(union([string(), number()]))
+		array(union$1([string(), number()]))
 	])
 });
 /**
@@ -15903,7 +15903,7 @@ var AutomationTriggerSchema = discriminatedUnion("kind", [
 		cap: string().min(1),
 		fieldPath: string().min(1),
 		/** Fire when the field takes this value. Omit to fire on any change. */
-		becomes: union([
+		becomes: union$1([
 			string(),
 			number(),
 			boolean()
@@ -15957,7 +15957,7 @@ var AutomationActionSchema = discriminatedUnion("kind", [
 		* or `{ $var }` for the device that triggered the run. An array is
 		* fan-out at codegen — each id gets the same cap.method call.
 		*/
-		deviceId: union([
+		deviceId: union$1([
 			number().int(),
 			array(number().int()).min(1),
 			object({ $var: string().min(1) })
@@ -16125,7 +16125,7 @@ var ConfigSectionWithValuesSchema = object({
 	descriptionKey: string().optional(),
 	style: _enum(["card", "accordion"]).optional(),
 	defaultCollapsed: boolean().optional(),
-	columns: union([
+	columns: union$1([
 		literal(1),
 		literal(2),
 		literal(3),
@@ -16943,7 +16943,7 @@ var CollectionColumnSchema = object({
 	* collection surface simply cannot express their existing tables — which is
 	* why they were still on the uncapped `table*` API.
 	*/
-	defaultValue: union([
+	defaultValue: union$1([
 		string(),
 		number(),
 		boolean()
@@ -17005,7 +17005,7 @@ method(object({
 }), object({ 
 /** The id the row HAS: assigned by SQLite on an insert, or the existing
 *  row's own id on an update. */
-id: union([string(), number()]) }), {
+id: union$1([string(), number()]) }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -17029,7 +17029,7 @@ id: union([string(), number()]) }), {
 * for an absent one, or the ROWID SQLite assigned on an `INTEGER`
 * primary key — which is the only place an auto key is knowable.
 */
-id: union([string(), number()]) }), {
+id: union$1([string(), number()]) }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -19144,7 +19144,7 @@ var CompositionFieldStateSchema = object({
 	item: CompositionFieldItemSchema.optional(),
 	state: CompositionFieldStateKindSchema,
 	/** `null` whenever `state === 'unavailable'`; never a plausible stand-in (D393). */
-	value: union([
+	value: union$1([
 		string(),
 		number(),
 		boolean(),
@@ -19306,7 +19306,7 @@ var RawSecretMigrationReportSchema = object({
 });
 /** 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)]);
+var CoreBlockPlacementSchema = union$1([literal("hub"), string().min(1)]);
 /** What a block's process is doing. Mirrors the addon runner's own lifecycle so
 *  a failing block reads the same way a failing addon does. `degraded` is a
 *  composition on an existing device with a field handed back to the native
@@ -19703,7 +19703,7 @@ method(_void(), EngineInfoSchema, { auth: "admin" }), method(object({
 * for an absent one, or the ROWID SQLite assigned on an `INTEGER`
 * primary key — which is the only place an auto key is knowable.
 */
-id: union([string(), number()]) }), {
+id: union$1([string(), number()]) }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -19711,7 +19711,7 @@ id: union([string(), number()]) }), {
 	collection: string(),
 	conflict: array(string()).readonly(),
 	record: BulkRecordSchema
-}), object({ id: union([string(), number()]) }), {
+}), object({ id: union$1([string(), number()]) }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -19838,20 +19838,20 @@ var RecordViewSchema = object({
 	data: RecordBodySchema
 });
 /** Declared index fields only. Anything else does not compile, by design. */
-var RecordWhereSchema = record(RecordFieldPathSchema, union([
+var RecordWhereSchema = record(RecordFieldPathSchema, union$1([
 	string(),
 	number(),
 	boolean(),
-	object({ in: array(union([
+	object({ in: array(union$1([
 		string(),
 		number(),
 		boolean()
 	])).min(1).max(RECORD_BATCH_MAX) }),
 	object({
-		gt: union([string(), number()]).optional(),
-		gte: union([string(), number()]).optional(),
-		lt: union([string(), number()]).optional(),
-		lte: union([string(), number()]).optional()
+		gt: union$1([string(), number()]).optional(),
+		gte: union$1([string(), number()]).optional(),
+		lt: union$1([string(), number()]).optional(),
+		lte: union$1([string(), number()]).optional()
 	}).refine((r) => Object.keys(r).length > 0, { message: "name at least one bound" })
 ]));
 var KindShape = { kind: RecordKindNameSchema };
@@ -20002,7 +20002,7 @@ method(object({ kinds: record(RecordKindNameSchema, RecordKindDeclarationSchema)
 	groupBy: RecordFieldPathSchema.optional(),
 	where: RecordWhereSchema.optional()
 }), object({ rows: array(object({
-	group: union([
+	group: union$1([
 		string(),
 		number(),
 		_null()
@@ -20348,7 +20348,7 @@ var QueryWindowShape = {
 	scope: string().optional(),
 	from: number(),
 	to: number(),
-	resolution: union([DeviceHistoryResolutionSchema, literal("auto")]).default("auto"),
+	resolution: union$1([DeviceHistoryResolutionSchema, literal("auto")]).default("auto"),
 	maxPoints: number().int().positive().max(5e3).default(1e3)
 };
 var QueryResultSchema = object({
@@ -20357,7 +20357,7 @@ var QueryResultSchema = object({
 	truncated: boolean()
 });
 /** One read of a batch: a device's key or a node's key (exactly one subject). */
-var QueryManyItemSchema = union([object({
+var QueryManyItemSchema = union$1([object({
 	deviceId: number().int(),
 	key: string(),
 	scope: string().optional()
@@ -43309,7 +43309,7 @@ var LlmListModelsResultSchema = discriminatedUnion("ok", [object({
 	code: LlmListModelsErrorCodeSchema,
 	message: string()
 })]);
-var LlmDefaultSelectorSchema = union([object({ consumer: string() }), object({ purpose: _enum(["text", "vision"]) })]);
+var LlmDefaultSelectorSchema = union$1([object({ consumer: string() }), object({ purpose: _enum(["text", "vision"]) })]);
 var LlmDefaultSchema = object({
 	selector: LlmDefaultSelectorSchema,
 	profileId: string()
@@ -43647,7 +43647,7 @@ var LogReadQuerySchema = object({
 	*/
 	fromNodeId: string().min(1).max(200).optional(),
 	/** Any other tag, exact match (AND). */
-	tags: record(string(), union([string(), number()])).optional(),
+	tags: record(string(), union$1([string(), number()])).optional(),
 	/** Severity FLOOR: this level and above. */
 	level: LogLevelSchema.optional(),
 	/** Case-insensitive substring over message, scope, tag values and meta values. */
@@ -43674,7 +43674,7 @@ var LogReadResultSchema = object({
 		level: LogLevelSchema,
 		scope: string().optional(),
 		message: string(),
-		tags: record(string(), union([string(), number()])).optional(),
+		tags: record(string(), union$1([string(), number()])).optional(),
 		meta: record(string(), unknown()).optional()
 	})),
 	/** Pass as `before` for the next older page; null when nothing older exists. */
@@ -48165,7 +48165,7 @@ var OauthIntegrationDescriptorSchema = object({
 	* The value is baked into the authorization code at `/authorize` and travels
 	* on the tokens, so editing this field changes FUTURE links only.
 	*/
-	refreshTokenTtlSec: union([number().int().positive(), literal("never")]).optional()
+	refreshTokenTtlSec: union$1([number().int().positive(), literal("never")]).optional()
 });
 method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" });
 /**
@@ -48201,7 +48201,7 @@ var OidcConnectionUpdateInputSchema = object({
 	icon: string().optional(),
 	issuerUrl: string().optional(),
 	clientId: string().optional(),
-	clientSecret: union([string(), object({ $secretClear: literal(true) })]).optional(),
+	clientSecret: union$1([string(), object({ $secretClear: literal(true) })]).optional(),
 	redirectUri: string().optional(),
 	scopes: string().optional(),
 	usernameClaim: _enum([
@@ -48368,6 +48368,18 @@ Object.freeze({
 	reason: "camera sensor mappings not loaded"
 });
 /**
+* What the vision model must answer before a package event is emitted
+* when a packages rule has "Confirm with the LLM" on.
+*
+* `package` is the verdict. `confidence` is 0..1. `reason` is the model's
+* one-line explanation, stored on the event so a drop is not silent.
+*/
+var PackageLlmVerdictSchema = object({
+	package: boolean(),
+	confidence: number().min(0).max(1),
+	reason: string().min(1)
+});
+/**
 * A model choice has a SCOPE, and a scope change has a workflow.
 *
 * ## The two scopes
@@ -48844,7 +48856,7 @@ var TrackFlagsSchema = object({
 	*  `trained` without a re-fetch. */
 	retrainStatus: RetrainStatusSchema
 });
-union([literal(1), literal(2)]);
+union$1([literal(1), literal(2)]);
 /**
 * WHO decided a label, and when. Carried per tier so a value can be traced to
 * the step and model that produced it — which is what makes the write rule
@@ -49351,6 +49363,21 @@ var ObjectEventSchema = object({
 	* pick-up written before D684 — UNKNOWN, never 0 and never `timestamp`.
 	*/
 	observedAt: number().optional(),
+	/**
+	* The delivery was emitted without a vision-model yes (D931).
+	*
+	* Set only when the packages rule asked for an LLM confirm and the model
+	* was unreachable, timed out, or answered something that did not parse.
+	* A notification reads it so it can say "possible" instead of a definite
+	* delivery. Absent on every other row, and on a confirm that said yes.
+	*/
+	packagePossible: boolean().optional(),
+	/**
+	* The vision model's verdict, when a packages rule asked for one and the
+	* model answered the schema (D931). A "no" never becomes a row — the
+	* detector drops it and logs the reason. Present on a yes.
+	*/
+	packageLlmVerdict: PackageLlmVerdictSchema.optional(),
 	/** The parent track's key-event importance [0,1], propagated to every object
 	*  event of the track (so an event row can be sorted by importance without a
 	*  track join). Absent on legacy rows / before the track was scored. */
@@ -51731,11 +51758,18 @@ var KeptReasonSchema = _enum(["custom-pin"]);
 * Where a choice's latency came from (D791): this node's own benchmark
 * result, or the hardware-class table. Measured on the node beats the table.
 */
-var LatencySourceSchema = discriminatedUnion("kind", [object({ kind: literal("table") }), object({
-	kind: literal("node-benchmark"),
-	resultId: string(),
-	measuredAtMs: number()
-})]);
+var LatencySourceSchema = discriminatedUnion("kind", [
+	object({ kind: literal("table") }),
+	object({
+		kind: literal("node-benchmark"),
+		resultId: string(),
+		measuredAtMs: number()
+	}),
+	object({
+		kind: literal("estimated"),
+		estimatedFrom: HardwareClassIdSchema
+	})
+]);
 var DeviceModelChoiceSchema = object({
 	modelId: string(),
 	p50Ms: number(),
@@ -51743,6 +51777,11 @@ var DeviceModelChoiceSchema = object({
 	measured: boolean(),
 	/** Absent on a plan from before D791 — read as the table. */
 	source: LatencySourceSchema.optional(),
+	/**
+	* The measured class this latency was scaled from (D930). Absent when the
+	* cell is the table or a node benchmark.
+	*/
+	estimatedFrom: HardwareClassIdSchema.optional(),
 	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
 	capacitySessions: number(),
 	personRecall: number()
@@ -52644,7 +52683,7 @@ var DetailResultSchema = object({
 	* stops enriching rather than guessing, which is why addon-pipeline is
 	* deployed BEFORE addon-post-analysis.
 	*/
-	labelTier: union([literal(1), literal(2)]).optional(),
+	labelTier: union$1([literal(1), literal(2)]).optional(),
 	/** Model that produced `label` — carried into the tier's attribution. */
 	labelModelId: string().optional(),
 	alignedCropJpeg: string().optional(),
@@ -54844,7 +54883,7 @@ method(_void(), ServerPackageStatusSchema, { auth: "admin" }), method(_void(), S
 */
 var EmailAddressSchema = email();
 var SendEmailInputSchema = object({
-	to: union([EmailAddressSchema, array(EmailAddressSchema).min(1)]),
+	to: union$1([EmailAddressSchema, array(EmailAddressSchema).min(1)]),
 	cc: array(EmailAddressSchema).optional(),
 	bcc: array(EmailAddressSchema).optional(),
 	/** RFC 5322 `From` field. Most relays will reject if the domain
@@ -55065,7 +55104,7 @@ var SsoBridgeClaimsSchema = object({
 	* editing a descriptor must not retroactively extend or shorten a link the
 	* operator already consented to.
 	*/
-	refreshTtl: union([number().int().positive(), literal("never")]).optional(),
+	refreshTtl: union$1([number().int().positive(), literal("never")]).optional(),
 	/**
 	* Opaque handle of a hub-side LINK intent (D782). Set by an OIDC callback
 	* that was started from a signed-in user's "Link" button: the finish then
@@ -55112,7 +55151,7 @@ method(object({
 	* went through the numeric path would fail at mint time and break
 	* linking rather than produce an eternal token.
 	*/
-	ttlSec: union([number().int().positive(), literal("never")]).optional()
+	ttlSec: union$1([number().int().positive(), literal("never")]).optional()
 }), object({ token: string() }), { auth: "admin" }), method(object({ token: string() }), SsoBridgeClaimsSchema.nullable(), { auth: "admin" });
 var ProviderListEntrySchema = discriminatedUnion("shouldSaveDiskSpace", [object({
 	providerId: string().min(1),
@@ -55680,7 +55719,7 @@ method(_void(), array(TerminalProfileInfoSchema).readonly(), { auth: "admin" }),
 */
 var TurnServerSchema = object({
 	/** Single URL or list of URLs (e.g. "turn:turn.example.com:3478?transport=udp"). */
-	urls: union([string(), array(string())]),
+	urls: union$1([string(), array(string())]),
 	username: string().optional(),
 	credential: string().optional()
 });
@@ -55878,7 +55917,7 @@ var VectorMetricSchema = _enum([
 * Callers keep their rich records in their own store and put only the filterable
 * columns here (deviceId, timestamp, className, modelId, …).
 */
-var VectorMetadataSchema = record(string(), union([
+var VectorMetadataSchema = record(string(), union$1([
 	string(),
 	number(),
 	boolean()
@@ -55891,7 +55930,7 @@ var VectorMetadataSchema = record(string(), union([
 * caller will treat as matches.
 */
 var VectorFilterSchema = object({
-	equals: record(string(), union([
+	equals: record(string(), union$1([
 		string(),
 		number(),
 		boolean()
@@ -59055,7 +59094,7 @@ object({
 	/** Current value. Numeric kind → number; select/text/datetime → string.
 	*  Datetime values are ISO 8601 strings (full timestamp, date-only,
 	*  or time-only — HA accepts all three forms). */
-	value: union([number(), string()]),
+	value: union$1([number(), string()]),
 	/** Acceptable values when `kind === 'select'`. Empty for other kinds. */
 	options: array(string()),
 	/** Ms epoch when the slice was last updated. */
@@ -59369,7 +59408,7 @@ object({
 });
 var DeviceIdSchema = number().int().nonnegative();
 /** A value a program option or setting can take. */
-var DishwasherValueSchema = union([
+var DishwasherValueSchema = union$1([
 	boolean(),
 	string(),
 	number()
@@ -62682,6 +62721,30 @@ includeCrops: boolean().optional() }).optional(), array(VehicleSchema).readonly(
 	kind: "mutation",
 	auth: "admin"
 });
+var CORE_ULTRA_265K_IGPU_CLOCK_MHZ = 2e3;
+var positiveOrNull = number().nullable().transform((value) => value !== null && Number.isFinite(value) && value > 0 ? value : null);
+var textOrNull = string().nullable().transform((value) => value !== null && value.trim() !== "" ? value : null);
+var PrecisionGopsSchema = object({
+	int8: positiveOrNull,
+	fp16: positiveOrNull
+});
+/** What one accelerator device reported. Every failed query is null. */
+var AcceleratorComputeSchema = object({
+	deviceKey: string(),
+	fullDeviceName: textOrNull,
+	executionUnits: positiveOrNull,
+	clockMHz: positiveOrNull,
+	gops: PrecisionGopsSchema.nullable(),
+	architecture: textOrNull,
+	npuName: textOrNull,
+	tops: positiveOrNull,
+	vendor: textOrNull,
+	webgpuArchitecture: textOrNull,
+	webgpuDevice: textOrNull,
+	computeUnits: positiveOrNull
+});
+object({ accelerators: array(AcceleratorComputeSchema).nullable() });
+64 * CORE_ULTRA_265K_IGPU_CLOCK_MHZ;
 var ModelFormatSchema = _enum(MODEL_FORMATS);
 var HwAccelBackendInputSchema = _enum([
 	"videotoolbox",
@@ -62795,7 +62858,12 @@ var HardwareInfoSchema = object({
 	availableRAM_MB: number(),
 	gpu: GpuInfoSchema.nullable(),
 	npu: NpuInfoSchema.nullable(),
-	coral: CoralInfoSchema.nullable().optional()
+	coral: CoralInfoSchema.nullable().optional(),
+	/**
+	* Per-accelerator compute (D930). Omitted by a node that has not probed it.
+	* `null` fields inside an entry are a failed query, never a zero.
+	*/
+	accelerators: array(AcceleratorComputeSchema).readonly().optional()
 });
 var PlatformScoreSchema = object({
 	runtime: literal("python"),
@@ -65691,7 +65759,20 @@ var ZoneRuleSchema = object({
 	* Defaults to `true` so operators creating a rule via the UI
 	* see it active immediately.
 	*/
-	enabled: boolean().default(true)
+	enabled: boolean().default(true),
+	/**
+	* Package stage only. When true, a package candidate may open from a
+	* scene difference in this rule's zone after a person leaves. The
+	* package model, when it boxes something overlapping, is extra evidence
+	* and is not the gate. Absent or false keeps today's model path.
+	*/
+	detectBySceneDifference: boolean().optional(),
+	/**
+	* Package stage only. When true, a promoted package is shown to the
+	* `llm` cap before the delivery event is emitted. Absent or false emits
+	* as today. Usable with or without `detectBySceneDifference`.
+	*/
+	confirmWithLlm: boolean().optional()
 });
 array(ZoneRuleSchema).readonly();
 object({
@@ -66503,8 +66584,8 @@ var UserSummarySchema = object({
 	id: string(),
 	username: string(),
 	isAdmin: boolean().default(false),
-	allowedProviders: union([array(string()), literal("*")]),
-	allowedDevices: record(string(), union([array(string()), literal("*")])),
+	allowedProviders: union$1([array(string()), literal("*")]),
+	allowedDevices: record(string(), union$1([array(string()), literal("*")])),
 	/** Capability rows, or ONE viewer row (D921) — see `UserScopeSchema`. */
 	scopes: array(UserScopeSchema).default([]),
 	/**
@@ -66521,15 +66602,15 @@ var CreateUserInputSchema = object({
 	username: string(),
 	password: string().min(6),
 	isAdmin: boolean().default(false),
-	allowedProviders: union([array(string()), literal("*")]).optional(),
-	allowedDevices: record(string(), union([array(string()), literal("*")])).optional(),
+	allowedProviders: union$1([array(string()), literal("*")]).optional(),
+	allowedDevices: record(string(), union$1([array(string()), literal("*")])).optional(),
 	scopes: array(UserScopeSchema).optional()
 });
 var UpdateUserInputSchema = object({
 	id: string(),
 	isAdmin: boolean().optional(),
-	allowedProviders: union([array(string()), literal("*")]).optional(),
-	allowedDevices: record(string(), union([array(string()), literal("*")])).optional(),
+	allowedProviders: union$1([array(string()), literal("*")]).optional(),
+	allowedDevices: record(string(), union$1([array(string()), literal("*")])).optional(),
 	scopes: array(UserScopeSchema).optional()
 });
 var OauthSessionSummarySchema = object({
@@ -66648,7 +66729,7 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserI
 	*  From `OauthIntegrationDescriptor.refreshTokenTtlSec`. Baked into the
 	*  code so the link carries its own lifetime; omit for the 30-day
 	*  default. */
-	refreshTtlSec: union([number().int().positive(), literal("never")]).optional()
+	refreshTtlSec: union$1([number().int().positive(), literal("never")]).optional()
 }), object({ code: string() }), {
 	kind: "mutation",
 	access: "create"
@@ -67138,7 +67219,7 @@ var TrainingProviderUpdateEntryInputSchema = object({
 	entryId: string().min(1),
 	name: string().min(1),
 	tokenId: string().optional(),
-	tokenSecret: union([string(), object({ $secretClear: literal(true) })]).optional(),
+	tokenSecret: union$1([string(), object({ $secretClear: literal(true) })]).optional(),
 	environment: string().optional(),
 	gpuType: string().optional(),
 	region: string().optional(),
@@ -85223,6 +85304,430 @@ function buildBenchStepTree(schema, rootModelId, enabledStepIds) {
 		]
 	}];
 }
+/** The object-detection step id — the first-level detector both recipes run. */
+var OBJECT_DETECTION_STEP_ID = "object-detection";
+/** Motion regions older than this describe a different frame. */
+var RECOVERY_MOTION_MAX_AGE_MS = 2e3;
+/** Area of a normalised rectangle, never negative. Shared with the D396 recipe. */
+function normalizedArea(r) {
+	return Math.max(0, r.w) * Math.max(0, r.h);
+}
+var area = normalizedArea;
+function intersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+}
+/**
+* Share of `region` not covered by any detection box. The sum of pairwise
+* intersections over-counts where detections overlap each other, which only
+* makes the pass MORE conservative; clipped at 1.
+*/
+function uncoveredFraction(region, detections) {
+	const regionArea = area(region);
+	if (regionArea <= 0) return 0;
+	let covered = 0;
+	for (const detection of detections) covered += intersection(region, detection);
+	return 1 - Math.min(1, covered / regionArea);
+}
+/**
+* THE square-placement rule of this pass — one owner, shared by both recipes.
+*
+* A crop is a square of `side` native pixels centred where it can be and slid
+* inside the frame where it cannot. Both region rules place their squares
+* through this function so a crop means the same rectangle whichever rule
+* chose the region.
+*/
+function squareAround(centreX, centreY, side, native) {
+	return {
+		left: Math.round(Math.max(0, Math.min(native.width - side, centreX - side / 2))),
+		top: Math.round(Math.max(0, Math.min(native.height - side, centreY - side / 2))),
+		side
+	};
+}
+function contains(crop, x, y) {
+	return x >= crop.left && x <= crop.left + crop.side && y >= crop.top && y <= crop.top + crop.side;
+}
+/**
+* Squares for one region: one when it fits the largest side, otherwise up to
+* two tiles along its longer axis (a person-sized blob with something small
+* at either end). The padded region decides the side, never the frame.
+*/
+function cropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const padded = longest * 1.5;
+	const side = Math.round(Math.min(Math.max(padded, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (padded <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/**
+* The ONE place the two region gates are decided. `planRecoveryCrops` filters
+* on it and {@link countRecoverySkips} counts it, so the report can never
+* describe a gate the planner does not actually apply.
+*/
+function classifyRegion(region, uncovered) {
+	if (area(region) > .25) return "too-large";
+	if (uncovered < .35) return "covered";
+	return "eligible";
+}
+/**
+* WHY A FRAME PLANNED NO CROP, AS A NUMBER (D378).
+*
+* The pass report counts the passes that RAN, so "the second pass stops running
+* when a person is beside the dog" — a plausible reading of
+* {@link RECOVERY_MAX_REGION_FRAME_FRACTION} and
+* {@link RECOVERY_MIN_UNCOVERED_FRACTION}, and a live hypothesis on camera 615
+* — could not be confirmed or killed from the logs at all. This classifies the
+* regions a frame offered, against the same predicate the planner filters on.
+*/
+function countRecoverySkips(input) {
+	let tooLarge = 0;
+	let covered = 0;
+	let eligible = 0;
+	for (const region of input.regions) switch (classifyRegion(region, uncoveredFraction(region, input.detections))) {
+		case "too-large":
+			tooLarge += 1;
+			break;
+		case "covered":
+			covered += 1;
+			break;
+		case "eligible":
+			eligible += 1;
+			break;
+	}
+	return {
+		tooLarge,
+		covered,
+		eligible
+	};
+}
+function planRecoveryCrops(input) {
+	const { native } = input;
+	if (Math.min(native.width, native.height) < 640) return [];
+	const ranked = input.regions.map((region) => ({
+		region,
+		uncovered: uncoveredFraction(region, input.detections)
+	})).filter(({ region, uncovered }) => classifyRegion(region, uncovered) === "eligible").toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
+	const planned = [];
+	for (const { region } of ranked) for (const crop of cropsForRegion(region, native)) {
+		if (planned.length >= 2) return planned;
+		const centreX = crop.left + crop.side / 2;
+		const centreY = crop.top + crop.side / 2;
+		if (planned.some((existing) => contains(existing, centreX, centreY))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
+/**
+* Boxes the executor produced on the crop VIEW → the result's own space.
+*
+* Three spaces meet here: the view the model saw (`view`, ≤640 px), the native
+* square it was cut from (`crop`, native px) and the space the full-frame
+* result reports in (`result`, native px on the `frameRef` path, the inline
+* ≤640 view otherwise). A box touching the view edge was clipped by the crop
+* and is dropped: half a person is not a person, and the tracker would take
+* the half as the whole.
+*/
+function remapCropDetections(detections, crop, view, result, native) {
+	const viewToNative = crop.side / Math.max(1, view.width);
+	const nativeToResultX = result.width / Math.max(1, native.width);
+	const nativeToResultY = result.height / Math.max(1, native.height);
+	const out = [];
+	for (const detection of detections) {
+		const { x, y, width, height } = detection.bbox;
+		if (x <= 2 || y <= 2 || x + width >= view.width - 2 || y + height >= view.height - 2) continue;
+		out.push({
+			...detection,
+			nativeRecovery: {
+				score: detection.score,
+				cropSidePx: crop.side,
+				viewPx: view.width
+			},
+			bbox: {
+				x: (crop.left + x * viewToNative) * nativeToResultX,
+				y: (crop.top + y * viewToNative) * nativeToResultY,
+				width: width * viewToNative * nativeToResultX,
+				height: height * viewToNative * nativeToResultY
+			}
+		});
+	}
+	return out;
+}
+function boxIntersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+}
+function sameSubject(recovered, existing) {
+	const inter = boxIntersection(recovered, existing);
+	if (inter <= 0) return false;
+	const areaR = recovered.width * recovered.height;
+	const union = areaR + existing.width * existing.height - inter;
+	if (union > 0 && inter / union >= .5) return true;
+	return areaR > 0 && inter / areaR >= .7;
+}
+/**
+* Class-aware NMS of the recovered boxes against the full-frame ones. Every
+* full-frame box is kept as it is — the second pass only ADDS. A recovered box
+* is added when no full-frame box of the same macro class is the same subject
+* (`RECOVERY_FUSE_IOU`) or contains it (`RECOVERY_FUSE_CONTAINMENT`). Ids are
+* re-minted so a crop's `d0` cannot collide with the frame's.
+*/
+function fuseRecoveredDetections(full, recovered) {
+	const accepted = [];
+	for (const [index, candidate] of recovered.entries()) {
+		if ([...full, ...accepted].some((existing) => existing.macroClass === candidate.macroClass && sameSubject(candidate.bbox, existing.bbox))) continue;
+		accepted.push({
+			...candidate,
+			id: `recovered-${index}-${candidate.id}`
+		});
+	}
+	return [...full, ...accepted];
+}
+/**
+* The step the second pass runs: the enabled first-level object detector of
+* the camera's own tree, with its own model and no children. Same model as
+* the full pass so a recovered box is comparable to a full-frame one.
+*/
+function selectRecoveryStep(steps) {
+	const detector = steps.find((step) => step.addonId === "object-detection" && step.enabled !== false);
+	if (!detector) return null;
+	return {
+		addonId: detector.addonId,
+		...detector.modelId !== void 0 ? { modelId: detector.modelId } : {},
+		enabled: true
+	};
+}
+/**
+* Read the opt-in. Anything that is not the boolean `true` is the shipped
+* rule: a stored string or a number is a mis-write (this repo has shipped a
+* setting written into the wrong sqlite table before), and a mis-write must
+* not silently change what a camera detects on.
+*/
+function readRecoveryRecipe(settings) {
+	return settings?.["motionCropDispatch"] === true ? "motion-crop" : "uncovered-region";
+}
+/**
+* The recipe this camera's resolved step tree selects.
+*
+* Reads the ENABLED first-level detector's own settings, which is where
+* `pipelineOrchestrator.setCameraStepSettings` writes a per-camera value. A
+* tree with no enabled detector runs no second pass at all, so the answer
+* there is the shipped rule and it is never used.
+*/
+function readRecoveryRecipeForSteps(steps) {
+	return readRecoveryRecipe(steps.find((step) => step.addonId === "object-detection" && step.enabled !== false)?.settings);
+}
+/**
+* A motion box is grown ×1.5 about its centre before anything else.
+*
+* The motion step's box is the CHANGED pixels, which on a moving animal is the
+* leading edge plus its shadow, not the animal. The detector needs the subject
+* and the context it was trained on.
+*/
+var MOTION_CROP_MOTION_PAD = 1.5;
+/**
+* An intersecting tracked box is grown ×1.25 — less, because it is already a
+* subject rectangle rather than a change mask.
+*/
+var MOTION_CROP_TRACKED_PAD = 1.25;
+/**
+* The floor a `person` or `vehicle` box must clear when it came out of a CROP
+* rather than out of the full frame.
+*
+* Collected, not assumed: 3 085 quiet frames produced 27 motion-positive
+* frames and 28 crop invocations. The full-frame arm produced 0 boxes above
+* any gate; the crop arm produced 3, of which two are genuine false positives,
+* and both are night-IR corners upscaled into a 320 model — `vehicle 0.749`
+* and `person 0.701`. Zero false `animal` at any gate, which is why `animal`
+* is deliberately absent from this table: the class the pass exists to recover
+* is the class that never produced a false positive, and gating it would cost
+* the whole measured gain.
+*
+* This is a CROP-ONLY floor, applied on top of the per-macro floors the
+* executor already enforced. A full-frame `person` at 0.70 is untouched — the
+* full-frame arm is the one arm with ground truth behind its floor
+* (`minConfidencePerson` 0.65, raised on 2026-07-30 from a measured
+* distribution).
+*
+* The cost of this floor is stated rather than assumed away: it can also
+* remove a real distant person or vehicle recovered from a crop at 0.70–0.80.
+* Nothing in the quiet-footage sample measures that, so the floor is a
+* constant here rather than a slider, and the runner reports every drop it
+* makes per camera.
+*/
+var CROP_CLASS_FLOORS = Object.freeze({
+	person: .8,
+	vehicle: .8
+});
+/**
+* Apply the crop-only class floors, REPORTING every drop.
+*
+* A class with no entry in {@link CROP_CLASS_FLOORS} is kept: a floor this
+* table cannot express is not a floor of zero, and silently dropping a class
+* nobody measured is the exact shape of silent drop this repo has paid for
+* three separate times.
+*/
+function applyCropClassFloors(detections) {
+	const kept = [];
+	const dropped = [];
+	for (const detection of detections) {
+		const floor = CROP_CLASS_FLOORS[detection.macroClass];
+		if (floor !== void 0 && detection.score < floor) {
+			dropped.push({
+				macroClass: detection.macroClass,
+				score: detection.score,
+				floor
+			});
+			continue;
+		}
+		kept.push(detection);
+	}
+	return {
+		kept,
+		dropped
+	};
+}
+function scaleAbout(rect, factor) {
+	const w = rect.w * factor;
+	const h = rect.h * factor;
+	return {
+		x: rect.x + rect.w / 2 - w / 2,
+		y: rect.y + rect.h / 2 - h / 2,
+		w,
+		h
+	};
+}
+function overlaps(a, b) {
+	return Math.min(a.x + a.w, b.x + b.w) > Math.max(a.x, b.x) && Math.min(a.y + a.h, b.y + b.h) > Math.max(a.y, b.y);
+}
+function union(a, b) {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		w: Math.max(a.x + a.w, b.x + b.w) - x,
+		h: Math.max(a.y + a.h, b.y + b.h) - y
+	};
+}
+function clampToFrame(rect) {
+	const x = Math.max(0, rect.x);
+	const y = Math.max(0, rect.y);
+	return {
+		x,
+		y,
+		w: Math.min(1, rect.x + rect.w) - x,
+		h: Math.min(1, rect.y + rect.h) - y
+	};
+}
+/**
+* Merge transitively every seed whose padded box overlaps another, and answer
+* the union rectangles.
+*
+* Transitive on purpose: a person, the dog beside them and the dog's shadow
+* are three components of one subject, and cutting three crops for them spends
+* two inferences on pixels the first one already showed the detector.
+*/
+function mergeSeeds(seeds) {
+	const merged = [];
+	for (const seed of seeds) {
+		let current = seed;
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (let i = merged.length - 1; i >= 0; i -= 1) {
+				const other = merged[i];
+				if (other === void 0 || !overlaps(current, other)) continue;
+				current = union(current, other);
+				merged.splice(i, 1);
+				changed = true;
+			}
+		}
+		merged.push(current);
+	}
+	return merged;
+}
+/**
+* The regions the measured recipe judges this frame on.
+*
+* Motion boxes padded {@link MOTION_CROP_MOTION_PAD}; every full-frame box
+* that intersects a RAW motion box padded {@link MOTION_CROP_TRACKED_PAD} and
+* added as a seed of its own; everything that overlaps merged; the result
+* clamped to the frame, ordered largest first and capped at
+* {@link MOTION_CROP_MAX_REGIONS}.
+*
+* There is deliberately no coverage gate and no size gate here. Those belong
+* to the shipped rule, and they are what makes it a rule about a subject
+* BESIDE a detected one; the measurement says the pass is worth running on the
+* detected subject's own region too.
+*/
+function planMotionCropRegions(input) {
+	if (input.regions.length === 0) return [];
+	const seeds = input.regions.map((r) => scaleAbout(r, MOTION_CROP_MOTION_PAD));
+	for (const detection of input.detections) {
+		if (!input.regions.some((region) => overlaps(detection, region))) continue;
+		seeds.push(scaleAbout(detection, MOTION_CROP_TRACKED_PAD));
+	}
+	return mergeSeeds(seeds).map(clampToFrame).filter((r) => r.w > 0 && r.h > 0).toSorted((a, b) => normalizedArea(b) - normalizedArea(a)).slice(0, 3);
+}
+/**
+* The square the detector is fed for one measured region.
+*
+* "Grow to the detector's input aspect ratio without ever shrinking" is a
+* SQUARE here, and that is a fact about the production detector rather than a
+* simplification: `yolov9m-320-int8` takes 320×320, as does every hardware
+* default in the catalog.
+*
+* The side is the region's longer side, floored at
+* {@link RECOVERY_CROP_MIN_SIDE_PX} — the growth is what magnifies the subject
+* — and ceilinged at {@link RECOVERY_CROP_MAX_SIDE_PX}. The ceiling is NOT a
+* simplification either: at 1024 px the same 320 model scored the reference
+* dog 0.52–0.76, and at 1280 px lost it entirely
+* (`docs/benchmarks/pipeline-frame-model-eval.md`, case `miss-dog-615`). A
+* region longer than the ceiling is TILED along its longer axis, never zoomed
+* out.
+*/
+function motionCropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const side = Math.round(Math.min(Math.max(longest, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (longest <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/** `true` when `inner` lies entirely inside `outer`. */
+function cropContains(outer, inner) {
+	return inner.left >= outer.left && inner.top >= outer.top && inner.left + inner.side <= outer.left + outer.side && inner.top + inner.side <= outer.top + outer.side;
+}
+/**
+* The crops the measured recipe runs on this frame.
+*
+* Dedupe is by CONTAINMENT only. Two squares that merely overlap both run: the
+* pixels the second adds are pixels no other crop shows the detector, and the
+* fusion step downstream already refuses a duplicate BOX. Dropping a crop
+* because it overlapped would drop the subject sitting at its edge, which is
+* the whole population this pass exists for.
+*
+* A frame that cannot hold the smallest crop yields nothing: it is already
+* seen at scale.
+*/
+function planMotionCrops(input) {
+	const { native } = input;
+	if (Math.min(native.width, native.height) < 640) return [];
+	const planned = [];
+	for (const region of planMotionCropRegions(input)) for (const crop of motionCropsForRegion(region, native)) {
+		if (planned.some((existing) => cropContains(existing, crop))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
 /** Side of the square, as a multiple of the face box's longer side. */
 var ROOT_FACE_REFINE_SCALE = 1.6;
 /**
@@ -86778,6 +87283,12 @@ Object.defineProperty(exports, "NodeBenchRunnerInputSchema", {
 		return NodeBenchRunnerInputSchema;
 	}
 });
+Object.defineProperty(exports, "OBJECT_DETECTION_STEP_ID", {
+	enumerable: true,
+	get: function() {
+		return OBJECT_DETECTION_STEP_ID;
+	}
+});
 Object.defineProperty(exports, "OpsLogEntrySchema", {
 	enumerable: true,
 	get: function() {
@@ -86826,6 +87337,12 @@ Object.defineProperty(exports, "RECORDING_SOURCE_CAMSTACK_ADDON", {
 		return RECORDING_SOURCE_CAMSTACK_ADDON;
 	}
 });
+Object.defineProperty(exports, "RECOVERY_MOTION_MAX_AGE_MS", {
+	enumerable: true,
+	get: function() {
+		return RECOVERY_MOTION_MAX_AGE_MS;
+	}
+});
 Object.defineProperty(exports, "ROOT_SUPPLIABLE_STEP_IDS", {
 	enumerable: true,
 	get: function() {
@@ -86886,6 +87403,12 @@ Object.defineProperty(exports, "allowedSuppliedEffect", {
 		return allowedSuppliedEffect;
 	}
 });
+Object.defineProperty(exports, "applyCropClassFloors", {
+	enumerable: true,
+	get: function() {
+		return applyCropClassFloors;
+	}
+});
 Object.defineProperty(exports, "applyModelBoundSettings", {
 	enumerable: true,
 	get: function() {
@@ -86988,6 +87511,12 @@ Object.defineProperty(exports, "containingParentIndex", {
 		return containingParentIndex;
 	}
 });
+Object.defineProperty(exports, "countRecoverySkips", {
+	enumerable: true,
+	get: function() {
+		return countRecoverySkips;
+	}
+});
 Object.defineProperty(exports, "createEvent", {
 	enumerable: true,
 	get: function() {
@@ -87168,6 +87697,12 @@ Object.defineProperty(exports, "ffmpegRate", {
 		return ffmpegRate;
 	}
 });
+Object.defineProperty(exports, "fuseRecoveredDetections", {
+	enumerable: true,
+	get: function() {
+		return fuseRecoveredDetections;
+	}
+});
 Object.defineProperty(exports, "gbToBytes", {
 	enumerable: true,
 	get: function() {
@@ -87396,6 +87931,18 @@ Object.defineProperty(exports, "pipelineRunnerCapability", {
 		return pipelineRunnerCapability;
 	}
 });
+Object.defineProperty(exports, "planMotionCrops", {
+	enumerable: true,
+	get: function() {
+		return planMotionCrops;
+	}
+});
+Object.defineProperty(exports, "planRecoveryCrops", {
+	enumerable: true,
+	get: function() {
+		return planRecoveryCrops;
+	}
+});
 Object.defineProperty(exports, "preprocess", {
 	enumerable: true,
 	get: function() {
@@ -87408,6 +87955,12 @@ Object.defineProperty(exports, "rankStreams", {
 		return rankStreams;
 	}
 });
+Object.defineProperty(exports, "readRecoveryRecipeForSteps", {
+	enumerable: true,
+	get: function() {
+		return readRecoveryRecipeForSteps;
+	}
+});
 Object.defineProperty(exports, "record", {
 	enumerable: true,
 	get: function() {
@@ -87438,6 +87991,12 @@ Object.defineProperty(exports, "recordingSignalCapability", {
 		return recordingSignalCapability;
 	}
 });
+Object.defineProperty(exports, "remapCropDetections", {
+	enumerable: true,
+	get: function() {
+		return remapCropDetections;
+	}
+});
 Object.defineProperty(exports, "resolveClusterStepModelId", {
 	enumerable: true,
 	get: function() {
@@ -87504,6 +88063,12 @@ Object.defineProperty(exports, "selectAssignedProfileSlots", {
 		return selectAssignedProfileSlots;
 	}
 });
+Object.defineProperty(exports, "selectRecoveryStep", {
+	enumerable: true,
+	get: function() {
+		return selectRecoveryStep;
+	}
+});
 Object.defineProperty(exports, "sleep", {
 	enumerable: true,
 	get: function() {
@@ -87561,7 +88126,7 @@ Object.defineProperty(exports, "supportedRuntimes", {
 Object.defineProperty(exports, "union", {
 	enumerable: true,
 	get: function() {
-		return union;
+		return union$1;
 	}
 });
 Object.defineProperty(exports, "userError", {