@camstack/types 1.2.322 → 1.2.323

package/dist/capabilities/pipeline-runner.cap.d.ts

@@ -491,7 +491,6 @@ declare const RunnerLocalLoadSchema: z.ZodObject<{
         deviceKey: z.ZodString;
         backend: z.ZodString;
         attachedCameras: z.ZodNumber;
-        queueDepthTotal: z.ZodNumber;
     }, z.core.$strip>>>;
     hardware: z.ZodObject<{
         hasGpu: z.ZodBoolean;
@@ -818,7 +817,6 @@ export declare const pipelineRunnerCapability: {
                 deviceKey: z.ZodString;
                 backend: z.ZodString;
                 attachedCameras: z.ZodNumber;
-                queueDepthTotal: z.ZodNumber;
             }, z.core.$strip>>>;
             hardware: z.ZodObject<{
                 hasGpu: z.ZodBoolean;

package/dist/capabilities/schemas/streaming-shared.d.ts

@@ -170,35 +170,12 @@ export declare const StreamSourceSchema: z.ZodObject<{
     audioCodec: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
-export declare const EncodedPacketSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        audio: "audio";
-        video: "video";
-    }>;
-    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
-    pts: z.ZodNumber;
-    dts: z.ZodNumber;
-    keyframe: z.ZodBoolean;
-    codec: z.ZodString;
-}, z.core.$strip>;
-export declare const DecodedFrameSchema: z.ZodObject<{
-    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
-    width: z.ZodNumber;
-    height: z.ZodNumber;
-    format: z.ZodEnum<{
-        jpeg: "jpeg";
-        rgb: "rgb";
-        bgr: "bgr";
-        yuv420: "yuv420";
-        gray: "gray";
-    }>;
-    timestamp: z.ZodNumber;
-}, z.core.$strip>;
 /**
  * Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
  * frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
- * interface in `interfaces/frame-handle.ts` field-for-field so a decoder cap
- * method (`pullHandles`) can carry handles over tRPC / Moleculer.
+ * interface in `interfaces/frame-handle.ts` field-for-field so a cap method
+ * (the runner's native-crop and pipeline-executor inputs) can carry handles
+ * over tRPC / Moleculer.
  *
  * The `satisfies` assertion below pins this schema to the interface: if a
  * field is added to / removed from `FrameHandle` without a matching schema
@@ -223,49 +200,6 @@ export declare const FrameHandleSchema: z.ZodObject<{
     nodeId: z.ZodString;
     slotCount: z.ZodNumber;
 }, z.core.$strip>;
-/**
- * Pixel format a frame-handle subscriber can request from the broker
- * (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
- * `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
- * `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
- * payload, and no decoded-frame consumer requests it over the shm plane.
- */
-export declare const FrameHandleFormatSchema: z.ZodEnum<{
-    rgb: "rgb";
-    bgr: "bgr";
-    yuv420: "yuv420";
-    gray: "gray";
-}>;
-export type FrameHandleFormat = z.infer<typeof FrameHandleFormatSchema>;
-/**
- * Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
- * broker for a `FrameHandle` stream of one `format`; the broker maintains one
- * shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
- * subscriber (motion) and an `rgb` subscriber (detection) each read the format
- * they asked for with no broker-side conversion.
- */
-export declare const SubscribeFramesInputSchema: z.ZodObject<{
-    brokerId: z.ZodString;
-    format: z.ZodEnum<{
-        rgb: "rgb";
-        bgr: "bgr";
-        yuv420: "yuv420";
-        gray: "gray";
-    }>;
-    maxFps: z.ZodOptional<z.ZodNumber>;
-    tag: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type SubscribeFramesInput = z.infer<typeof SubscribeFramesInputSchema>;
-/**
- * Result of `stream-broker.subscribeFrames`. The consumer then polls
- * `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
- * `FrameHandle` to a `FrameRingReader`.
- */
-export declare const SubscribeFramesResultSchema: z.ZodObject<{
-    subscriptionId: z.ZodString;
-    maxFps: z.ZodNumber;
-}, z.core.$strip>;
-export type SubscribeFramesResult = z.infer<typeof SubscribeFramesResultSchema>;
 /**
  * Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
  * `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
@@ -274,8 +208,8 @@ export type SubscribeFramesResult = z.infer<typeof SubscribeFramesResultSchema>;
  * Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
  * Float32 PCM), so unlike video frames they ship their bytes INLINE over
  * tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
- * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
- * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
+ * (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
+ * it.
  */
 export declare const AudioChunkFormatSchema: z.ZodEnum<{
     f32le: "f32le";
@@ -295,11 +229,10 @@ export declare const DecodedAudioChunkSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type DecodedAudioChunkWire = z.infer<typeof DecodedAudioChunkSchema>;
 /**
- * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
- * handle-free, ship-bytes-inline analogue of `subscribeFrames`: a consumer
- * asks the broker for the decoded audio-chunk stream of one broker; the
- * broker keeps a per-subscription bounded FIFO queue the consumer drains via
- * `pullAudioChunks`.
+ * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
+ * its bytes inline: a consumer asks the broker for the decoded audio-chunk
+ * stream of one broker; the broker keeps a per-subscription bounded FIFO queue
+ * the consumer drains via `pullAudioChunks`.
  */
 export declare const SubscribeAudioChunksInputSchema: z.ZodObject<{
     brokerId: z.ZodString;
@@ -332,9 +265,7 @@ export declare const BrokerStatsSchema: z.ZodObject<{
         stopped: "stopped";
     }>;
     inputFps: z.ZodNumber;
-    decodeFps: z.ZodNumber;
     encodedSubscribers: z.ZodNumber;
-    decodedSubscribers: z.ZodNumber;
     uptimeMs: z.ZodNumber;
     bitrateKbps: z.ZodNumber;
     idrIntervalMs: z.ZodNumber;
@@ -346,7 +277,6 @@ export declare const BrokerStatsSchema: z.ZodObject<{
     preBufferSec: z.ZodNumber;
     preBufferMs: z.ZodNumber;
     preBufferPackets: z.ZodNumber;
-    decoderNodeId: z.ZodNullable<z.ZodString>;
     audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         codec: z.ZodString;
         sampleRate: z.ZodNumber;

package/dist/capabilities/stream-broker.cap.d.ts

@@ -110,13 +110,6 @@ export declare const BrokerRtspClientSchema: z.ZodObject<{
     lastRtpAt: z.ZodNumber;
     bytesSent: z.ZodNumber;
 }, z.core.$strip>;
-export declare const BrokerDecodedClientSchema: z.ZodObject<{
-    tag: z.ZodString;
-    subscribedAt: z.ZodNumber;
-    maxFps: z.ZodNumber;
-    framesDelivered: z.ZodNumber;
-    framesDropped: z.ZodNumber;
-}, z.core.$strip>;
 export declare const BrokerAudioClientSchema: z.ZodObject<{
     tag: z.ZodString;
     subscribedAt: z.ZodNumber;
@@ -232,13 +225,6 @@ export declare const BrokerClientsSchema: z.ZodObject<{
         lastRtpAt: z.ZodNumber;
         bytesSent: z.ZodNumber;
     }, z.core.$strip>>>;
-    decoded: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        tag: z.ZodString;
-        subscribedAt: z.ZodNumber;
-        maxFps: z.ZodNumber;
-        framesDelivered: z.ZodNumber;
-        framesDropped: z.ZodNumber;
-    }, z.core.$strip>>>;
     audio: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         tag: z.ZodString;
         subscribedAt: z.ZodNumber;
@@ -290,7 +276,6 @@ export declare const BrokerClientsSchema: z.ZodObject<{
     encodedSubscribers: z.ZodNumber;
 }, z.core.$strip>;
 export type BrokerRtspClient = z.infer<typeof BrokerRtspClientSchema>;
-export type BrokerDecodedClient = z.infer<typeof BrokerDecodedClientSchema>;
 export type BrokerAudioClient = z.infer<typeof BrokerAudioClientSchema>;
 export type BrokerClients = z.infer<typeof BrokerClientsSchema>;
 export declare const PlaceholderReasonSchema: z.ZodEnum<{
@@ -914,9 +899,7 @@ export declare const streamBrokerCapability: {
                 stopped: "stopped";
             }>;
             inputFps: z.ZodNumber;
-            decodeFps: z.ZodNumber;
             encodedSubscribers: z.ZodNumber;
-            decodedSubscribers: z.ZodNumber;
             uptimeMs: z.ZodNumber;
             bitrateKbps: z.ZodNumber;
             idrIntervalMs: z.ZodNumber;
@@ -928,7 +911,6 @@ export declare const streamBrokerCapability: {
             preBufferSec: z.ZodNumber;
             preBufferMs: z.ZodNumber;
             preBufferPackets: z.ZodNumber;
-            decoderNodeId: z.ZodNullable<z.ZodString>;
             audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 codec: z.ZodString;
                 sampleRate: z.ZodNumber;
@@ -965,13 +947,6 @@ export declare const streamBrokerCapability: {
                 lastRtpAt: z.ZodNumber;
                 bytesSent: z.ZodNumber;
             }, z.core.$strip>>>;
-            decoded: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                tag: z.ZodString;
-                subscribedAt: z.ZodNumber;
-                maxFps: z.ZodNumber;
-                framesDelivered: z.ZodNumber;
-                framesDropped: z.ZodNumber;
-            }, z.core.$strip>>>;
             audio: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 tag: z.ZodString;
                 subscribedAt: z.ZodNumber;
@@ -1027,7 +1002,6 @@ export declare const streamBrokerCapability: {
             channel: z.ZodEnum<{
                 audio: "audio";
                 rtsp: "rtsp";
-                decoded: "decoded";
             }>;
             handle: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
@@ -1293,65 +1267,6 @@ export declare const streamBrokerCapability: {
         }, z.core.$strip>, z.ZodObject<{
             released: z.ZodBoolean;
         }, z.core.$strip>, "mutation">;
-        /**
-         * ── Shared-memory frame plane (Phase 5 / D9) ──────────────────────
-         *
-         * The handle-based replacement for the live-object `IStreamBroker.
-         * onDecodedFrame` callback path. A consumer:
-         *
-         *   1. `subscribeFrames({ brokerId, format })` — the broker spins up
-         *      (or reuses) a `frameSink: 'shm'` decoder session producing that
-         *      `format` and returns a `subscriptionId`.
-         *   2. polls `pullFrameHandles({ subscriptionId, maxCount })` — drains
-         *      zero-pixel `FrameHandle[]`; each handle is fed to a
-         *      `FrameRingReader` that opens the named shm segment and reads the
-         *      pixels back zero-copy.
-         *   3. `unsubscribeFrames({ subscriptionId })` on teardown.
-         *
-         * The broker keeps one shm ring per `(brokerId, format)` actually
-         * requested — no broker-side `sharp` conversion. fps throttling is
-         * implicit (latest-wins ring reads drop frames for a slow consumer).
-         */
-        readonly subscribeFrames: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            brokerId: z.ZodString;
-            format: z.ZodEnum<{
-                rgb: "rgb";
-                bgr: "bgr";
-                yuv420: "yuv420";
-                gray: "gray";
-            }>;
-            maxFps: z.ZodOptional<z.ZodNumber>;
-            tag: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            subscriptionId: z.ZodString;
-            maxFps: z.ZodNumber;
-        }, z.core.$strip>, "mutation">;
-        readonly pullFrameHandles: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            subscriptionId: z.ZodString;
-            maxCount: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            shmId: z.ZodString;
-            slot: z.ZodNumber;
-            seq: z.ZodNumber;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            format: z.ZodEnum<{
-                jpeg: "jpeg";
-                rgb: "rgb";
-                bgr: "bgr";
-                yuv420: "yuv420";
-                gray: "gray";
-            }>;
-            pts: z.ZodNumber;
-            byteLength: z.ZodNumber;
-            nodeId: z.ZodString;
-            slotCount: z.ZodNumber;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly unsubscribeFrames: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            subscriptionId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            released: z.ZodBoolean;
-        }, z.core.$strip>, "mutation">;
         readonly setPreBufferDuration: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             brokerId: z.ZodString;
             seconds: z.ZodNumber;

package/dist/capabilities/webrtc-session.cap.d.ts

@@ -73,7 +73,6 @@ export declare const WebrtcStreamChoiceSchema: z.ZodObject<{
         stopped: "stopped";
     }>>;
     inputFps: z.ZodNullable<z.ZodNumber>;
-    decodeFps: z.ZodNullable<z.ZodNumber>;
     bitrateKbps: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>;
 export type WebrtcStreamChoice = z.infer<typeof WebrtcStreamChoiceSchema>;
@@ -336,7 +335,6 @@ export declare const webrtcSessionCapability: {
                 stopped: "stopped";
             }>>;
             inputFps: z.ZodNullable<z.ZodNumber>;
-            decodeFps: z.ZodNullable<z.ZodNumber>;
             bitrateKbps: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**

package/dist/client.js

@@ -228,27 +228,6 @@ zod.z.object({
 	audioCodec: zod.z.string().optional(),
 	metadata: zod.z.record(zod.z.string(), zod.z.unknown()).readonly().optional()
 });
-zod.z.object({
-	type: zod.z.enum(["video", "audio"]),
-	data: zod.z.instanceof(Uint8Array),
-	pts: zod.z.number(),
-	dts: zod.z.number(),
-	keyframe: zod.z.boolean(),
-	codec: zod.z.string()
-});
-zod.z.object({
-	data: zod.z.instanceof(Uint8Array),
-	width: zod.z.number(),
-	height: zod.z.number(),
-	format: zod.z.enum([
-		"jpeg",
-		"rgb",
-		"bgr",
-		"yuv420",
-		"gray"
-	]),
-	timestamp: zod.z.number()
-});
 zod.z.object({
 	shmId: zod.z.string(),
 	slot: zod.z.number().int().nonnegative(),
@@ -268,38 +247,6 @@ zod.z.object({
 	slotCount: zod.z.number().int().positive()
 });
 /**
-* Pixel format a frame-handle subscriber can request from the broker
-* (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
-* `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
-* `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
-* payload, and no decoded-frame consumer requests it over the shm plane.
-*/
-var FrameHandleFormatSchema = zod.z.enum([
-	"rgb",
-	"bgr",
-	"yuv420",
-	"gray"
-]);
-zod.z.object({
-	brokerId: zod.z.string(),
-	format: FrameHandleFormatSchema,
-	/**
-	* Optional reader-side cadence hint in frames per second. The broker does
-	* NOT throttle — latest-wins ring reads drop frames implicitly for a slow
-	* consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
-	* the consumer can pace its own `pullFrameHandles` polling.
-	*/
-	maxFps: zod.z.number().positive().optional(),
-	/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
-	tag: zod.z.string().optional()
-});
-zod.z.object({
-	/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
-	subscriptionId: zod.z.string(),
-	/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
-	maxFps: zod.z.number().nonnegative()
-});
-/**
 * Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
 * `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
 * sample bytes plus the track parameters a consumer needs to interpret them.
@@ -307,8 +254,8 @@ zod.z.object({
 * Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
 * Float32 PCM), so unlike video frames they ship their bytes INLINE over
 * tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
-* (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
-* / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
+* (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
+* it.
 */
 var AudioChunkFormatSchema = zod.z.enum(AUDIO_CHUNK_FORMATS);
 zod.z.object({
@@ -354,9 +301,7 @@ var BrokerStatusSchema = zod.z.enum([
 zod.z.object({
 	status: BrokerStatusSchema,
 	inputFps: zod.z.number(),
-	decodeFps: zod.z.number(),
 	encodedSubscribers: zod.z.number(),
-	decodedSubscribers: zod.z.number(),
 	uptimeMs: zod.z.number(),
 	bitrateKbps: zod.z.number(),
 	idrIntervalMs: zod.z.number(),
@@ -369,14 +314,6 @@ zod.z.object({
 	preBufferMs: zod.z.number(),
 	preBufferPackets: zod.z.number(),
 	/**
-	* Moleculer node id of the decoder provider currently servicing this
-	* stream's decoded subscribers. `null` until the deferred decoder is
-	* created (no decoded clients yet, or codec not detected). Surfaces the
-	* runtime decoder placement so the UI can show "Decoder: <agent>" without
-	* a separate cap call per broker.
-	*/
-	decoderNodeId: zod.z.string().nullable(),
-	/**
 	* Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
 	* when the stream has no audio track or the broker is in cold start.
 	* `supported = false` means the codec was detected but the local
@@ -7152,19 +7089,7 @@ function createSystemProxy(api) {
 			validateComposition: (input) => dispatch("coreBlocks", "validateComposition", "mutation", input)
 		},
 		decoder: {
-			supportsCodec: (input) => dispatch("decoder", "supportsCodec", "query", input),
 			getInfo: (input) => dispatch("decoder", "getInfo", "query", input),
-			createSession: (input) => dispatch("decoder", "createSession", "query", input),
-			destroySession: (input) => dispatch("decoder", "destroySession", "query", input),
-			pushPacket: (input) => dispatch("decoder", "pushPacket", "query", input),
-			openStream: (input) => dispatch("decoder", "openStream", "query", input),
-			pullFrames: (input) => dispatch("decoder", "pullFrames", "query", input),
-			pullHandles: (input) => dispatch("decoder", "pullHandles", "query", input),
-			getFrame: (input) => dispatch("decoder", "getFrame", "query", input),
-			getShmStats: (input) => dispatch("decoder", "getShmStats", "query", input),
-			updateConfig: (input) => dispatch("decoder", "updateConfig", "query", input),
-			getStats: (input) => dispatch("decoder", "getStats", "query", input),
-			listActiveSessions: (input) => dispatch("decoder", "listActiveSessions", "query", input),
 			reprobeHwaccel: (input) => dispatch("decoder", "reprobeHwaccel", "mutation", input)
 		},
 		deviceAdoption: {
@@ -7641,9 +7566,6 @@ function createSystemProxy(api) {
 			subscribeAudioChunks: (input) => dispatch("streamBroker", "subscribeAudioChunks", "mutation", input),
 			pullAudioChunks: (input) => dispatch("streamBroker", "pullAudioChunks", "query", input),
 			unsubscribeAudioChunks: (input) => dispatch("streamBroker", "unsubscribeAudioChunks", "mutation", input),
-			subscribeFrames: (input) => dispatch("streamBroker", "subscribeFrames", "mutation", input),
-			pullFrameHandles: (input) => dispatch("streamBroker", "pullFrameHandles", "query", input),
-			unsubscribeFrames: (input) => dispatch("streamBroker", "unsubscribeFrames", "mutation", input),
 			setPreBufferDuration: (input) => dispatch("streamBroker", "setPreBufferDuration", "mutation", input),
 			getPreBufferInfo: (input) => dispatch("streamBroker", "getPreBufferInfo", "query", input),
 			getRtspPort: (input) => dispatch("streamBroker", "getRtspPort", "query", input),

package/dist/client.mjs

@@ -227,27 +227,6 @@ z.object({
 	audioCodec: z.string().optional(),
 	metadata: z.record(z.string(), z.unknown()).readonly().optional()
 });
-z.object({
-	type: z.enum(["video", "audio"]),
-	data: z.instanceof(Uint8Array),
-	pts: z.number(),
-	dts: z.number(),
-	keyframe: z.boolean(),
-	codec: z.string()
-});
-z.object({
-	data: z.instanceof(Uint8Array),
-	width: z.number(),
-	height: z.number(),
-	format: z.enum([
-		"jpeg",
-		"rgb",
-		"bgr",
-		"yuv420",
-		"gray"
-	]),
-	timestamp: z.number()
-});
 z.object({
 	shmId: z.string(),
 	slot: z.number().int().nonnegative(),
@@ -267,38 +246,6 @@ z.object({
 	slotCount: z.number().int().positive()
 });
 /**
-* Pixel format a frame-handle subscriber can request from the broker
-* (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
-* `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
-* `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
-* payload, and no decoded-frame consumer requests it over the shm plane.
-*/
-var FrameHandleFormatSchema = z.enum([
-	"rgb",
-	"bgr",
-	"yuv420",
-	"gray"
-]);
-z.object({
-	brokerId: z.string(),
-	format: FrameHandleFormatSchema,
-	/**
-	* Optional reader-side cadence hint in frames per second. The broker does
-	* NOT throttle — latest-wins ring reads drop frames implicitly for a slow
-	* consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
-	* the consumer can pace its own `pullFrameHandles` polling.
-	*/
-	maxFps: z.number().positive().optional(),
-	/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
-	tag: z.string().optional()
-});
-z.object({
-	/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
-	subscriptionId: z.string(),
-	/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
-	maxFps: z.number().nonnegative()
-});
-/**
 * Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
 * `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
 * sample bytes plus the track parameters a consumer needs to interpret them.
@@ -306,8 +253,8 @@ z.object({
 * Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
 * Float32 PCM), so unlike video frames they ship their bytes INLINE over
 * tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
-* (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
-* / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
+* (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
+* it.
 */
 var AudioChunkFormatSchema = z.enum(AUDIO_CHUNK_FORMATS);
 z.object({
@@ -353,9 +300,7 @@ var BrokerStatusSchema = z.enum([
 z.object({
 	status: BrokerStatusSchema,
 	inputFps: z.number(),
-	decodeFps: z.number(),
 	encodedSubscribers: z.number(),
-	decodedSubscribers: z.number(),
 	uptimeMs: z.number(),
 	bitrateKbps: z.number(),
 	idrIntervalMs: z.number(),
@@ -368,14 +313,6 @@ z.object({
 	preBufferMs: z.number(),
 	preBufferPackets: z.number(),
 	/**
-	* Moleculer node id of the decoder provider currently servicing this
-	* stream's decoded subscribers. `null` until the deferred decoder is
-	* created (no decoded clients yet, or codec not detected). Surfaces the
-	* runtime decoder placement so the UI can show "Decoder: <agent>" without
-	* a separate cap call per broker.
-	*/
-	decoderNodeId: z.string().nullable(),
-	/**
 	* Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
 	* when the stream has no audio track or the broker is in cold start.
 	* `supported = false` means the codec was detected but the local
@@ -7151,19 +7088,7 @@ function createSystemProxy(api) {
 			validateComposition: (input) => dispatch("coreBlocks", "validateComposition", "mutation", input)
 		},
 		decoder: {
-			supportsCodec: (input) => dispatch("decoder", "supportsCodec", "query", input),
 			getInfo: (input) => dispatch("decoder", "getInfo", "query", input),
-			createSession: (input) => dispatch("decoder", "createSession", "query", input),
-			destroySession: (input) => dispatch("decoder", "destroySession", "query", input),
-			pushPacket: (input) => dispatch("decoder", "pushPacket", "query", input),
-			openStream: (input) => dispatch("decoder", "openStream", "query", input),
-			pullFrames: (input) => dispatch("decoder", "pullFrames", "query", input),
-			pullHandles: (input) => dispatch("decoder", "pullHandles", "query", input),
-			getFrame: (input) => dispatch("decoder", "getFrame", "query", input),
-			getShmStats: (input) => dispatch("decoder", "getShmStats", "query", input),
-			updateConfig: (input) => dispatch("decoder", "updateConfig", "query", input),
-			getStats: (input) => dispatch("decoder", "getStats", "query", input),
-			listActiveSessions: (input) => dispatch("decoder", "listActiveSessions", "query", input),
 			reprobeHwaccel: (input) => dispatch("decoder", "reprobeHwaccel", "mutation", input)
 		},
 		deviceAdoption: {
@@ -7640,9 +7565,6 @@ function createSystemProxy(api) {
 			subscribeAudioChunks: (input) => dispatch("streamBroker", "subscribeAudioChunks", "mutation", input),
 			pullAudioChunks: (input) => dispatch("streamBroker", "pullAudioChunks", "query", input),
 			unsubscribeAudioChunks: (input) => dispatch("streamBroker", "unsubscribeAudioChunks", "mutation", input),
-			subscribeFrames: (input) => dispatch("streamBroker", "subscribeFrames", "mutation", input),
-			pullFrameHandles: (input) => dispatch("streamBroker", "pullFrameHandles", "query", input),
-			unsubscribeFrames: (input) => dispatch("streamBroker", "unsubscribeFrames", "mutation", input),
 			setPreBufferDuration: (input) => dispatch("streamBroker", "setPreBufferDuration", "mutation", input),
 			getPreBufferInfo: (input) => dispatch("streamBroker", "getPreBufferInfo", "query", input),
 			getRtspPort: (input) => dispatch("streamBroker", "getRtspPort", "query", input),

package/dist/enums/event-category.d.ts

@@ -498,15 +498,6 @@ export declare enum EventCategory {
     AgentWsDisconnected = "agent.ws.disconnected",
     AgentBackupActivated = "agent.backup.activated",
     OrchestrationSettingsUpdated = "orchestration.settings-updated",
-    /**
-     * Per-agent hwaccel preference changed (user override set, cleared, or
-     * re-probed). Observability event — decoders pull the current pref at
-     * `createSession`, so running sessions keep their current backend until
-     * they rotate naturally (camera add/remove, stream restart). Future
-     * work can wire a listener in stream-broker that force-rotates live
-     * sessions; for now this event powers logs + admin-UI toast feedback.
-     */
-    PipelineAgentHwaccelChanged = "pipeline.agent-hwaccel-changed",
     MotionAnalysis = "detection.motion-analysis",
     /** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
     MotionZonesRaw = "detection.motion-zones-raw",

package/dist/enums.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_category = require("./event-category-DmS_tLsU.js");
+const require_event_category = require("./event-category-CtBAl88K.js");
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";

package/dist/enums.mjs

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-BGmz_oxW.mjs";
+import { t as EventCategory } from "./event-category-B_0XEcLF.mjs";
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";

package/dist/{event-category-BGmz_oxW.mjs → event-category-B_0XEcLF.mjs}

@@ -499,15 +499,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
 	EventCategory["AgentBackupActivated"] = "agent.backup.activated";
 	EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
-	/**
-	* Per-agent hwaccel preference changed (user override set, cleared, or
-	* re-probed). Observability event — decoders pull the current pref at
-	* `createSession`, so running sessions keep their current backend until
-	* they rotate naturally (camera add/remove, stream restart). Future
-	* work can wire a listener in stream-broker that force-rotates live
-	* sessions; for now this event powers logs + admin-UI toast feedback.
-	*/
-	EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
 	EventCategory["MotionAnalysis"] = "detection.motion-analysis";
 	/** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
 	EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";

package/dist/{event-category-DmS_tLsU.js → event-category-CtBAl88K.js}

@@ -499,15 +499,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
 	EventCategory["AgentBackupActivated"] = "agent.backup.activated";
 	EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
-	/**
-	* Per-agent hwaccel preference changed (user override set, cleared, or
-	* re-probed). Observability event — decoders pull the current pref at
-	* `createSession`, so running sessions keep their current backend until
-	* they rotate naturally (camera add/remove, stream restart). Future
-	* work can wire a listener in stream-broker that force-rotates live
-	* sessions; for now this event powers logs + admin-UI toast feedback.
-	*/
-	EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
 	EventCategory["MotionAnalysis"] = "detection.motion-analysis";
 	/** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
 	EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";

package/dist/ffmpeg/hwaccel.d.ts

@@ -9,7 +9,7 @@
  *
  * - the raw kernel resolver (`ctx.kernel.hwaccel.resolve()`) returns
  *   `['qsv','vaapi']` for an Intel host — qsv FIRST;
- * - `addon-decoder-ffmpeg`'s `DECODE_HWACCEL_RANK` puts **vaapi above qsv on
+ * - the decoder addon's `DECODE_HWACCEL_RANK` (`addon-decoder-nodeav`) puts **vaapi above qsv on
  *   purpose**, because on this exact hub a qsv decode child exits `code=171`
  *   producing no frames, while vaapi decodes 8 MP h264 at ~50 fps.
  *