@camstack/addon-decoder-nodeav 1.1.10 → 1.1.12

package/dist/index.mjs

@@ -1,6 +1,4 @@
-import { DecoderFrameRingSink, FrameRingReaderCache, RING_BUDGET_MB, SEGMENT_NAME_PREFIX, makeSegmentName, unlinkSegment } from "@camstack/shm-ring";
 import { randomUUID } from "node:crypto";
-import { readdirSync } from "node:fs";
 //#region ../../node_modules/zod/v4/core/core.js
 var _a$1;
 function $constructor(name, initializer, params) {
@@ -4289,6 +4287,14 @@ function object(shape, params) {
 		...normalizeParams(params)
 	});
 }
+function looseObject(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape,
+		catchall: unknown(),
+		...normalizeParams(params)
+	});
+}
 var ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
 	$ZodUnion.init(inst, def);
 	ZodType.init(inst, def);
@@ -4630,7 +4636,7 @@ function _instanceof(cls, params = {}) {
 	return inst;
 }
 //#endregion
-//#region ../types/dist/sleep-BC9Yqte7.mjs
+//#region ../types/dist/sleep-_sv7WKkq.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -5040,10 +5046,51 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["EnrichmentEmbeddingStored"] = "enrichment.embedding.stored";
 	EventCategory["EnrichmentSceneStateChanged"] = "enrichment.scene.state-changed";
 	EventCategory["EnrichmentActivitySummary"] = "enrichment.activity.summary";
+	/**
+	* Unified track-lifecycle event: ONE category carrying `phase:
+	* 'start' | 'update' | 'end'` with a rich, typed
+	* `PipelineAnalyticsTrackLifecyclePayload`. Supersedes the thin
+	* `PipelineAnalyticsTrackStarted` / `PipelineAnalyticsTrackEnded`
+	* pair — a consumer subscribes once and branches on `phase`.
+	*/
+	EventCategory["PipelineAnalyticsTrackLifecycle"] = "pipeline-analytics.track-lifecycle";
+	/**
+	* @deprecated Superseded by {@link PipelineAnalyticsTrackLifecycle}
+	* (`phase:'start'`). Kept as a soft alias — no known subscribers.
+	*/
 	EventCategory["PipelineAnalyticsTrackStarted"] = "pipeline-analytics.track-started";
+	/**
+	* @deprecated Superseded by {@link PipelineAnalyticsTrackLifecycle}
+	* (`phase:'end'`). Kept as a soft alias — no known subscribers.
+	*/
 	EventCategory["PipelineAnalyticsTrackEnded"] = "pipeline-analytics.track-ended";
 	EventCategory["PipelineAnalyticsDetectionEvent"] = "pipeline-analytics.detection-event";
 	EventCategory["PipelineAnalyticsFrameTracked"] = "pipeline-analytics.frame-tracked";
+	/**
+	* Fired by `addon-post-analysis` when a parked (stationary) object appears
+	* (a track was promoted to a stationary-registry entry) or departs (the
+	* object moved / was removed). Telemetry (D8): lossy, drives a UI refresh of
+	* the dedicated "Stationary" section — never the live event feed. Payload:
+	* `{ deviceId, entryId, className, phase:'appeared'|'departed', timestamp }`.
+	*/
+	EventCategory["PipelineAnalyticsStationaryChanged"] = "pipeline-analytics.stationary-changed";
+	/**
+	* Fired by `addon-post-analysis` whenever a gallery face row changes:
+	* `kind:'buffered'` a new detected face was persisted, `'assigned'` /
+	* `'unassigned'` its identity link changed, `'deleted'` the row was
+	* removed. Telemetry semantics (D8): a lost event only delays a refresh,
+	* never a correctness issue. Payload `PipelineAnalyticsFaceGalleryChangedPayload`.
+	*/
+	EventCategory["PipelineAnalyticsFaceGalleryChanged"] = "pipeline-analytics.face-gallery-changed";
+	/**
+	* Fired by `addon-post-analysis` whenever a gallery plate row changes:
+	* `kind:'buffered'` a new read was persisted (`PlateRecognizer.onTrackEnd`),
+	* `'assigned'` / `'unassigned'` its vehicle link changed
+	* (`PlateGalleryProvider`), `'deleted'` the row was removed. Telemetry
+	* semantics (D8): a lost event only delays a refresh, never a correctness
+	* issue. Payload `PipelineAnalyticsPlateGalleryChangedPayload`.
+	*/
+	EventCategory["PipelineAnalyticsPlateGalleryChanged"] = "pipeline-analytics.plate-gallery-changed";
 	EventCategory["FrigateLiveEvent"] = "frigate.live-event";
 	EventCategory["CameraStreamsProfileSlotsChanged"] = "camera-streams.onProfileSlotsChanged";
 	/**
@@ -6884,7 +6931,8 @@ var MODEL_FORMATS = [
 	"coreml",
 	"openvino",
 	"tflite",
-	"pt"
+	"pt",
+	"gguf"
 ];
 /**
 * Multi-file format payload.
@@ -6928,7 +6976,8 @@ var ModelFormatsSchema = object({
 	coreml: ModelFormatEntrySchema.optional(),
 	openvino: ModelFormatEntrySchema.optional(),
 	tflite: ModelFormatEntrySchema.optional(),
-	pt: ModelFormatEntrySchema.optional()
+	pt: ModelFormatEntrySchema.optional(),
+	gguf: ModelFormatEntrySchema.optional()
 });
 /**
 * Variant-selector grouping axes. Shared by the full `ModelCatalogEntry` and by
@@ -6969,6 +7018,15 @@ var ModelCatalogEntrySchema = object({
 		width: number(),
 		height: number()
 	}),
+	/**
+	* Channel count of the model input tensor. Omit ⇒ 3 (RGB), the default for
+	* every detector / classifier / embedder. Set to 1 for a grayscale CTC text
+	* recognizer (EasyOCR VGG plate-OCR: input `[N,1,H,W]`) so the preprocess
+	* feeds a single-channel, EasyOCR-normalized tensor instead of the default
+	* 3-channel RGB one. Threaded through `PoolModelConfig.inputChannels` to the
+	* Python inference pool.
+	*/
+	inputChannels: number().int().positive().optional(),
 	labels: array(LabelDefinitionSchema).readonly(),
 	inputLayout: _enum(["nchw", "nhwc"]).optional(),
 	inputNormalization: _enum([
@@ -6978,6 +7036,16 @@ var ModelCatalogEntrySchema = object({
 	]).optional(),
 	preprocessMode: _enum(["letterbox", "resize"]).optional(),
 	/**
+	* Per-MODEL postprocessor override. Absent ⇒ the step's own
+	* `StepDefinition.postprocessor` applies (the normal case — every model in a
+	* step shares its decode). Set it when a step hosts models with DIFFERENT raw
+	* output layouts under one slot: e.g. object-detection is `'yolo'` by default,
+	* but a Coral SSD MobileNet build emits the `TFLite_Detection_PostProcess`
+	* 4-tensor layout and needs `'ssd'`. Threaded into `PoolModelConfig.postprocessor`
+	* by the engine factory (`modelEntry.postprocessor ?? def.postprocessor`).
+	*/
+	postprocessor: custom().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):
@@ -10423,7 +10491,8 @@ var ModelFormatSchema$1 = _enum([
 	"coreml",
 	"openvino",
 	"tflite",
-	"pt"
+	"pt",
+	"gguf"
 ]);
 var PipelineSlotSchema = _enum([
 	"detector",
@@ -10517,7 +10586,8 @@ var EngineProvisioningSchema = object({
 	runtimeId: _enum([
 		"onnx",
 		"openvino",
-		"coreml"
+		"coreml",
+		"edgetpu"
 	]).nullable(),
 	device: string().nullable(),
 	state: _enum([
@@ -10678,7 +10748,15 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	image: _instanceof(Uint8Array).optional(),
 	referenceImage: string().optional(),
 	deviceId: number().optional(),
-	sessionId: string().optional()
+	sessionId: string().optional(),
+	/**
+	* Execution plane. 'full' (default) runs the whole tree — benchmark,
+	* reference-image, and detail-subtree calls. 'frame' is the live
+	* per-frame dispatch: ONLY root-plane steps run; crop children
+	* (inputClasses ≠ null) are skipped and served per-track via
+	* pipelineRunner.runDetailSubtree (two-plane design).
+	*/
+	plane: _enum(["full", "frame"]).optional()
 }), PipelineRunResultBridge, { kind: "mutation" }), method(object({
 	engine: PipelineEngineChoiceSchema.optional(),
 	steps: array(PipelineStepInputSchema).min(1),
@@ -10821,6 +10899,28 @@ var NativeCropResultSchema = object({
 	width: number().int().positive(),
 	height: number().int().positive()
 });
+/** Parent detection context passed to `runDetailSubtree` — the crop's
+*  originating detection, in FRAME-space coordinates. Reuses
+*  `NativeCropBboxSchema`'s `{x,y,w,h}` shape (same numeric fields; here
+*  the coordinates are frame-space rather than getNativeCrop's
+*  normalized [0,1] convention). */
+var DetailParentSchema = object({
+	bbox: NativeCropBboxSchema,
+	className: string()
+});
+/** One child-step result from `runDetailSubtree` — an embedding, label,
+*  or refined detection produced by running the crop-subtree on a
+*  single tracked detection. */
+var DetailResultSchema = object({
+	stepId: string(),
+	className: string(),
+	score: number(),
+	/** FRAME-space bbox (already mapped back from crop space). */
+	bbox: NativeCropBboxSchema.optional(),
+	embedding: string().optional(),
+	label: string().optional(),
+	alignedCropJpeg: string().optional()
+});
 /**
 * Per-camera tunable ranges + defaults. Single source of truth used
 * by both the Zod data schema (validation + default fallback) and
@@ -11081,7 +11181,13 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
 	handle: FrameHandleSchema,
 	bbox: NativeCropBboxSchema,
 	maxWidth: number().int().positive().optional()
-}), NativeCropResultSchema.nullable());
+}), NativeCropResultSchema.nullable()), method(object({
+	deviceId: number(),
+	frameHandle: FrameHandleSchema.optional(),
+	cropJpeg: string().optional(),
+	parent: DetailParentSchema,
+	steps: array(string()).optional()
+}), object({ details: array(DetailResultSchema) }).nullable(), { kind: "mutation" });
 object({
 	detected: boolean(),
 	/** Ms epoch of the last detected-true observation. Null if never detected. */
@@ -11693,6 +11799,140 @@ DeviceType.Camera, method(object({ deviceId: number() }), PtzAutotrackStatusSche
 	deviceId: number(),
 	status: PtzAutotrackStatusSchema
 });
+/**
+* scene-monitor — device-scoped reference-region state cap. An operator marks
+* a rect ROI on a camera frame and names one or more states; the engine
+* (pipeline-analytics, designated post-processing node) reports which state is
+* active on an ongoing basis. Two operator-selectable check modes share every-
+* thing except the comparator: `similarity` (CLIP cosine at the same ROI coords
+* vs condition-tagged references) and `llm` (vision-LLM judgment over the crop).
+*
+* D14 device-config archetype (`deviceConfig.ui.kind:'widget'`) — the framework
+* derives the device-detail contribution; the provider carries NO hand-written
+* settings-contribution methods. `status.kind:'push'` — the engine pushes on
+* every hysteresis flip / availability change; consumers never poll.
+*/
+/** Extensible condition tag. Seeded 'day' | 'night'; open by design so more can
+*  be added without a wire break (matching falls back to any-condition refs). */
+var SceneConditionSchema = string();
+/** One captured reference — condition-tagged, model-version-gated. `embedding`
+*  is `number[]` (Float32Array does NOT survive MsgPack/UDS). */
+var SceneReferenceSchema = object({
+	embedding: array(number()),
+	modelId: string(),
+	condition: SceneConditionSchema,
+	capturedAt: number(),
+	thumbnailMediaId: string().optional()
+});
+var SceneMonitorStateSchema = object({
+	id: string(),
+	label: string(),
+	references: array(SceneReferenceSchema),
+	textPrompts: array(string()).optional(),
+	referenceCount: number(),
+	currentlyMatched: boolean()
+});
+/** Per-mode comparator params in a discriminated union so an `llm` scene never
+*  carries similarity knobs and vice-versa. */
+var SceneCheckSchema = discriminatedUnion("mode", [object({
+	mode: literal("similarity"),
+	threshold: number().min(0).max(1),
+	hysteresisCount: number().int().positive()
+}), object({
+	mode: literal("llm"),
+	prompt: string(),
+	profileId: string().optional(),
+	hysteresisCount: number().int().positive()
+})]);
+var SceneMonitorSchema = object({
+	id: string(),
+	label: string(),
+	roi: MaskRectShapeSchema,
+	enabled: boolean(),
+	triggerMode: _enum([
+		"periodic",
+		"on-motion",
+		"both"
+	]),
+	checkIntervalSec: number().optional(),
+	check: SceneCheckSchema,
+	states: array(SceneMonitorStateSchema),
+	currentStateId: string().nullable(),
+	lastCheckedAt: number().nullable(),
+	lastConfidence: number().nullable(),
+	currentCondition: SceneConditionSchema.nullable(),
+	availability: _enum(["ok", "unavailable"]),
+	unavailableReason: string().nullable()
+});
+var SceneMonitorStatusSchema = object({
+	monitors: array(SceneMonitorSchema),
+	lastFetchedAt: number()
+});
+DeviceType.Camera, method(object({ deviceId: number() }), SceneMonitorStatusSchema), method(object({
+	deviceId: number(),
+	label: string(),
+	roi: MaskRectShapeSchema,
+	check: SceneCheckSchema,
+	triggerMode: _enum([
+		"periodic",
+		"on-motion",
+		"both"
+	]).optional(),
+	checkIntervalSec: number().optional()
+}), SceneMonitorSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	monitorId: string(),
+	patch: object({
+		label: string().optional(),
+		roi: MaskRectShapeSchema.optional(),
+		enabled: boolean().optional(),
+		triggerMode: _enum([
+			"periodic",
+			"on-motion",
+			"both"
+		]).optional(),
+		checkIntervalSec: number().optional(),
+		check: SceneCheckSchema.optional()
+	})
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	monitorId: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	monitorId: string(),
+	stateId: string().optional(),
+	label: string().optional(),
+	condition: SceneConditionSchema.optional()
+}), object({
+	stateId: string(),
+	referenceCount: number()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	monitorId: string(),
+	stateId: string(),
+	index: number()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	monitorId: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
 object({
 	/** Whether the script is currently executing. */
 	isRunning: boolean(),
@@ -12100,6 +12340,36 @@ var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
 	*  with the per-track detail panel and live overlay. */
 	trackIds: array(string()).readonly()
 });
+/**
+* A parked ("stationary") object surfaced alongside occupancy — an object that
+* settled and stopped moving. It is NO LONGER a tracked object (the tracker was
+* told to forget it so it stops re-spawning tracks/events), but it IS still
+* physically present, so it keeps counting toward `frame` occupancy and is
+* listed here so the UI can show it in a dedicated "Stationary" section instead
+* of flooding the live event feed.
+*/
+var StationaryObjectSchema = object({
+	id: string(),
+	className: string(),
+	bbox: object({
+		x: number(),
+		y: number(),
+		w: number(),
+		h: number()
+	}),
+	frameWidth: number().int().nonnegative(),
+	frameHeight: number().int().nonnegative(),
+	/** When the source track was first seen. */
+	firstSeenAt: number().int(),
+	/** When the object was recognised as parked (promotion time). */
+	becameStationaryAt: number().int(),
+	/** Last frame a detection confirmed the object is still there. */
+	lastConfirmedAt: number().int(),
+	/** Enrichment label carried from the source track (identity / plate). */
+	label: string().optional(),
+	/** Native-resolution key-frame media key for the parked object's best image. */
+	keyFrameMediaKey: string().optional()
+});
 var CameraOccupancySnapshotSchema = object({
 	/** Frame timestamp of the inference result that produced this snapshot. */
 	ts: number().int(),
@@ -12108,10 +12378,15 @@ var CameraOccupancySnapshotSchema = object({
 	frameHeight: number().int().nonnegative(),
 	/** Per-zone breakdown — one entry per defined zone (user + onboard). */
 	zones: array(ZoneScopeBreakdownSchema).readonly(),
-	/** Frame-wide aggregate (everywhere, regardless of zone membership). */
+	/** Frame-wide aggregate (everywhere, regardless of zone membership).
+	*  INCLUDES currently-confirmed stationary objects (they are still present). */
 	frame: PerScopeBreakdownSchema,
 	/** Detections that landed outside every zone. Empty when no zones defined. */
-	unzoned: PerScopeBreakdownSchema
+	unzoned: PerScopeBreakdownSchema,
+	/** Parked objects on this camera (additive — absent on legacy snapshots).
+	*  Surfaced separately so the UI shows them in a dedicated section rather
+	*  than as repeated tracks/events. */
+	stationaryObjects: array(StationaryObjectSchema).readonly().optional()
 });
 /**
 * Time-series resolution. The history methods return one bucket per
@@ -12714,7 +12989,12 @@ var NotificationRuleConditionsSchema = object({
 	clipDescription: object({
 		text: string().min(1),
 		minSimilarity: number().min(0).max(1)
-	}).optional()
+	}).optional(),
+	/** Match events whose recognized-entity label (face identity name or plate
+	*  vehicle name, propagated onto `event.data.label`) is one of these values.
+	*  Empty/absent → unaffected (back-compat). Enables "notify me when <named
+	*  vehicle/person> is seen". */
+	labels: array(string()).readonly().optional()
 });
 var NotificationRuleTemplateSchema = object({
 	title: string(),
@@ -13009,11 +13289,19 @@ method(object({
 *    login page needs NO change.
 *
 *  - `widget` — a Module-Federation widget the login page mounts (via
-*    `loadRemoteBundle`) for an in-page ceremony. Covers the passkey
-*    login ceremony, which must run `@simplewebauthn/browser` INSIDE the
-*    addon bundle. The referenced widget also declares `preAuth: true` in
-*    its `addon-widgets-source` catalog entry. `auth.listLoginMethods`
-*    stamps a public `bundleUrl` from `addonId` + `bundle`.
+*    `loadRemoteBundle`) for an in-page ceremony. `auth.listLoginMethods`
+*    stamps a public `bundleUrl` from `addonId` + `bundle`. Generic
+*    mechanism kept for future use; no shipped addon uses it on the login
+*    page (the passkey ceremony below runs natively in the shell instead).
+*
+*  - `passkey` — a declarative WebAuthn ceremony the shell renders
+*    natively (`@simplewebauthn/browser` lives in `addon-admin-ui`, not in
+*    a remotely-loaded bundle). Carries the addon's effective `rpId` /
+*    `origin` (from its `resolveRpID()` / `resolveOrigin()`) so the shell
+*    can gate visibility (IP-literal origin, hostname/rpId mismatch) WITHOUT
+*    fetching any remote code pre-auth. Contribution stays unconditional —
+*    enrollment state is never leaked pre-auth; visibility is a shell
+*    decision.
 *
 * Every contribution carries a `stage`:
 *  - `primary`        — shown on the first credentials screen (OIDC /
@@ -13027,30 +13315,45 @@ method(object({
 */
 /** When a login method renders in the two-phase login flow. */
 var LoginStageEnum = _enum(["primary", "second-factor"]);
-/** One login-method contribution — redirect button OR pre-auth widget. */
-var LoginMethodContributionSchema = discriminatedUnion("kind", [object({
-	kind: literal("redirect"),
-	/** Stable id within the login-method set (e.g. `auth-oidc/google`). */
-	id: string(),
-	/** Operator-facing button label. */
-	label: string(),
-	/** lucide-react icon name. */
-	icon: string().optional(),
-	/** Addon-owned HTTP route the button navigates to (GET). */
-	startUrl: string(),
-	stage: LoginStageEnum
-}), object({
-	kind: literal("widget"),
-	/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-login`). */
-	id: string(),
-	/** Owning addon id — drives the public bundle URL + the MF namespace. */
-	addonId: string(),
-	/** Bundle filename inside the addon's dist dir (`remoteEntry.js`). */
-	bundle: string(),
-	/** MF remote descriptor — `{ remoteName, exposedModule, componentKey }`. */
-	remote: WidgetRemoteSchema,
-	stage: LoginStageEnum
-})]);
+/** One login-method contribution — redirect button, pre-auth widget, or native passkey ceremony. */
+var LoginMethodContributionSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("redirect"),
+		/** Stable id within the login-method set (e.g. `auth-oidc/google`). */
+		id: string(),
+		/** Operator-facing button label. */
+		label: string(),
+		/** lucide-react icon name. */
+		icon: string().optional(),
+		/** Addon-owned HTTP route the button navigates to (GET). */
+		startUrl: string(),
+		stage: LoginStageEnum
+	}),
+	object({
+		kind: literal("widget"),
+		/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-login`). */
+		id: string(),
+		/** Owning addon id — drives the public bundle URL + the MF namespace. */
+		addonId: string(),
+		/** Bundle filename inside the addon's dist dir (`remoteEntry.js`). */
+		bundle: string(),
+		/** MF remote descriptor — `{ remoteName, exposedModule, componentKey }`. */
+		remote: WidgetRemoteSchema,
+		stage: LoginStageEnum
+	}),
+	object({
+		kind: literal("passkey"),
+		/** Stable id within the login-method set (e.g. `auth-webauthn/passkey-direct-login`). */
+		id: string(),
+		/** Operator-facing button label. */
+		label: string(),
+		stage: LoginStageEnum,
+		/** Effective WebAuthn RP ID (`resolveRpID()`) — the shell gates visibility on it. */
+		rpId: string(),
+		/** Effective expected origin (`resolveOrigin()`), null when unconfigured. */
+		origin: string().nullable()
+	})
+]);
 method(_void(), array(LoginMethodContributionSchema).readonly());
 /**
 * Orchestrator-side destination metadata. The orchestrator computes
@@ -14971,14 +15274,14 @@ var TargetKindCapsSchema = object({
 * the union is large and not meant for runtime validation here; the exported
 * `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
 */
-var ConfigSchemaPassthrough = unknown();
+var ConfigSchemaPassthrough$1 = unknown();
 var TargetKindSchema = object({
 	kind: string(),
 	label: string(),
 	icon: string(),
 	/** Stamped by each provider so the concat-fanned catalog stays routable. */
 	addonId: string(),
-	configSchema: ConfigSchemaPassthrough,
+	configSchema: ConfigSchemaPassthrough$1,
 	supportsDiscovery: boolean(),
 	caps: TargetKindCapsSchema
 });
@@ -15031,6 +15334,298 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	enabled: boolean()
 }), _void(), { kind: "mutation" });
 /**
+* Shared LLM generate contracts — imported by BOTH `llm.cap.ts` (consumer
+* surface) and `llm-runtime.cap.ts` (node-side managed executor) so the two
+* caps stay wire-compatible without a circular cap→cap import.
+*
+* Errors are a discriminated-union RESULT, never thrown: the shape survives
+* every transport tier structurally, and failed calls still write usage rows.
+* Token counts only in v1 — no costUsd (operator decision, 2026-07-15).
+*/
+var LlmUsageSchema = object({
+	inputTokens: number(),
+	outputTokens: number()
+});
+var LlmErrorCodeSchema = _enum([
+	"timeout",
+	"rate-limited",
+	"auth",
+	"refusal",
+	"bad-request",
+	"unavailable",
+	"no-profile",
+	"budget-exceeded",
+	"adapter-error"
+]);
+var LlmGenerateResultSchema = discriminatedUnion("ok", [object({
+	ok: literal(true),
+	text: string(),
+	model: string(),
+	usage: LlmUsageSchema,
+	truncated: boolean(),
+	latencyMs: number()
+}), object({
+	ok: literal(false),
+	code: LlmErrorCodeSchema,
+	message: string(),
+	retryAfterMs: number().optional()
+})]);
+/**
+* `Uint8Array` is the sanctioned binary convention — superjson + the UDS
+* MsgPack channel round-trip typed arrays (embedding-encoder.cap.ts:29,
+* notification-output.cap.ts:27-31 precedents).
+*/
+var LlmImageSchema = object({
+	bytes: _instanceof(Uint8Array),
+	mimeType: string()
+});
+var LlmGenerateBaseInputSchema = object({
+	/** Collection routing (the notification-output posture). */
+	addonId: string().optional(),
+	/** Explicit profile; else the resolution chain (spec §3). */
+	profileId: string().optional(),
+	/** MANDATORY usage tag: 'ai-summary', 'notifier-rules', 'adhoc-ui', … */
+	consumer: string(),
+	system: string().optional(),
+	/** v1: single-turn. `messages[]` is a v2 additive field. */
+	prompt: string(),
+	/** Structured output — adapter-mapped (response_format / forced tool / responseSchema). */
+	jsonSchema: record(string(), unknown()).optional(),
+	/** Per-call override of the profile default. */
+	maxTokens: number().int().positive().optional(),
+	temperature: number().optional()
+});
+/**
+* `llm-runtime` — node-side managed llama.cpp executor (spec §4). Registered
+* on EVERY node where `addon-ai` is installed; the hub `llm` provider reaches
+* a specific node's runtime with `nodePin(profile.runtime.nodeId)` — normal
+* cap routing, zero bespoke plumbing. `internal: true`: the operator reaches
+* this only through the `llm` cap's methods.
+*
+* One running llama-server child per node in v1 (models are RAM-heavy).
+* Resource ceiling = llama-server flags + idleStopMinutes ONLY (no RSS
+* watchdog — operator decision #3).
+*/
+var ManagedModelRefSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("catalog"),
+		catalogId: string()
+	}),
+	object({
+		kind: literal("url"),
+		url: string(),
+		sha256: string().optional()
+	}),
+	object({
+		kind: literal("path"),
+		path: string()
+	})
+]);
+var ManagedRuntimeConfigSchema = object({
+	/** WHERE the runtime lives — hub or any agent. */
+	nodeId: string(),
+	/** Closed for v1; 'ollama' is a v2 candidate. */
+	engine: _enum(["llama-cpp"]),
+	model: ManagedModelRefSchema,
+	contextSize: number().int().default(4096),
+	/** 0 = CPU-only. */
+	gpuLayers: number().int().default(0),
+	/** Default: cpus-2, clamped ≥1 (resolved node-side). */
+	threads: number().int().optional(),
+	/** Concurrent slots. */
+	parallel: number().int().default(1),
+	/** Else lazy: first generate boots it. */
+	autoStart: boolean().default(false),
+	/** 0 = never; frees RAM after quiet periods. */
+	idleStopMinutes: number().int().default(30)
+});
+var LlmRuntimeStatusSchema = object({
+	/** Status is ALWAYS node-qualified. */
+	nodeId: string(),
+	state: _enum([
+		"stopped",
+		"downloading",
+		"starting",
+		"ready",
+		"crashed",
+		"failed"
+	]),
+	pid: number().optional(),
+	port: number().optional(),
+	modelPath: string().optional(),
+	modelId: string().optional(),
+	downloadProgress: number().min(0).max(1).optional(),
+	lastError: string().optional(),
+	crashesInWindow: number(),
+	/** Child RSS (sampled best-effort). */
+	memoryBytes: number().optional(),
+	vramBytes: number().optional()
+});
+var LlmNodeModelSchema = object({
+	file: string(),
+	sizeBytes: number(),
+	catalogId: string().optional(),
+	installedAt: number().optional()
+});
+var LlmRuntimeDiskUsageSchema = object({
+	nodeId: string(),
+	modelsBytes: number(),
+	freeBytes: number().optional()
+});
+method(LlmGenerateBaseInputSchema.extend({
+	images: array(LlmImageSchema).optional(),
+	runtime: ManagedRuntimeConfigSchema,
+	/** The managed profile's timeout, threaded by the hub provider. */
+	timeoutMs: number().int().positive().optional()
+}), LlmGenerateResultSchema, { kind: "mutation" }), method(object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), LlmRuntimeStatusSchema), method(object({ model: ManagedModelRefSchema }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ file: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), array(LlmNodeModelSchema)), method(object({}), LlmRuntimeDiskUsageSchema);
+/**
+* `llm` — consumer-facing LLM surface (spec §1-§3). Collection-mode: array
+* methods concat-fan across providers; single-row methods route to ONE
+* provider by the `addonId` in the call input (the notification-output
+* posture, notification-output.cap.ts:215-250). Provided by `addon-ai`
+* (hub-placed); the cap stays open for future providers.
+*
+* Profiles are ROWS (data), not addons: one row = one usable model endpoint.
+* `apiKey` is a password field — providers REDACT it on read and merge on
+* write; a stored key NEVER round-trips to a client.
+*/
+var LlmProfileKindSchema = _enum([
+	"openai-compatible",
+	"openai",
+	"anthropic",
+	"google",
+	"managed-local"
+]);
+var LlmProfileSchema = object({
+	id: string(),
+	name: string(),
+	kind: LlmProfileKindSchema,
+	/** Stamped by the provider — keeps the fanned catalog routable. */
+	addonId: string(),
+	enabled: boolean(),
+	/** Vendor model id, or the managed runtime's loaded model. */
+	model: string(),
+	/** Required for openai-compatible; override for cloud kinds. */
+	baseUrl: string().optional(),
+	/** ConfigUISchema type:'password' — never round-trips (spec §5). */
+	apiKey: string().optional(),
+	supportsVision: boolean(),
+	temperature: number().min(0).max(2).optional(),
+	maxTokens: number().int().positive().optional(),
+	timeoutMs: number().int().positive().default(6e4),
+	extraHeaders: record(string(), string()).optional(),
+	/** kind === 'managed-local' only (spec §4). */
+	runtime: ManagedRuntimeConfigSchema.optional()
+});
+/** ConfigUISchema tree passed through untyped on the wire (the
+*  notification-output `ConfigSchemaPassthrough` precedent at
+*  notification-output.cap.ts:151); the exported TS type re-tightens it. */
+var ConfigSchemaPassthrough = unknown();
+var LlmProfileKindDescriptorSchema = object({
+	kind: LlmProfileKindSchema,
+	label: string(),
+	icon: string(),
+	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	addonId: string(),
+	configSchema: ConfigSchemaPassthrough
+});
+var LlmDefaultSelectorSchema = union([object({ consumer: string() }), object({ purpose: _enum(["text", "vision"]) })]);
+var LlmDefaultSchema = object({
+	selector: LlmDefaultSelectorSchema,
+	profileId: string()
+});
+/** Server-side rollup row — getUsage never dumps raw call rows (spec §6). */
+var LlmUsageRollupSchema = object({
+	day: string(),
+	consumer: string(),
+	profileId: string(),
+	calls: number(),
+	okCalls: number(),
+	errorCalls: number(),
+	inputTokens: number(),
+	outputTokens: number(),
+	avgLatencyMs: number()
+});
+/** LLM-facing view over the reused ModelCatalogEntry mechanism (spec §4.2). */
+var ManagedModelCatalogEntrySchema = object({
+	id: string(),
+	label: string(),
+	family: string(),
+	purpose: _enum(["text", "vision"]),
+	url: string(),
+	sha256: string(),
+	sizeBytes: number(),
+	quantization: string(),
+	/** Load-time guidance shown in the picker. */
+	minRamBytes: number(),
+	contextSizeDefault: number().int(),
+	/** Vision models: companion projector file. */
+	mmprojUrl: string().optional()
+});
+var LlmRuntimeNodeSchema = object({
+	nodeId: string(),
+	reachable: boolean(),
+	status: LlmRuntimeStatusSchema.optional(),
+	disk: LlmRuntimeDiskUsageSchema.optional(),
+	error: string().optional()
+});
+var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: array(LlmImageSchema).min(1) });
+var ProfileRefInputSchema = object({
+	addonId: string(),
+	profileId: string()
+});
+method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }), method(GenerateVisionInputSchema, LlmGenerateResultSchema, { kind: "mutation" }), method(object({}), array(LlmProfileKindDescriptorSchema)), method(object({}), array(LlmProfileSchema)), method(object({ profile: LlmProfileSchema }), LlmProfileSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(ProfileRefInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(ProfileRefInputSchema, LlmGenerateResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(ProfileRefInputSchema, array(string())), method(object({}), array(LlmDefaultSchema)), method(object({
+	selector: LlmDefaultSelectorSchema,
+	profileId: string().nullable()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	since: number().optional(),
+	until: number().optional(),
+	consumer: string().optional(),
+	profileId: string().optional()
+}), array(LlmUsageRollupSchema)), method(object({}), array(ManagedModelCatalogEntrySchema)), method(object({}), array(LlmRuntimeNodeSchema)), method(object({ nodeId: string() }), array(LlmNodeModelSchema)), method(object({
+	nodeId: string(),
+	model: ManagedModelRefSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	nodeId: string(),
+	file: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(ProfileRefInputSchema, LlmRuntimeStatusSchema), method(ProfileRefInputSchema, LlmRuntimeStatusSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(ProfileRefInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * Zod schemas for persisted record types.
 *
 * These schemas serve as the single source of truth for types that are
@@ -15232,6 +15827,22 @@ var TrackSnapshotSchema = object({
 	/** MediaStore key; resolve via `getTrackMedia({ trackId })`. */
 	mediaKey: string()
 });
+/**
+* One audio-classification label heard on the track's camera while the
+* track was alive, aggregated per label. An "episode" is one persisted
+* audio event (the confident-classification path: score ≥ the device's
+* `classificationMinScore`, class-change-or-heartbeat coalesced) — NOT
+* one 32 ms inference chunk, so counts stay human-scaled.
+*/
+var TrackAudioLabelSchema = object({
+	label: string(),
+	/** Highest classification score observed across the label's episodes. */
+	peakScore: number(),
+	/** Number of coalesced audio-event episodes carrying this label. */
+	count: number(),
+	firstAt: number(),
+	lastAt: number()
+});
 var TrackSchema = object({
 	trackId: string(),
 	deviceId: number(),
@@ -15246,6 +15857,10 @@ var TrackSchema = object({
 	snapshots: array(TrackSnapshotSchema).readonly(),
 	/** Deduplicated zones the track has entered at least once. */
 	zonesVisited: array(string()).readonly(),
+	/** Deduplicated set of detector classes observed for this track over its
+	*  life (a track may be reclassified, e.g. person→vehicle). Absent on
+	*  legacy rows written before class accumulation shipped. */
+	classes: array(string()).readonly().optional(),
 	/** Cumulative normalized distance travelled (0..1 units = full frame width). */
 	totalDistance: number(),
 	state: TrackStateSchema,
@@ -15259,7 +15874,11 @@ var TrackSchema = object({
 	bestEventId: string().optional(),
 	/** Tag of the importance sub-signal that dominated the score
 	*  (identity|dwell|proximity|class|confidence|travel|zone). */
-	importanceReason: string().optional()
+	importanceReason: string().optional(),
+	/** Audio-classification labels heard on the camera during the track's
+	*  life (score ≥ device `classificationMinScore`), aggregated per label.
+	*  Absent on legacy rows / tracks with no confident audio. */
+	audioLabels: array(TrackAudioLabelSchema).readonly().optional()
 });
 var BaseEventFields = {
 	id: string(),
@@ -15407,7 +16026,7 @@ var KeyEventSchema = object({
 	/** Track lifetime in ms (lastSeen - firstSeen). */
 	windowMs: number().optional()
 });
-var TrackedDetectionSchema = object({
+object({
 	trackId: string(),
 	className: string(),
 	confidence: number(),
@@ -15415,6 +16034,23 @@ var TrackedDetectionSchema = object({
 	zones: array(string()).readonly(),
 	state: TrackStateSchema
 });
+var OverlayDetectionSchema = looseObject({
+	id: string(),
+	kind: _enum(["first-level", "detail"]),
+	macroClass: string(),
+	score: number(),
+	bbox: object({
+		x: number(),
+		y: number(),
+		width: number(),
+		height: number()
+	}),
+	labels: array(looseObject({
+		label: string(),
+		score: number()
+	})).readonly(),
+	parentId: string().optional()
+});
 var ScoredObjectEventSchema = ObjectEventSchema.extend({ score: number() });
 var SearchObjectEventsInput = object({
 	text: string(),
@@ -15425,6 +16061,20 @@ var SearchObjectEventsInput = object({
 	limit: number().default(50),
 	minScore: number().min(0).max(1).default(.2)
 });
+var TrackCascadeCountsSchema = object({
+	/** Persisted track roots deleted (authoritative). */
+	tracks: number().int(),
+	/** Object events removed with their tracks (best-effort; see note above). */
+	events: number().int(),
+	/** Track/face/plate-owned media removed (best-effort). Never identity media. */
+	media: number().int(),
+	/** Unassigned (non-enrolled) face reads removed (best-effort). */
+	faces: number().int(),
+	/** Unassigned plate reads removed (best-effort; plate leg deferred to plate-intelligence). */
+	plates: number().int(),
+	/** Per-track CLIP search vectors removed (best-effort). */
+	embeddings: number().int()
+});
 DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).readonly()), method(object({
 	deviceId: number(),
 	trackId: string()
@@ -15457,15 +16107,33 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
-	eventId: string(),
-	kind: MediaFileKindEnum.optional()
-}), array(MediaFileSchema).readonly()), method(object({ trackId: string() }), array(MediaFileSchema).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), object({
 	deviceId: number(),
-	timestamp: number(),
-	frameWidth: number(),
-	frameHeight: number(),
-	detections: array(TrackedDetectionSchema).readonly()
-}), object({
+	cutoffMs: number()
+}), TrackCascadeCountsSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number() }), TrackCascadeCountsSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	trackIds: array(string()).min(1)
+}), object({
+	deleted: number().int(),
+	failed: array(string()).readonly()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	eventId: string(),
+	kind: MediaFileKindEnum.optional()
+}), array(MediaFileSchema).readonly()), method(object({ trackId: string() }), array(MediaFileSchema).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), object({
+	deviceId: number(),
+	timestamp: number(),
+	frameWidth: number(),
+	frameHeight: number(),
+	detections: array(OverlayDetectionSchema).readonly()
+}), object({
 	deviceId: number(),
 	trackId: string(),
 	className: string()
@@ -18233,6 +18901,24 @@ DeviceType.Camera, method(object({
 	deviceId: number(),
 	status: OsdStatusSchema
 });
+var VehicleSchema = object({
+	id: string(),
+	name: string(),
+	sampleCount: number().int().nonnegative(),
+	coverMediaKey: string().optional(),
+	/** Inline base64 of the cover sample's plate crop, resolved from `coverMediaKey`. */
+	coverBase64: string().optional()
+});
+var VehicleSampleInfoSchema = object({
+	id: string(),
+	/** The plate text this sample enrolled (self-labeling — no embedding). */
+	text: string(),
+	/** OCR confidence of the enrolled read (0..1). */
+	score: number(),
+	addedAt: number().int(),
+	deviceId: number().int().optional(),
+	base64: string().optional()
+});
 var PlateInfoSchema = object({
 	plateId: string(),
 	deviceId: number().int(),
@@ -18244,6 +18930,16 @@ var PlateInfoSchema = object({
 	score: number(),
 	/** True when the text was manually corrected (exempt from retention). */
 	corrected: boolean(),
+	/** Recognized vehicle id when a matcher lookup named this read (SQL NULL → absent). */
+	recognizedVehicleId: string().optional(),
+	/** Resolved vehicle name for `recognizedVehicleId` (UI convenience). */
+	vehicleName: string().optional(),
+	/** True once the read was assigned to a vehicle (enrolled as a sample). */
+	assigned: boolean(),
+	/** keyFrame parity: the plate bbox (pixel space) on the native key frame. */
+	plateBbox: BoundingBoxSchema.optional(),
+	/** keyFrame parity: MediaStore key of the track's native-resolution key frame. */
+	keyFrameMediaKey: string().optional(),
 	base64: string().optional()
 });
 var MediaFileLiteSchema = object({
@@ -18283,6 +18979,48 @@ method(object({
 }), method(object({ plateId: string() }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(_void(), array(VehicleSchema).readonly()), method(object({ name: string().min(1) }), VehicleSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	id: string(),
+	name: string().min(1)
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ id: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ vehicleId: string() }), array(VehicleSampleInfoSchema).readonly()), method(object({
+	vehicleId: string(),
+	sampleId: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	plateId: string(),
+	vehicleId: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ plateId: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	plateIds: array(string()).min(1),
+	vehicleId: string()
+}), object({
+	assigned: number().int(),
+	failed: array(string()).readonly()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ plateIds: array(string()).min(1) }), object({
+	unassigned: number().int(),
+	failed: array(string()).readonly()
+}), {
+	kind: "mutation",
+	auth: "admin"
 });
 var ModelFormatSchema = _enum(MODEL_FORMATS);
 var HwAccelBackendInputSchema = _enum([
@@ -18361,6 +19099,10 @@ var GpuInfoSchema = object({
 	memoryMB: number().optional()
 });
 var NpuInfoSchema = object({ type: _enum(["apple-ane", "intel-npu"]) });
+var CoralInfoSchema = object({
+	type: literal("coral-edgetpu"),
+	bus: string().optional()
+});
 var HardwareInfoSchema = object({
 	platform: HardwarePlatformSchema,
 	arch: HardwareArchSchema,
@@ -18369,7 +19111,8 @@ var HardwareInfoSchema = object({
 	totalRAM_MB: number(),
 	availableRAM_MB: number(),
 	gpu: GpuInfoSchema.nullable(),
-	npu: NpuInfoSchema.nullable()
+	npu: NpuInfoSchema.nullable(),
+	coral: CoralInfoSchema.nullable().optional()
 });
 var PlatformScoreSchema = object({
 	runtime: _enum(["node", "python"]),
@@ -20828,6 +21571,168 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"llm.deleteModel": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"llm.deleteProfile": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"llm.generate": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.generateVision": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.getDefaults": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.getRuntimeStatus": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.getUsage": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.installModel": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.listModelCatalog": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listModels": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listNodeModels": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listProfileKinds": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listProfiles": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.listRuntimeNodes": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llm.setDefault": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.startRuntime": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.stopRuntime": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.testProfile": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llm.upsertProfile": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.complete": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.deleteModel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"llmRuntime.ensureStarted": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.getDiskUsage": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.installModel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"llmRuntime.listLocalModels": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.status": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.stop": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.getAllowedAddresses": {
 		capName: "local-network",
 		capScope: "system",
@@ -21458,6 +22363,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineAnalytics.deleteTracks": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineAnalytics.getActiveTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -21524,12 +22435,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.pruneTracksBefore": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.searchObjectEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.wipeAllAnalytics": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineExecutor.cacheFrameInPool": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -22028,18 +22951,48 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineRunner.runDetailSubtree": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"plateGallery.assignPlate": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"plateGallery.assignPlates": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"plateGallery.correctPlateText": {
 		capName: "plate-gallery",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"plateGallery.createVehicle": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"plateGallery.deletePlate": {
 		capName: "plate-gallery",
 		capScope: "system",
 		addonId: null,
 		access: "delete"
 	},
+	"plateGallery.deleteVehicle": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"plateGallery.getPlateByTrack": {
 		capName: "plate-gallery",
 		capScope: "system",
@@ -22058,6 +23011,30 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"plateGallery.listVehicles": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"plateGallery.listVehicleSamples": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"plateGallery.removeVehicleSample": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"plateGallery.renameVehicle": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"plateGallery.searchPlates": {
 		capName: "plate-gallery",
 		capScope: "system",
@@ -22070,6 +23047,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"plateGallery.unassignPlate": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"plateGallery.unassignPlates": {
+		capName: "plate-gallery",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"platformProbe.getCapabilities": {
 		capName: "platform-probe",
 		capScope: "system",
@@ -22262,6 +23251,48 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"sceneMonitor.captureReference": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"sceneMonitor.createScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"sceneMonitor.deleteReference": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
+	"sceneMonitor.deleteScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
+	"sceneMonitor.listScenes": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"sceneMonitor.recheckNow": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"sceneMonitor.updateScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"scriptRunner.run": {
 		capName: "script-runner",
 		capScope: "device",
@@ -23346,6 +24377,7 @@ Object.freeze({
 Object.freeze({
 	"broker": "broker",
 	"device-export": "device-export",
+	"llm": "ai",
 	"mesh-network": "mesh",
 	"mqtt-broker": "broker",
 	"network-access": "ingress",
@@ -23480,77 +24512,12 @@ function rankDecodeHwAccels(preferred, supportedMethods) {
 	return candidates.sort((a, b) => decodeHwAccelRankIndex(a) - decodeHwAccelRankIndex(b));
 }
 //#endregion
-//#region src/shm-orphan-purge.ts
-/**
-* Startup reclamation of orphaned shared-memory segments.
-*
-* A decoder writes frames into named `/dev/shm` segments and unlinks each one
-* on graceful session teardown (`DecoderFrameRingSink.destroy`). When the
-* decoder process dies *ungracefully* — SIGBUS, OOM-kill, or a SIGKILL during
-* redeploy — that teardown never runs and the segment is orphaned: it stays in
-* the tmpfs forever, since nothing else knows its name. Across many
-* crashes/redeploys these accumulate until `/dev/shm` fills, at which point the
-* next `mmap` write faults with an uncatchable SIGBUS and the decoder
-* crash-loops into its circuit breaker (which is exactly the incident this
-* guards against).
-*
-* The reclamation is safe *at process startup*: a freshly-booting decoder owns
-* no live sessions, so every pre-existing segment with its prefix is by
-* definition an orphan from a dead instance. `shm_unlink` only removes the
-* name — any consumer still holding a mapping keeps reading valid memory until
-* it closes (POSIX deferred reclaim + the ring seqlock), so unlinking is safe
-* even if a stale reader is momentarily still attached.
-*
-* POSIX-only: segments surface as files under `/dev/shm` on Linux. On platforms
-* without that directory (Windows, macOS) the scan finds nothing — no-op.
-*
-* NOTE: this lives inside the decoder addon (not `@camstack/shm-ring`) so it
-* ships in the self-contained addon bundle via `camstack deploy`, reusing the
-* already-deployed `unlinkSegment`; no host base-image rebuild required.
-*/
-/** Default tmpfs directory where POSIX shared-memory segments appear on Linux. */
-var DEFAULT_SHM_DIR = "/dev/shm";
-/**
-* Unlink every shared-memory segment whose name starts with `prefix`.
-*
-* Intended to run ONCE at decoder startup, before any session is created, to
-* reclaim segments orphaned by a previously-crashed instance. A per-file unlink
-* failure is swallowed so one stuck segment cannot block reclaiming the rest.
-*/
-function purgeOrphanSegments(prefix, options = {}) {
-	const dir = options.dir ?? DEFAULT_SHM_DIR;
-	const unlink = options.unlink ?? unlinkSegment;
-	let entries;
-	try {
-		entries = readdirSync(dir);
-	} catch {
-		return {
-			scanned: 0,
-			removed: 0,
-			names: []
-		};
-	}
-	const names = [];
-	for (const name of entries) {
-		if (!name.startsWith(prefix)) continue;
-		try {
-			unlink(name);
-			names.push(name);
-		} catch {}
-	}
-	return {
-		scanned: entries.length,
-		removed: names.length,
-		names
-	};
-}
-//#endregion
 //#region src/shared/notifying-ring-buffer.ts
 /**
 * A {@link RingBuffer} that can notify a single blocked consumer the moment an
-* item commits — the server side of the `pullFrames`/`pullHandles` long-poll.
+* item commits — the server side of the `pullFrames` long-poll.
 *
-* The decoder's `onFrame`/`onFrameHandle` callback drives `push()`; a consumer
+* The decoder's `onFrame` callback drives `push()`; a consumer
 * that finds the ring momentarily empty calls {@link waitForItem} and is woken
 * on the very next `push()` (a real commit signal) rather than spinning at
 * ~1kHz on `setTimeout(…,1)`. If nothing commits it resolves after `waitMs`,
@@ -23888,19 +24855,7 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 	config;
 	logger;
 	frameCallbacks = /* @__PURE__ */ new Set();
-	handleCallbacks = /* @__PURE__ */ new Set();
 	destroyed = false;
-	/**
-	* Frame delivery mode (see {@link DecoderFrameSink}). `'shm'` lazily
-	* constructs `frameRingSink` and routes every decoded frame through it.
-	*/
-	frameSink;
-	/**
-	* The shared-memory ring writer for this stream. Created lazily on the
-	* first decoded frame in `'shm'` mode (the segment cannot be sized until
-	* the output geometry is known) and torn down in `destroy`.
-	*/
-	frameRingSink = null;
 	parser = null;
 	codecCtx = null;
 	scaler = null;
@@ -24021,8 +24976,6 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 	startTime = Date.now();
 	hwaccelPref;
 	hwaccelResolver;
-	/** Cluster node id stamped into every `FrameHandle` the `'shm'` sink emits. */
-	nodeId;
 	/** The backend that actually initialised successfully — `'none'` = software fallback. */
 	activeHwAccel = "none";
 	hwDevice = null;
@@ -24054,35 +25007,6 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		this.outputMode = NodeAvDecoderSession.resolveOutputMode(config.outputFormat);
 		this.hwaccelPref = options?.hwaccel ?? "auto";
 		this.hwaccelResolver = options?.hwaccelResolver ?? null;
-		this.frameSink = options?.frameSink ?? "callback";
-		this.nodeId = options?.nodeId ?? "local";
-	}
-	/**
-	* The shared-memory ring sink for this stream, or `null` before the first
-	* `'shm'`-mode frame lazily creates it. Exposed so the owning addon can
-	* surface ring stats via `decoder.getShmStats`.
-	*/
-	get frameRingSinkOrNull() {
-		return this.frameRingSink;
-	}
-	/**
-	* Lazily build the shared-memory ring sink for this stream. The segment
-	* itself is still created lazily by the sink on its first `writeFrame`,
-	* once the decoded geometry is known.
-	*/
-	ensureFrameRingSink() {
-		if (this.frameRingSink === null) {
-			const seedParts = [];
-			if (typeof this.config.deviceId === "number") seedParts.push(String(this.config.deviceId));
-			if (typeof this.config.tag === "string" && this.config.tag.length > 0) seedParts.push(this.config.tag);
-			const seed = seedParts.length > 0 ? seedParts.join(":") : "anon";
-			this.frameRingSink = new DecoderFrameRingSink({
-				seed,
-				logger: this.logger,
-				nodeId: this.nodeId
-			});
-		}
-		return this.frameRingSink;
 	}
 	/**
 	* Resolve the backend preference list and try each one against
@@ -24706,10 +25630,6 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		}
 		if (!this.dstFrame || !this.scaler) return;
 		const decodeStart = performance.now();
-		if (this.frameSink === "shm" && this.outputMode !== "jpeg") {
-			this.scaleIntoRingSlot(frame, decodeStart);
-			return;
-		}
 		try {
 			this.dstFrame.makeWritable();
 			this.scaler.scaleFrameSync(this.dstFrame, frame);
@@ -24754,100 +25674,6 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		else this.emitRawFrame(rawBuf, "gray", decodeStart);
 	}
 	/**
-	* Scale a decoded frame **directly into a shared-memory ring slot** — the
-	* zero write-side copy path (Phase 5 / D9 Task 7c).
-	*
-	* `beginFrame` reserves the slot (its seqlock open / odd — readers skip it);
-	* `SoftwareScaleContext.scaleSync` (the low-level `sws_scale` mapping) writes
-	* the packed pixels straight into the slot buffer with `linesize = width ×
-	* bpp` — no linesize padding, so there is nothing to strip and nothing to
-	* memcpy; `commitFrame` writes the metadata, closes the seqlock and publishes
-	* the slot. The decoded source planes feed `scaleSync` as `srcSlice` +
-	* `srcStride` (`frame.data` / `frame.linesize`).
-	*
-	* Used only for raw output formats (rgb/bgr/gray). The jpeg path keeps the
-	* `dstFrame` + sharp encode route because sharp must consume an RGB buffer
-	* before the final (variable-length) jpeg bytes exist.
-	*/
-	scaleIntoRingSlot(frame, decodeStart) {
-		if (!this.scaler) return;
-		const format = this.outputMode === "gray" ? "gray" : "rgb";
-		const channels = this.outputMode === "gray" ? 1 : 3;
-		const sink = this.ensureFrameRingSink();
-		const reserved = sink.beginFrame(this.outWidth, this.outHeight, format);
-		if (reserved === null) {
-			this.droppedFrames++;
-			return;
-		}
-		const srcPlanes = frame.data;
-		if (!srcPlanes || srcPlanes.length === 0) {
-			sink.abortFrame(reserved.slot);
-			this.droppedFrames++;
-			return;
-		}
-		const dstStride = this.outWidth * channels;
-		const needed = dstStride * this.outHeight;
-		if (reserved.buffer.length < needed) {
-			this.logger.warn("node-av: ring slot too small for scaled frame — dropping", { meta: {
-				needed,
-				slotBytes: reserved.buffer.length,
-				width: this.outWidth,
-				height: this.outHeight
-			} });
-			sink.abortFrame(reserved.slot);
-			this.droppedFrames++;
-			return;
-		}
-		try {
-			const srcStrides = Array.from(frame.linesize).slice(0, srcPlanes.length);
-			this.scaler.scaleSync(Array.from(srcPlanes), srcStrides, 0, frame.height, [reserved.buffer], [dstStride]);
-		} catch (err) {
-			this.logger.warn("node-av scale-into-slot error", { meta: { error: errMsg(err) } });
-			sink.abortFrame(reserved.slot);
-			this.droppedFrames++;
-			return;
-		}
-		const decodeMs = performance.now() - decodeStart;
-		this.totalDecodeTimeMs += decodeMs;
-		this.outputFrames++;
-		this.lastEmitTime = performance.now();
-		if (!this.firstFrameLogged) {
-			this.firstFrameLogged = true;
-			this.logger.info("node-av: scaled directly into shm ring slot", { meta: {
-				phase: "frame-debug",
-				width: this.outWidth,
-				height: this.outHeight,
-				dstStride,
-				format
-			} });
-		}
-		if (this.outputFrames === 1 || this.outputFrames % 500 === 0) this.logger.info("node-av frame emitted", { meta: {
-			frameNumber: this.outputFrames,
-			width: this.outWidth,
-			height: this.outHeight,
-			format,
-			decodeMs,
-			sink: "shm",
-			subs: this.handleCallbacks.size
-		} });
-		const handle = sink.commitFrame(reserved.slot, {
-			width: this.outWidth,
-			height: this.outHeight,
-			format,
-			pts: performance.now(),
-			byteLength: dstStride * this.outHeight
-		});
-		if (handle === null) {
-			this.droppedFrames++;
-			return;
-		}
-		const delivered = {
-			handle,
-			timestamp: Date.now()
-		};
-		for (const cb of this.handleCallbacks) cb(delivered);
-	}
-	/**
 	* Extract packed pixel buffer from a decoded frame.
 	* FFmpeg's av_frame_get_buffer() may pad each row to alignment (32/64 bytes).
 	* Sharp and WASM consumers expect tightly-packed rows (stride = width * channels).
@@ -24906,13 +25732,8 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 			height: this.outHeight,
 			format,
 			decodeMs,
-			sink: this.frameSink,
-			subs: this.frameSink === "shm" ? this.handleCallbacks.size : this.frameCallbacks.size
+			subs: this.frameCallbacks.size
 		} });
-		if (this.frameSink === "shm") {
-			this.emitShmFrame(data, format);
-			return;
-		}
 		const decodedFrame = {
 			data,
 			width: this.outWidth,
@@ -24922,47 +25743,12 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		};
 		for (const cb of this.frameCallbacks) cb(decodedFrame);
 	}
-	/**
-	* Write a decoded frame into this stream's shared-memory ring and deliver
-	* the resulting `FrameHandle` to `onFrameHandle` subscribers. No pixel
-	* `Buffer` is handed to callbacks — consumers open the segment and read the
-	* pixels zero-copy via a `FrameRingReader`.
-	*/
-	emitShmFrame(data, format) {
-		const handle = this.ensureFrameRingSink().writeFrame(data, {
-			width: this.outWidth,
-			height: this.outHeight,
-			format,
-			pts: performance.now(),
-			byteLength: data.byteLength
-		});
-		if (handle === null) {
-			this.droppedFrames++;
-			return;
-		}
-		const frame = {
-			handle,
-			timestamp: Date.now()
-		};
-		for (const cb of this.handleCallbacks) cb(frame);
-	}
 	onFrame(callback) {
 		this.frameCallbacks.add(callback);
 		return () => {
 			this.frameCallbacks.delete(callback);
 		};
 	}
-	/**
-	* Subscribe to shared-memory frame handles. Fires only when the session was
-	* created with `frameSink: 'shm'`; in the legacy `'callback'` mode no
-	* handles are produced and this subscription never fires.
-	*/
-	onFrameHandle(callback) {
-		this.handleCallbacks.add(callback);
-		return () => {
-			this.handleCallbacks.delete(callback);
-		};
-	}
 	updateConfig(update) {
 		const prevFormat = this.config.outputFormat;
 		this.config = {
@@ -25000,7 +25786,6 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		if (this.destroyed) return;
 		this.destroyed = true;
 		this.frameCallbacks.clear();
-		this.handleCallbacks.clear();
 		this.pullActive = false;
 		if (this.pullRedialTimer) {
 			clearTimeout(this.pullRedialTimer);
@@ -25016,8 +25801,6 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 			if (!this.pullHwContext.isDisposed) this.pullHwContext.dispose();
 			this.pullHwContext = null;
 		}
-		this.frameRingSink?.destroy();
-		this.frameRingSink = null;
 		this.dstFrame?.[Symbol.dispose]?.();
 		this.avFrame?.[Symbol.dispose]?.();
 		this.avPacket?.[Symbol.dispose]?.();
@@ -25845,27 +26628,14 @@ var FRAME_BUFFER_CAPACITY = 32;
 var DecoderNodeAvAddon = class extends BaseAddon {
 	/**
 	* Sessions are stored as the concrete `NodeAvDecoderSession` (the only type
-	* this addon ever creates) so `getShmStats` can reach the per-session shm
-	* ring sink — `IDecoderSession` does not expose it.
+	* this addon ever creates).
 	*/
 	sessions = /* @__PURE__ */ new Map();
-	/** Pixel-frame buffers — populated only for `frameSink: 'callback'` sessions. */
+	/** Pixel-frame buffers drained by `pullFrames`. */
 	frameBuffers = /* @__PURE__ */ new Map();
-	/** `FrameHandle` buffers — populated only for `frameSink: 'shm'` sessions. */
-	handleBuffers = /* @__PURE__ */ new Map();
 	unsubscribers = /* @__PURE__ */ new Map();
 	sessionMeta = /* @__PURE__ */ new Map();
 	/**
-	* Per-shm-segment `FrameRingReader` cache backing `getFrame`. Opens each
-	* named segment once and reuses the reader for every later handle on it;
-	* built in `onInitialize` (it needs the scoped logger) and closed in
-	* `onShutdown`.
-	*/
-	frameReaders = null;
-	/** Running `getFrame` hit/miss counters surfaced via `getShmStats`. */
-	getFrameHits = 0;
-	getFrameMisses = 0;
-	/**
 	* node-av audio-codec provider — registered independently of the video
 	* decoder backend gate whenever node-av loads on this node, so this single
 	* addon provides both the `decoder` and `audio-codec` caps.
@@ -25930,12 +26700,6 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 			return registrations;
 		}
 		this.ctx.logger.info("node-av decoder addon initialized", { meta: { selectedBackend: backend } });
-		const purged = purgeOrphanSegments(SEGMENT_NAME_PREFIX);
-		if (purged.removed > 0) this.ctx.logger.warn("node-av decoder: reclaimed orphaned shm segments at startup", { meta: {
-			removed: purged.removed,
-			scanned: purged.scanned
-		} });
-		this.frameReaders = new FrameRingReaderCache(this.ctx.logger);
 		if (!this.config.probedBestHwaccel) this.reprobeHwaccel().catch((err) => {
 			this.ctx.logger.warn("nodeav: auto-reprobe hwaccel failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
@@ -26002,11 +26766,11 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 	}
 	/**
 	* The cluster node id of this decoder — the Moleculer nodeID (`hub`,
-	* `dev-agent-0`, …), not the addon id. Stamped into session-owned
-	* `FrameHandle`s so a downstream consumer routes `getFrame` to the node
-	* that holds the shm ring. A hierarchical broker nodeID (`hub/...`) is
-	* collapsed to the cluster-visible parent; in-process boot is left as-is.
-	* Mirrors the resolution `PipelineRunnerAddon.onInitialize` performs.
+	* `dev-agent-0`, …), not the addon id. Returned from `createSession` so the
+	* caller can route session-scoped calls to the node that owns the session.
+	* A hierarchical broker nodeID (`hub/...`) is collapsed to the
+	* cluster-visible parent; in-process boot is left as-is. Mirrors the
+	* resolution `PipelineRunnerAddon.onInitialize` performs.
 	*/
 	resolveLocalNodeId() {
 		const raw = this.ctx.kernel.localNodeId ?? this.ctx.id;
@@ -26015,15 +26779,12 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 	async createSession(config) {
 		const sessionId = randomUUID();
 		const hwaccel = await this.resolveHwAccelPref();
-		const { frameSink } = config;
 		const nodeId = this.resolveLocalNodeId();
 		const session = new NodeAvDecoderSession(config, this.ctx.logger, {
 			hwaccel,
-			hwaccelResolver: this.ctx.kernel.hwaccel,
-			frameSink,
-			nodeId
+			hwaccelResolver: this.ctx.kernel.hwaccel
 		});
-		const unsub = frameSink === "shm" ? this.wireShmSink(sessionId, session) : this.wireCallbackSink(sessionId, session);
+		const unsub = this.wireCallbackSink(sessionId, session);
 		this.sessions.set(sessionId, session);
 		this.unsubscribers.set(sessionId, unsub);
 		this.sessionMeta.set(sessionId, {
@@ -26038,7 +26799,6 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 				sessionId,
 				codec: config.codec,
 				hwaccelPref: hwaccel,
-				frameSink,
 				nodeId
 			}
 		});
@@ -26069,18 +26829,6 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 			ringBuffer.push(capFrame);
 		});
 	}
-	/**
-	* Subscribe a `'shm'` session's `FrameHandle`s into a per-session ring
-	* buffer drained by `pullHandles`. No pixel bytes cross the cap boundary
-	* — the broker opens the named segment and reads the pixels zero-copy.
-	*/
-	wireShmSink(sessionId, session) {
-		const handleRing = new NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
-		this.handleBuffers.set(sessionId, handleRing);
-		return session.onFrameHandle((frame) => {
-			handleRing.push(frame.handle);
-		});
-	}
 	async destroySession(input) {
 		const { sessionId } = input;
 		const session = this.sessions.get(sessionId);
@@ -26088,12 +26836,10 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		const unsub = this.unsubscribers.get(sessionId);
 		if (unsub) unsub();
 		this.frameBuffers.get(sessionId)?.cancel();
-		this.handleBuffers.get(sessionId)?.cancel();
 		const deviceId = this.sessionMeta.get(sessionId)?.deviceId;
 		await session.destroy();
 		this.sessions.delete(sessionId);
 		this.frameBuffers.delete(sessionId);
-		this.handleBuffers.delete(sessionId);
 		this.unsubscribers.delete(sessionId);
 		this.sessionMeta.delete(sessionId);
 		this.ctx.logger.info("node-av: destroyed session", {
@@ -26133,12 +26879,14 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		if (ringBuffer.size === 0 && input.waitMs) await ringBuffer.waitForItem(input.waitMs);
 		return ringBuffer.drain(input.maxCount);
 	}
-	async pullHandles(input) {
-		if (!this.sessions.has(input.sessionId)) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		const handleRing = this.handleBuffers.get(input.sessionId);
-		if (!handleRing) return [];
-		if (handleRing.size === 0 && input.waitMs) await handleRing.waitForItem(input.waitMs);
-		return handleRing.drain(input.maxCount);
+	/**
+	* DORMANT — the shm `FrameHandle` frame plane is retired. Every session now
+	* delivers pixels over the callback path drained by `pullFrames`, so no
+	* handles are ever produced. Kept to satisfy the (still-defined) cap method;
+	* always returns an empty list. Removal rides a later framework train.
+	*/
+	async pullHandles() {
+		return [];
 	}
 	async updateConfig(input) {
 		const session = this.sessions.get(input.sessionId);
@@ -26151,50 +26899,22 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		return session.getStats();
 	}
 	/**
-	* Read back the pixels a `FrameHandle` refers to from this node's shm ring
-	* (Phase 5 / D9 downstream access). Returns `null` when the slot was
-	* already recycled (latest-wins drop) or the segment could not be opened.
-	* The reader cache opens each named segment once and reuses the reader.
-	*
-	* The reader hands back a `Buffer` view over its **reusable scratch
-	* buffer**, only valid until the next `read` on the same reader; the
-	* cap caller may keep the frame across reads, so the pixels are copied
-	* into a fresh detached `ArrayBuffer` here. This matches the existing
-	* callback-path copy in `wireCallbackSink`.
+	* DORMANT — shm handle read-back is retired (the decoder no longer owns a
+	* `/dev/shm` ring). Kept to satisfy the (still-defined) cap method; always
+	* returns `null`. Full-frame retrieval by handle now flows through the
+	* runner's RAM-backed `pipelineRunner.getNativeCrop`. Removal rides a later
+	* framework train.
 	*/
-	async getFrame(input) {
-		const frame = this.frameReaders?.read(input.handle) ?? null;
-		if (!frame) {
-			this.getFrameMisses += 1;
-			return null;
-		}
-		this.getFrameHits += 1;
-		const arrayBuf = new ArrayBuffer(frame.data.byteLength);
-		new Uint8Array(arrayBuf).set(frame.data);
-		return {
-			data: new Uint8Array(arrayBuf),
-			width: frame.width,
-			height: frame.height,
-			format: frame.format,
-			timestamp: frame.timestamp
-		};
+	async getFrame() {
+		return null;
 	}
 	/**
-	* shm ring usage stats for a `frameSink: 'shm'` session — slot geometry,
-	* frames written, byte budget, plus this addon's running `getFrame`
-	* hit/miss counters. Returns `null` for an unknown session or one whose
-	* shm ring has not yet been armed by a first decoded frame.
+	* DORMANT — no shm ring exists to report stats for. Kept to satisfy the
+	* (still-defined) cap method; always returns `null`. Removal rides a later
+	* framework train.
 	*/
-	async getShmStats(input) {
-		const stats = this.sessions.get(input.sessionId)?.frameRingSinkOrNull?.getShmStats() ?? null;
-		if (!stats) return null;
-		return {
-			sessionId: input.sessionId,
-			...stats,
-			budgetMb: RING_BUDGET_MB,
-			getFrameHits: this.getFrameHits,
-			getFrameMisses: this.getFrameMisses
-		};
+	async getShmStats() {
+		return null;
 	}
 	async onShutdown() {
 		this.audioProvider?.stop();
@@ -26209,12 +26929,9 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		await Promise.all(destroyPromises);
 		this.sessions.clear();
 		this.frameBuffers.clear();
-		this.handleBuffers.clear();
 		this.unsubscribers.clear();
 		this.sessionMeta.clear();
-		this.frameReaders?.close();
-		this.frameReaders = null;
 	}
 };
 //#endregion
-export { DecoderFrameRingSink, DecoderNodeAvAddon, DecoderNodeAvAddon as default, NodeAvAudioCodecProvider, NodeAvAudioDecodeSession, NodeAvAudioEncodeSession, NodeAvDecoderSession, loadNodeAvRuntime, makeSegmentName, peekNodeAvRuntime };
+export { DecoderNodeAvAddon, DecoderNodeAvAddon as default, NodeAvAudioCodecProvider, NodeAvAudioDecodeSession, NodeAvAudioEncodeSession, NodeAvDecoderSession, loadNodeAvRuntime, peekNodeAvRuntime };