@camstack/addon-pipeline 1.2.107 → 1.2.115

package/dist/detection-pipeline/index.mjs

@@ -1,9 +1,9 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { $ as pickClusterStepSettings, At as nodePin, D as YAMNET_TO_MACRO, Et as hydrateSchema, G as evaluateZoneRules, Gt as union, Ht as object, I as defaultDeviceFor$1, It as array, Kt as EventCategory, Pt as sleep, Q as pickClusterStepModels, Tt as createEvent, V as detectionPipelineCapability, W as enumerateInferenceDevices, Wt as string, X as overlayClusterStepSettings, c as DEFAULT_CLUSTER_STEP_MODELS, ct as resolvePoolMemoryPolicy, ht as errMsg, jt as parseJsonUnknown, l as DEFAULT_CLUSTER_STEP_SETTINGS, nt as pipelineExecutorCapability, ot as resolveClusterStepModelId, p as DEVICE_BACKEND_TO_FORMAT, pt as supportedRuntimes$1, t as APPLE_SA_TO_MACRO, ut as runtimeDevices$1, x as PoolMemoryWatchdog, xt as BaseAddon } from "../dist-CkXAzTZ2.mjs";
-import { a as getDefaultModelForFormat, c as getStepDefinition, i as ALL_STEPS, l as resolveModelForFormat, n as startEventLoopStallMonitor, o as getDefaultModelForFormatFromDef, r as ALL_PIPELINE_STEPS, s as getStep, u as landmarkPrecisionVerdict } from "../event-loop-stall-monitor-fHkfgmlw.mjs";
+import { $ as pickClusterStepSettings, At as nodePin, D as YAMNET_TO_MACRO, Et as hydrateSchema, G as evaluateZoneRules, Gt as union, Ht as object, I as defaultDeviceFor$1, It as array, Kt as EventCategory, Pt as sleep, Q as pickClusterStepModels, Tt as createEvent, V as detectionPipelineCapability, W as enumerateInferenceDevices, Wt as string, X as overlayClusterStepSettings, c as DEFAULT_CLUSTER_STEP_MODELS, ct as resolvePoolMemoryPolicy, ht as errMsg, jt as parseJsonUnknown, l as DEFAULT_CLUSTER_STEP_SETTINGS, nt as pipelineExecutorCapability, ot as resolveClusterStepModelId, p as DEVICE_BACKEND_TO_FORMAT, pt as supportedRuntimes$1, t as APPLE_SA_TO_MACRO, ut as runtimeDevices$1, x as PoolMemoryWatchdog, xt as BaseAddon } from "../dist-DGQkkWc6.mjs";
+import { a as ALL_PIPELINE_STEPS, c as getDefaultModelForFormatFromDef, d as resolveModelForFormat, f as landmarkPrecisionVerdict, l as getStep, n as startEventLoopStallMonitor, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as getStepDefinition } from "../event-loop-stall-monitor-D5jK5v4Z.mjs";
 import { t as getSharp } from "../lazy-sharp-6oymT_yf.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-DlSOzuHP.mjs";
-import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../addon-utils-A2S9D7pu.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-BtT7WfbJ.mjs";
+import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../addon-utils-CgBCF-mE.mjs";
 import sharp from "sharp";
 import { spawn } from "node:child_process";
 import * as path$1 from "node:path";
@@ -257,7 +257,13 @@ var OBJECT_DETECTION_STEP_ID = "object-detection";
 * `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
 * INTEL NPU + iGPU default to OUR YOLOv9 (int8 @320): yolo26 does NOT compile on
 * the Intel NPU (arch incompat → 0 frames), while yolov9 runs on it (~298 fps
-* measured). Apple ANE stays on yolo26 until the CoreML yolov9 build lands.
+* measured). Apple ANE uses the CoreML yolov9 @320 build.
+*
+* Do **not** promote these ids to `yolov9m-640` / `*-640`. The controlled
+* evaluation recovered 0/3 misses at the current 0.50 threshold and failed the
+* false-positive and capacity gates — see
+* `docs/benchmarks/pipeline-frame-model-eval.md`. 640 remains an explicit
+* operator pick, not a hardware-aware default.
 */
 var MODEL_BY_CLASS = {
 	"apple-ane": "yolov9m-320",
@@ -1367,7 +1373,7 @@ function macroOfMinConfidenceKey(key) {
 */
 function reachableMacros(def, entry) {
 	if (entry.labels.length === 0) return void 0;
-	const map = def.classMap;
+	const map = entry.classMap ?? def.classMap;
 	if (!map) return new Set(entry.labels.map((l) => l.id));
 	if (map.preserveOriginal) return void 0;
 	const macros = /* @__PURE__ */ new Set();
@@ -1387,7 +1393,7 @@ function reachableMacros(def, entry) {
 */
 function collectClassMapDropWarning(def, entry) {
 	if (entry.labels.length === 0) return null;
-	const map = def.classMap;
+	const map = entry.classMap ?? def.classMap;
 	if (!map || map.preserveOriginal) return null;
 	const unmapped = entry.labels.filter((l) => map.mapping[l.id] === void 0).map((l) => l.id);
 	if (unmapped.length === 0) return null;
@@ -4163,7 +4169,7 @@ function applyChildOutput(parent, childStep, output, stepLatencyMs, ctx) {
 	switch (output.kind) {
 		case "detections":
 			if (childStep.definition.slot === "refiner") {
-				const classMap = childStep.definition.classMap?.mapping;
+				const classMap = childStep.effectiveClassMap?.mapping;
 				const parentMacro = parent.macroClass;
 				const best = output.detections.filter((d) => {
 					if (d.mask === void 0) return false;
@@ -4503,6 +4509,29 @@ function reprojectCropZoneDetections(output, cropOrigin) {
 		}))
 	};
 }
+function reprojectViewDetections(output, geometry) {
+	const mapPoint = (x, y) => ({
+		x: geometry.sourceCrop.left + x / geometry.scale.x,
+		y: geometry.sourceCrop.top + y / geometry.scale.y
+	});
+	return {
+		kind: "detections",
+		detections: output.detections.map((det) => {
+			const origin = mapPoint(det.bbox[0], det.bbox[1]);
+			const end = mapPoint(det.bbox[2], det.bbox[3]);
+			return {
+				...det,
+				bbox: [
+					origin.x,
+					origin.y,
+					end.x,
+					end.y
+				],
+				...det.landmarks ? { landmarks: det.landmarks.map((landmark) => mapPoint(landmark.x, landmark.y)) } : {}
+			};
+		})
+	};
+}
 var PipelineExecutor = class {
 	opts;
 	/** Bounds the full-frame-guard drop log: first example per (device,
@@ -4564,7 +4593,7 @@ var PipelineExecutor = class {
 	*
 	* @returns FrameResult + optional trace
 	*/
-	async run(tree, rootInput, fullFrameJpegProvider, imageWidth, imageHeight, deviceId, runOpts, nativeCropProvider, cropZoneBbox) {
+	async run(tree, rootInput, fullFrameJpegProvider, imageWidth, imageHeight, deviceId, runOpts, nativeCropProvider, cropZoneBbox, rootInputViewProvider) {
 		const startMs = Date.now();
 		const verbosity = runOpts?.traceVerbosity ?? "off";
 		const traceBuilder = new ExecutionTraceBuilder(verbosity, deviceId, imageWidth, imageHeight, this.opts.engineRuntime);
@@ -4612,18 +4641,20 @@ var PipelineExecutor = class {
 		};
 		for (const rootStep of tree.roots) {
 			if (debug) console.log(`[executor] rootStep=${rootStep.stepId} settings=${JSON.stringify(rootStep.settings ?? {})}`);
-			const cropPrep = rootStep.definition.extractMode === "crop-zone" && cropZoneBbox !== void 0 ? await this.prepareCropZoneInput(cropZoneBbox, fullFrameJpegProvider, imageWidth, imageHeight, deviceId) : null;
+			const rootCrop = rootStep.definition.extractMode === "crop-zone" ? cropZoneBbox : void 0;
+			const rootView = rootInputViewProvider ? await rootInputViewProvider(rootStep, rootCrop) : null;
+			const cropPrep = !rootView && rootCrop !== void 0 ? await this.prepareCropZoneInput(rootCrop, fullFrameJpegProvider, imageWidth, imageHeight, deviceId) : null;
 			const rootStart = Date.now();
-			const rawRootOutput = await this.executeStep(rootStep, cropPrep?.input ?? withInferenceDeviceId(rootInput, deviceId), cropPrep?.width ?? imageWidth, cropPrep?.height ?? imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg, rootShed);
+			const rawRootOutput = await this.executeStep(rootStep, rootView?.input ?? cropPrep?.input ?? withInferenceDeviceId(rootInput, deviceId), rootView?.width ?? cropPrep?.width ?? imageWidth, rootView?.height ?? cropPrep?.height ?? imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg, rootShed);
 			const rootMs = Date.now() - rootStart;
 			if (rawRootOutput === null) continue;
-			const rootOutput = cropPrep && rawRootOutput.kind === "detections" ? reprojectCropZoneDetections(rawRootOutput, cropPrep.origin) : rawRootOutput;
+			const rootOutput = rootView && rawRootOutput.kind === "detections" ? reprojectViewDetections(rawRootOutput, rootView.geometry) : cropPrep && rawRootOutput.kind === "detections" ? reprojectCropZoneDetections(rawRootOutput, cropPrep.origin) : rawRootOutput;
 			if (rootOutput.kind !== "detections") {
 				if (isEnrichmentOutput(rootOutput)) {
 					const mutable = this.synthesizeRootDetection(rootOutput, rootStep, idGen, rootMs, imageWidth, imageHeight);
 					applyChildOutput(mutable, rootStep, rootOutput, rootMs, ctx);
 					try {
-						await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
+						await this.executeChildren(rootStep.children, mutable, rootView?.jpegProvider ?? fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
 					} catch (err) {
 						this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
 							tags: { deviceId },
@@ -4641,12 +4672,12 @@ var PipelineExecutor = class {
 			}
 			for (const det of rootOutput.detections) {
 				const mutable = toMutableRootDetection(det, rootStep, idGen, rootMs);
-				if (rootStep.definition.classMap) {
-					const mapped = rootStep.definition.classMap.mapping[det.class];
+				if (rootStep.effectiveClassMap) {
+					const mapped = rootStep.effectiveClassMap.mapping[det.class];
 					if (mapped) {
 						mutable.originalClass = det.class;
 						mutable.macroClass = mapped;
-					} else if (!rootStep.definition.classMap.preserveOriginal) {
+					} else if (!rootStep.effectiveClassMap.preserveOriginal) {
 						(discarded ??= []).push({
 							bbox: [
 								mutable.bbox[0],
@@ -4728,7 +4759,7 @@ var PipelineExecutor = class {
 					}
 				});
 				try {
-					await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
+					await this.executeChildren(rootStep.children, mutable, rootView?.jpegProvider ?? fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
 				} catch (err) {
 					this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
 						tags: { deviceId },
@@ -5148,6 +5179,59 @@ function capitalize(s) {
 	return s.charAt(0).toUpperCase() + s.slice(1);
 }
 //#endregion
+//#region src/session-decode/frame-view-payload.ts
+var FRAME_VIEW_PAYLOAD_POLICY = "jpeg";
+//#endregion
+//#region src/detection-pipeline/root-frame-view.ts
+/** Resolve the pre-padding content requested from the decode worker for one root. */
+function resolveRootFrameViewSpec(model, source, crop, format = FRAME_VIEW_PAYLOAD_POLICY) {
+	const sourceWidth = crop?.width ?? source.width;
+	const sourceHeight = crop?.height ?? source.height;
+	if (model.preprocessMode !== "letterbox") return {
+		...crop ? { crop } : {},
+		content: {
+			width: model.inputSize.width,
+			height: model.inputSize.height
+		},
+		fit: "stretch",
+		format
+	};
+	const scale = Math.min(model.inputSize.width / sourceWidth, model.inputSize.height / sourceHeight);
+	return {
+		...crop ? { crop } : {},
+		content: {
+			width: Math.max(1, Math.round(sourceWidth * scale)),
+			height: Math.max(1, Math.round(sourceHeight * scale))
+		},
+		fit: "contain",
+		format
+	};
+}
+//#endregion
+//#region src/detection-pipeline/frame-ref-view-provider.ts
+var LocalFrameRefMissError = class extends Error {
+	reason;
+	constructor(reason) {
+		super(`local frameRef miss: ${reason}`);
+		this.reason = reason;
+		this.name = "LocalFrameRefMissError";
+	}
+};
+/** Bind one registry lease for all heterogeneous roots of a pipeline invocation. */
+function createRootFrameViewResolver(registry, ref) {
+	const lease = registry.acquire(ref);
+	if (!lease) throw new LocalFrameRefMissError(ref.registryId === registry.registryId ? "stale-ref" : "foreign-registry");
+	const resolve = async (root, crop) => {
+		const model = root.definition.models.find((candidate) => candidate.id === root.modelId);
+		if (!model) throw new Error(`frame view model not found: ${root.modelId}`);
+		const spec = resolveRootFrameViewSpec(model, ref, crop);
+		const result = await lease.resolve(spec);
+		if (result.kind === "miss") throw new LocalFrameRefMissError(result.reason);
+		return result;
+	};
+	return Object.assign(resolve, { release: (reason) => lease.release(reason) });
+}
+//#endregion
 //#region src/detection-pipeline/pipeline/native-crop-compose.ts
 /** Clamp `v` into `[lo, hi]`. */
 function clamp(v, lo, hi) {
@@ -5187,23 +5271,32 @@ function composeCropRoiToFrameNorm(roi, cropFrameSpace, frameWidth, frameHeight)
 //#endregion
 //#region src/detection-pipeline/pipeline/tree-builder.ts
 /**
+* Effective class map for `(definition, modelId)` without writing back to the
+* shared StepDefinition. Custom models missing from `definition.models` are
+* resolved through the optional registry callback.
+*/
+function resolveEffectiveClassMap(definition, modelId, resolveModel) {
+	return (definition.models.find((model) => model.id === modelId) ?? resolveModel?.(definition.id, modelId))?.classMap ?? definition.classMap;
+}
+/**
 * Build an executable tree from user config.
 *
 * @param steps - User-configured pipeline steps (from PipelineDefaultStep[])
 * @param getEngine - Function that returns an IInferenceEngine for a step ID.
 *                    Throws if step not loaded.
 */
-function buildExecutableTree(steps, getEngine) {
-	return { roots: steps.filter((s) => s.enabled).filter((s) => s.slot !== "audio-classifier").map((s) => buildNode(s, getEngine)) };
+function buildExecutableTree(steps, getEngine, resolveModel) {
+	return { roots: steps.filter((s) => s.enabled).filter((s) => s.slot !== "audio-classifier").map((s) => buildNode(s, getEngine, resolveModel)) };
 }
-function buildNode(step, getEngine) {
+function buildNode(step, getEngine, resolveModel) {
 	const definition = getStepDefinition(step.addonId);
 	const engine = getEngine(step.addonId);
-	const children = (step.children ?? []).filter((c) => c.enabled).map((c) => buildNode(c, getEngine));
+	const children = (step.children ?? []).filter((c) => c.enabled).map((c) => buildNode(c, getEngine, resolveModel));
 	const mergedSettings = {
 		...collectSchemaDefaults(step.addonId),
 		...step.settings
 	};
+	const effectiveClassMap = resolveEffectiveClassMap(definition, step.modelId, resolveModel);
 	return {
 		stepId: step.addonId,
 		definition,
@@ -5212,7 +5305,8 @@ function buildNode(step, getEngine) {
 		inputClasses: definition.inputClasses ?? [],
 		enabled: step.enabled,
 		children,
-		...Object.keys(mergedSettings).length > 0 ? { settings: mergedSettings } : {}
+		...Object.keys(mergedSettings).length > 0 ? { settings: mergedSettings } : {},
+		...effectiveClassMap !== void 0 ? { effectiveClassMap } : {}
 	};
 }
 /**
@@ -7091,17 +7185,30 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		let jpegProvider;
 		const sources = [
 			input.frame ? "frame" : null,
+			input.frameRef ? "frameRef" : null,
 			input.frameHandle ? "frameHandle" : null,
 			input.image ? "image" : null,
 			input.imageBase64 ? "imageBase64" : null,
 			input.referenceImage ? "referenceImage" : null
 		].filter((s) => s !== null);
-		if (sources.length === 0) throw new Error("runPipeline requires exactly one of: frame, frameHandle, image, imageBase64, referenceImage");
+		if (sources.length === 0) throw new Error("runPipeline requires exactly one of: frame, frameRef, frameHandle, image, imageBase64, referenceImage");
 		if (sources.length > 1) throw new Error(`runPipeline received conflicting image sources: ${sources.join(", ")}`);
 		if (input.frameHandle) return this.emptyFrameHandleResult(input);
 		const runtimeFrame = input.frame ?? void 0;
+		const runtimeFrameRef = input.frameRef;
 		const decodeT0 = performance.now();
-		if (runtimeFrame) {
+		if (runtimeFrameRef) {
+			imageWidth = runtimeFrameRef.width;
+			imageHeight = runtimeFrameRef.height;
+			rootInput = {
+				kind: "jpeg",
+				data: Buffer.alloc(0)
+			};
+			jpegProvider = async () => {
+				throw new Error("frameRef root view was requested before model resolution");
+			};
+			emit(`FrameRef: ${imageWidth}×${imageHeight} (${runtimeFrameRef.format})`);
+		} else if (runtimeFrame) {
 			const frame = runtimeFrame;
 			imageWidth = frame.width;
 			imageHeight = frame.height;
@@ -7301,9 +7408,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				emit(`All models loaded`);
 			}
 			emit("Running inference...");
-			const tree = buildExecutableTree(benchmarkSteps, (stepId) => dispatchFactory.getEngine(stepId));
+			const tree = buildExecutableTree(benchmarkSteps, (stepId) => dispatchFactory.getEngine(stepId), this.customModelResolver);
 			setupMs = performance.now() - wallT0 - decodeMs;
-			const isRuntime = Boolean(runtimeFrame);
+			const isRuntime = Boolean(runtimeFrame || runtimeFrameRef);
 			const effectiveDeviceId = input.deviceId ?? 0;
 			const deviceOverrides = effectiveDeviceId > 0 ? await this.readDeviceStore(effectiveDeviceId) : {};
 			const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
@@ -7314,10 +7421,42 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				const proxy = this.deviceProxies.get(effectiveDeviceId);
 				if (proxy) cropZoneBbox = resolvePackageCropBbox(proxy.state.zones.value?.zones ?? [], proxy.state.zoneRules.value?.package ?? [], imageWidth, imageHeight) ?? void 0;
 			}
-			const { result, trace } = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, {
-				traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full",
-				plane: input.plane
-			}, nativeCropProvider, cropZoneBbox);
+			let frameViewResolver;
+			let rootInputViewProvider;
+			if (runtimeFrameRef) {
+				frameViewResolver = createRootFrameViewResolver(localFrameRegistry, runtimeFrameRef);
+				rootInputViewProvider = async (root, crop) => {
+					const view = await frameViewResolver(root, crop ? {
+						left: crop[0],
+						top: crop[1],
+						width: crop[2] - crop[0],
+						height: crop[3] - crop[1]
+					} : void 0);
+					const data = Buffer.from(view.data.buffer, view.data.byteOffset, view.data.byteLength);
+					return {
+						input: {
+							kind: "jpeg",
+							data
+						},
+						jpegProvider: async () => data,
+						width: view.width,
+						height: view.height,
+						geometry: view.geometry
+					};
+				};
+			}
+			let executionSucceeded = false;
+			let execution;
+			try {
+				execution = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, {
+					traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full",
+					plane: input.plane
+				}, nativeCropProvider, cropZoneBbox, rootInputViewProvider);
+				executionSucceeded = true;
+			} finally {
+				frameViewResolver?.release(executionSucceeded ? "success" : "error");
+			}
+			const { result, trace } = execution;
 			if (isRuntime) {
 				if (trace && this.eventBus) this.eventBus.emit(createEvent(EventCategory.PipelineTrace, {
 					type: "device",

package/dist/{dist-L-1LMGQs.js → dist-BqIbYW1A.js}

@@ -9081,6 +9081,15 @@ var LabelDefinitionSchema = object({
 	description: string().optional(),
 	icon: string().optional()
 });
+var ClassMapDefinitionSchema = object({
+	mapping: record(string(), _enum([
+		"person",
+		"vehicle",
+		"animal",
+		"package"
+	])),
+	preserveOriginal: boolean()
+});
 var MODEL_FORMATS = [
 	"onnx",
 	"coreml",
@@ -9259,7 +9268,13 @@ var ModelCatalogEntrySchema = object({
 	* `id` stays the source of truth for resolution/download/persistence; grouping
 	* is a presentation overlay resolved back to an `id`.
 	*/
-	group: ModelVariantGroupSchema.optional()
+	group: ModelVariantGroupSchema.optional(),
+	/**
+	* Per-MODEL class map override. Absent ⇒ the step's `StepDefinition.classMap`
+	* applies (Frigate / COCO public catalog). Set on a custom model whose raw
+	* labels already ARE the CamStack macros (Scrypted identity map).
+	*/
+	classMap: ClassMapDefinitionSchema.optional()
 });
 var ConvertTargetSchema = discriminatedUnion("format", [object({
 	format: literal("openvino"),
@@ -9288,7 +9303,8 @@ var ModelConvertMetadataSchema = object({
 		"ocr",
 		"segmentation"
 	]),
-	faceAlignment: boolean().optional()
+	faceAlignment: boolean().optional(),
+	classMap: ClassMapDefinitionSchema.optional()
 });
 var ConvertResultSchema = object({
 	entry: ModelCatalogEntrySchema,
@@ -19072,6 +19088,33 @@ var NativeCropRefSchema = object({
 		h: number()
 	})
 });
+object({
+	crop: object({
+		left: number(),
+		top: number(),
+		width: number().positive(),
+		height: number().positive()
+	}).optional(),
+	content: object({
+		width: number().int().positive(),
+		height: number().int().positive()
+	}),
+	fit: _enum(["stretch", "contain"]),
+	format: _enum([
+		"rgb",
+		"gray",
+		"jpeg"
+	])
+});
+var FrameRefSchema = object({
+	registryId: string().min(1),
+	id: string().min(1),
+	width: number().int().positive(),
+	height: number().int().positive(),
+	format: _enum(["rgb", "gray"]),
+	timestamp: number(),
+	capturedAt: number().optional()
+});
 var ModelFormatSchema$1 = _enum([
 	"onnx",
 	"coreml",
@@ -19392,7 +19435,7 @@ var pipelineExecutorCapability = {
 		* legacy call shape used by existing benchmark code; once all
 		* callers pass it explicitly we make it required.
 		*
-		* Exactly one of `frame`, `frameHandle`, `imageBase64`,
+		* Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
 		* `referenceImage` must be provided:
 		*  - `frame`: runtime dispatch path (runner → decoded broker frame).
 		*    Carries the raw buffer, dimensions, and format; the executor
@@ -19414,6 +19457,12 @@ var pipelineExecutorCapability = {
 			steps: array(PipelineStepInputSchema).min(1),
 			frame: FrameInputSchema.optional(),
 			/**
+			* Process-local lazy frame. Valid only when caller and provider resolve
+			* in the same execution-group process; split/cross-node callers use
+			* `frame`/`image` inline compatibility instead.
+			*/
+			frameRef: FrameRefSchema.optional(),
+			/**
 			* CB5 shm passthrough — a `FrameHandle` naming the same ring slot
 			* the decoded pixels live in. One more member of the one-of
 			* frame/frameHandle/image/imageBase64/referenceImage group.
@@ -19723,7 +19772,10 @@ var NativeCropResultSchema = object({
 	* Which source served this crop, so a quality-sensitive consumer (the native
 	* `keyFrame`) can reject a degraded fallback:
 	* - `native` — cut from the decode worker's retained NATIVE surface (the
-	*   quality path).
+	*   quality path). A subject-tile serve is also native-resolution and stays
+	*   `native` here: the public enum cannot name `tile` without a breaking cap
+	*   change. Runner telemetry distinguishes lease vs tile via `source` on the
+	*   internal crop result (`nativeHits` vs `tileHits`).
 	* - `ram-fullframe` — the native surface MISSED but the request was full-frame,
 	*   so the ≤640 RAM `RetainedFrameStore` served it (honest lower-res; legit for
 	*   the blank-frame guard / 640-snapshot resolve, NOT for the clean keyFrame).
@@ -20214,12 +20266,41 @@ var RunnerLocalLoadSchema = object({
 * legacy `OrchestratorMetricsSchema` shape so existing dashboards keep
 * working unchanged when they switch to reading from the runner cap.
 */
+var FrameLazyCountersSchema = object({
+	framesDecoded: number(),
+	framesAdmitted: number(),
+	framesDroppedPixelFree: number(),
+	viewsMaterialized: number(),
+	viewsSkipped: number(),
+	workerToRunnerBytes: number(),
+	runnerToPoolRawBytes: number(),
+	runnerToPoolJpegBytes: number(),
+	onDemandFullFrameRequests: number(),
+	onDemandCropRequests: number(),
+	nativeHits: number(),
+	nativeMisses: number(),
+	tileHits: number(),
+	tileMisses: number(),
+	fallbackHits: number(),
+	fallbackMisses: number(),
+	retainedWritesAvoided: number(),
+	residentRefs: number(),
+	residentBytes: number(),
+	releases: number(),
+	evictions: number(),
+	staleMisses: number()
+});
+var FrameLazyMetricsSchema = object({
+	node: FrameLazyCountersSchema,
+	cameras: array(FrameLazyCountersSchema.extend({ deviceId: number() }))
+});
 var RunnerLocalMetricsSchema = object({
 	nodeId: string(),
 	activeCameras: number(),
 	throttledCameras: number(),
 	avgInferenceTimeMs: number(),
-	queueDepth: number()
+	queueDepth: number(),
+	frameLazy: FrameLazyMetricsSchema.optional()
 });
 /**
 * Pipeline Runner capability — runtime detection workhorse.
@@ -21676,6 +21757,9 @@ method(_void(), ProviderInfoSchema), method(object({ config: record(string(), un
 	location: StorageLocationSchema,
 	relativePath: string()
 }), _void(), { kind: "mutation" }), method(object({ location: StorageLocationSchema }), number().nullable()), method(BeginUploadInputSchema, BeginUploadResultSchema, { kind: "mutation" }), method(WriteChunkInputSchema, _void(), { kind: "mutation" }), method(FinalizeUploadInputSchema, _void(), { kind: "mutation" }), method(AbortUploadInputSchema, _void(), { kind: "mutation" }), method(BeginDownloadInputSchema, BeginDownloadResultSchema, { kind: "mutation" }), method(ReadChunkInputSchema, _instanceof(Uint8Array)), method(EndDownloadInputSchema, _void(), { kind: "mutation" });
+/** Profile-exported FormBuilder schema. Shape is ConfigUISchema at the UI. */
+var ProfileSettingsSchemaBridge = unknown().nullable();
+var ProfileSettingsBagSchema = record(string(), unknown());
 /**
 * A live terminal session hosted by the provider addon. Output and input do
 * NOT flow through the capability — they use the addon data plane
@@ -21710,7 +21794,9 @@ var TerminalProfileInfoSchema = object({
 	executable: string().optional(),
 	args: array(string()).readonly().optional(),
 	cwd: string().optional(),
-	environment: array(string()).readonly().optional()
+	environment: array(string()).readonly().optional(),
+	/** ConfigUISchema for instance knobs, or null when the profile has none. */
+	settingsSchema: ProfileSettingsSchemaBridge.optional()
 });
 /**
 * A durable operator-created Terminal instance. Profiles are templates; only
@@ -21727,7 +21813,8 @@ var TerminalInstanceInfoSchema = object({
 	executable: string(),
 	args: array(string()).readonly(),
 	cwd: string(),
-	environment: array(string()).readonly()
+	environment: array(string()).readonly(),
+	profileSettings: ProfileSettingsBagSchema
 });
 var TerminalLegacyCameraSchema = object({
 	stableId: string(),
@@ -21761,7 +21848,8 @@ method(_void(), array(TerminalProfileInfoSchema).readonly(), { auth: "admin" }),
 	executable: string().max(1024).optional(),
 	args: array(string().max(2048)).max(64).optional(),
 	cwd: string().max(1024).optional(),
-	environment: array(string().max(4096)).max(64).optional()
+	environment: array(string().max(4096)).max(64).optional(),
+	profileSettings: ProfileSettingsBagSchema.optional()
 }), TerminalInstanceInfoSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -21771,7 +21859,8 @@ method(_void(), array(TerminalProfileInfoSchema).readonly(), { auth: "admin" }),
 	executable: string().max(1024).optional(),
 	args: array(string().max(2048)).max(64).optional(),
 	cwd: string().max(1024).optional(),
-	environment: array(string().max(4096)).max(64).optional()
+	environment: array(string().max(4096)).max(64).optional(),
+	profileSettings: ProfileSettingsBagSchema.optional()
 }), TerminalInstanceInfoSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -24726,10 +24815,10 @@ DeviceType.LawnMower, method(object({ deviceId: number().int().nonnegative() }),
 *
 *  • The SDK (mobile / web client) consumes `getConnectionEndpoints()`
 *    to receive an ordered list of candidate base URLs it should race
-*    on connect — LAN IPv4 first (lowest latency when on same network),
-*    then public hostname (if a tunnel is up), then IPv6. The SDK can
-*    race them with short timeouts and stick with the winner for the
-*    session.
+*    on connect — LAN IPv4 and stable LAN IPv6 first (lowest latency
+*    when on the same network), then public hostname (if a tunnel is
+*    up). The SDK can race them with short timeouts and stick with the
+*    winner for the session.
 *
 * Why hub-only: agents are not directly addressable by the operator's
 * clients — they reverse-connect to the hub. Exposing their interfaces
@@ -24884,6 +24973,17 @@ var NotificationEndpointSchema = object({
 	/** What the ranking currently resolves to (null when nothing is reachable). */
 	resolved: string().nullable()
 });
+/**
+* The URLs the SDK / viewer should race for API access. `baseUrls` empty =
+* AUTO (every LAN IPv4 + the public tunnel). `resolved` is what that choice
+* currently expands to, so the UI can show the effective set either way.
+*/
+var ViewerEndpointsSchema = object({
+	/** The operator's explicit race set, or empty for AUTO. */
+	baseUrls: array(string()).readonly(),
+	/** What the ranking currently resolves to (may be empty if nothing is up). */
+	resolved: array(string()).readonly()
+});
 var AllowedAddressesSchema = object({ 
 /**
 * Allowlist of interface addresses operators have explicitly opted
@@ -24915,17 +25015,18 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
 	*/
 	port: number().int().min(1).max(65535).optional(),
 	/** Include `http(s)://127.0.0.1:<port>` as the lowest-priority
-	*  candidate. Default `true`. */
+	*  candidate. Default `false` — loopback is not a client route. */
 	includeLoopback: boolean().optional(),
-	/** Skip IPv6 entries. Some legacy clients can't parse them.
-	*  Default `false`. */
+	/** Skip IPv6 entries. Default `false` — the palette includes stable
+	*  LAN IPv6 (ICE/WebRTC uses dual-stack regardless). Pass `true` to
+	*  hide them. The viewer HTTP/WS race is `getViewerEndpoints`. */
 	ipv4Only: boolean().optional(),
 	/** Scheme to emit for LAN/loopback URLs. Default `'http'`.
 	*  Pass `'https'` when the caller is itself loaded over HTTPS
 	*  to avoid mixed-content blocks in the browser. The public
 	*  tunnel always emits `https://` regardless. */
 	scheme: _enum(["http", "https"]).optional()
-}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
+}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -30909,6 +31010,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.getViewerEndpoints": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.list": {
 		capName: "local-network",
 		capScope: "system",
@@ -30945,6 +31052,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.setViewerEndpoints": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.uploadCertificate": {
 		capName: "local-network",
 		capScope: "system",