@camstack/addon-export-hap 1.2.151 → 1.2.152

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -48,7 +48,7 @@ node_fs_promises = __toESM(node_fs_promises, 1);
48
48
  let node_events = require("node:events");
49
49
  let node_dgram = require("node:dgram");
50
50
  let node_os = require("node:os");
51
- //#region ../types/dist/event-category-BGmz_oxW.mjs
51
+ //#region ../types/dist/event-category-B_0XEcLF.mjs
52
52
  var EventCategory = /* @__PURE__ */ function(EventCategory) {
53
53
  EventCategory["SystemBoot"] = "system.boot";
54
54
  EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -549,15 +549,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
549
549
  EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
550
550
  EventCategory["AgentBackupActivated"] = "agent.backup.activated";
551
551
  EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
552
- /**
553
- * Per-agent hwaccel preference changed (user override set, cleared, or
554
- * re-probed). Observability event — decoders pull the current pref at
555
- * `createSession`, so running sessions keep their current backend until
556
- * they rotate naturally (camera add/remove, stream restart). Future
557
- * work can wire a listener in stream-broker that force-rotates live
558
- * sessions; for now this event powers logs + admin-UI toast feedback.
559
- */
560
- EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
561
552
  EventCategory["MotionAnalysis"] = "detection.motion-analysis";
562
553
  /** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
563
554
  EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
@@ -5428,7 +5419,7 @@ var ZodIssueCode = {
5428
5419
  var ZodFirstPartyTypeKind;
5429
5420
  ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
5430
5421
  //#endregion
5431
- //#region ../types/dist/sleep-C16NCZR2.mjs
5422
+ //#region ../types/dist/sleep-BNeXenvr.mjs
5432
5423
  /**
5433
5424
  * The audio chunk plane's byte format, and the ONE expansion from a coded
5434
5425
  * window to float samples (D455).
@@ -6794,32 +6785,12 @@ object({
6794
6785
  audioCodec: string().optional(),
6795
6786
  metadata: record(string(), unknown()).readonly().optional()
6796
6787
  });
6797
- var EncodedPacketSchema = object({
6798
- type: _enum(["video", "audio"]),
6799
- data: _instanceof(Uint8Array),
6800
- pts: number(),
6801
- dts: number(),
6802
- keyframe: boolean(),
6803
- codec: string()
6804
- });
6805
- var DecodedFrameSchema = object({
6806
- data: _instanceof(Uint8Array),
6807
- width: number(),
6808
- height: number(),
6809
- format: _enum([
6810
- "jpeg",
6811
- "rgb",
6812
- "bgr",
6813
- "yuv420",
6814
- "gray"
6815
- ]),
6816
- timestamp: number()
6817
- });
6818
6788
  /**
6819
6789
  * Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
6820
6790
  * frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
6821
- * interface in `interfaces/frame-handle.ts` field-for-field so a decoder cap
6822
- * method (`pullHandles`) can carry handles over tRPC / Moleculer.
6791
+ * interface in `interfaces/frame-handle.ts` field-for-field so a cap method
6792
+ * (the runner's native-crop and pipeline-executor inputs) can carry handles
6793
+ * over tRPC / Moleculer.
6823
6794
  *
6824
6795
  * The `satisfies` assertion below pins this schema to the interface: if a
6825
6796
  * field is added to / removed from `FrameHandle` without a matching schema
@@ -6845,50 +6816,6 @@ var FrameHandleSchema = object({
6845
6816
  slotCount: number().int().positive()
6846
6817
  });
6847
6818
  /**
6848
- * Pixel format a frame-handle subscriber can request from the broker
6849
- * (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
6850
- * `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
6851
- * `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
6852
- * payload, and no decoded-frame consumer requests it over the shm plane.
6853
- */
6854
- var FrameHandleFormatSchema = _enum([
6855
- "rgb",
6856
- "bgr",
6857
- "yuv420",
6858
- "gray"
6859
- ]);
6860
- /**
6861
- * Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
6862
- * broker for a `FrameHandle` stream of one `format`; the broker maintains one
6863
- * shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
6864
- * subscriber (motion) and an `rgb` subscriber (detection) each read the format
6865
- * they asked for with no broker-side conversion.
6866
- */
6867
- var SubscribeFramesInputSchema = object({
6868
- brokerId: string(),
6869
- format: FrameHandleFormatSchema,
6870
- /**
6871
- * Optional reader-side cadence hint in frames per second. The broker does
6872
- * NOT throttle — latest-wins ring reads drop frames implicitly for a slow
6873
- * consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
6874
- * the consumer can pace its own `pullFrameHandles` polling.
6875
- */
6876
- maxFps: number().positive().optional(),
6877
- /** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
6878
- tag: string().optional()
6879
- });
6880
- /**
6881
- * Result of `stream-broker.subscribeFrames`. The consumer then polls
6882
- * `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
6883
- * `FrameHandle` to a `FrameRingReader`.
6884
- */
6885
- var SubscribeFramesResultSchema = object({
6886
- /** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
6887
- subscriptionId: string(),
6888
- /** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
6889
- maxFps: number().nonnegative()
6890
- });
6891
- /**
6892
6819
  * Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
6893
6820
  * `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
6894
6821
  * sample bytes plus the track parameters a consumer needs to interpret them.
@@ -6896,8 +6823,8 @@ var SubscribeFramesResultSchema = object({
6896
6823
  * Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
6897
6824
  * Float32 PCM), so unlike video frames they ship their bytes INLINE over
6898
6825
  * tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
6899
- * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
6900
- * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
6826
+ * (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
6827
+ * it.
6901
6828
  */
6902
6829
  var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
6903
6830
  var DecodedAudioChunkSchema = object({
@@ -6915,11 +6842,10 @@ var DecodedAudioChunkSchema = object({
6915
6842
  format: AudioChunkFormatSchema.optional()
6916
6843
  });
6917
6844
  /**
6918
- * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
6919
- * handle-free, ship-bytes-inline analogue of `subscribeFrames`: a consumer
6920
- * asks the broker for the decoded audio-chunk stream of one broker; the
6921
- * broker keeps a per-subscription bounded FIFO queue the consumer drains via
6922
- * `pullAudioChunks`.
6845
+ * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
6846
+ * its bytes inline: a consumer asks the broker for the decoded audio-chunk
6847
+ * stream of one broker; the broker keeps a per-subscription bounded FIFO queue
6848
+ * the consumer drains via `pullAudioChunks`.
6923
6849
  */
6924
6850
  var SubscribeAudioChunksInputSchema = object({
6925
6851
  brokerId: string(),
@@ -6950,9 +6876,7 @@ var BrokerStatsSchema = object({
6950
6876
  "stopped"
6951
6877
  ]),
6952
6878
  inputFps: number(),
6953
- decodeFps: number(),
6954
6879
  encodedSubscribers: number(),
6955
- decodedSubscribers: number(),
6956
6880
  uptimeMs: number(),
6957
6881
  bitrateKbps: number(),
6958
6882
  idrIntervalMs: number(),
@@ -6965,14 +6889,6 @@ var BrokerStatsSchema = object({
6965
6889
  preBufferMs: number(),
6966
6890
  preBufferPackets: number(),
6967
6891
  /**
6968
- * Moleculer node id of the decoder provider currently servicing this
6969
- * stream's decoded subscribers. `null` until the deferred decoder is
6970
- * created (no decoded clients yet, or codec not detected). Surfaces the
6971
- * runtime decoder placement so the UI can show "Decoder: <agent>" without
6972
- * a separate cap call per broker.
6973
- */
6974
- decoderNodeId: string().nullable(),
6975
- /**
6976
6892
  * Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
6977
6893
  * when the stream has no audio track or the broker is in cold start.
6978
6894
  * `supported = false` means the codec was detected but the local
@@ -11094,70 +11010,6 @@ var StorageLocationDeclarationSchema = object({
11094
11010
  "backup"
11095
11011
  ]).optional()
11096
11012
  });
11097
- var DecoderStatsSchema = object({
11098
- inputFps: number(),
11099
- outputFps: number(),
11100
- avgDecodeTimeMs: number(),
11101
- droppedFrames: number(),
11102
- /**
11103
- * Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
11104
- * lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
11105
- * the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
11106
- * is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
11107
- */
11108
- lagMs: number().optional(),
11109
- effectiveFps: number().optional(),
11110
- adaptiveFps: number().optional()
11111
- });
11112
- var DecoderSessionConfigSchema = object({
11113
- codec: string(),
11114
- maxFps: number().default(0),
11115
- outputFormat: _enum([
11116
- "jpeg",
11117
- "rgb",
11118
- "bgr",
11119
- "yuv420",
11120
- "gray"
11121
- ]).default("jpeg"),
11122
- scale: number().default(1),
11123
- width: number().optional(),
11124
- height: number().optional(),
11125
- /**
11126
- * Identifier of the camera this decoder session serves. Optional
11127
- * because the cap is generic (any caller could request decode), but
11128
- * stream-broker passes it so decoder logs include `deviceId` for
11129
- * per-camera filtering when diagnosing failures (e.g. node-av
11130
- * sendPacket errors on a single hung camera).
11131
- */
11132
- deviceId: number().int().nonnegative().optional(),
11133
- /**
11134
- * Free-form tag for log scoping. Stream-broker uses
11135
- * `broker:<deviceId>/<profile>`. Decoder session logger surfaces it
11136
- * on every line so `grep tag=broker:5/high` filters one camera
11137
- * profile cleanly.
11138
- */
11139
- tag: string().optional(),
11140
- /**
11141
- * Where the session delivers decoded frames (Phase 5 / D9):
11142
- *
11143
- * - `'callback'` (default) — the legacy pixel path: decoded frames are
11144
- * buffered as `DecodedFrame`s and drained via `pullFrames`.
11145
- * - `'shm'` — the shared-memory frame plane: decoded frames are written
11146
- * into an OS shared-memory ring and drained as zero-pixel
11147
- * `FrameHandle`s via `pullHandles`. A session is one mode or the
11148
- * other — `pullFrames` returns nothing for an `'shm'` session and
11149
- * `pullHandles` returns nothing for a `'callback'` session.
11150
- */
11151
- frameSink: _enum(["callback", "shm"]).default("callback"),
11152
- /**
11153
- * Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
11154
- * a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
11155
- * real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
11156
- * stream-broker's `streamingDebug` gate — off by default so production logs
11157
- * stay quiet and the emit path pays zero per-frame cost when disabled.
11158
- */
11159
- debug: boolean().optional()
11160
- });
11161
11013
  /**
11162
11014
  * Per-component log CHANNELS — the gate a hot path consults, and the registry
11163
11015
  * an addon declares its channels in.
@@ -13392,13 +13244,6 @@ var BrokerRtspClientSchema = object({
13392
13244
  lastRtpAt: number(),
13393
13245
  bytesSent: number()
13394
13246
  });
13395
- var BrokerDecodedClientSchema = object({
13396
- tag: string(),
13397
- subscribedAt: number(),
13398
- maxFps: number(),
13399
- framesDelivered: number(),
13400
- framesDropped: number()
13401
- });
13402
13247
  var BrokerAudioClientSchema = object({
13403
13248
  tag: string(),
13404
13249
  subscribedAt: number(),
@@ -13490,7 +13335,6 @@ var BrokerEncodedClientSchema = object({
13490
13335
  });
13491
13336
  var BrokerClientsSchema = object({
13492
13337
  rtsp: array(BrokerRtspClientSchema).readonly(),
13493
- decoded: array(BrokerDecodedClientSchema).readonly(),
13494
13338
  audio: array(BrokerAudioClientSchema).readonly(),
13495
13339
  encoded: array(BrokerEncodedClientSchema).readonly(),
13496
13340
  pipeClients: number(),
@@ -13859,11 +13703,7 @@ method(object({
13859
13703
  auth: "admin"
13860
13704
  }), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
13861
13705
  brokerId: string(),
13862
- channel: _enum([
13863
- "rtsp",
13864
- "decoded",
13865
- "audio"
13866
- ]),
13706
+ channel: _enum(["rtsp", "audio"]),
13867
13707
  handle: string()
13868
13708
  }), object({ killed: boolean() }), {
13869
13709
  kind: "mutation",
@@ -13898,10 +13738,7 @@ method(object({
13898
13738
  }), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
13899
13739
  subscriptionId: string(),
13900
13740
  maxCount: number().int().positive().default(8)
13901
- }), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(SubscribeFramesInputSchema, SubscribeFramesResultSchema, { kind: "mutation" }), method(object({
13902
- subscriptionId: string(),
13903
- maxCount: number().int().positive().default(4)
13904
- }), array(FrameHandleSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
13741
+ }), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
13905
13742
  brokerId: string(),
13906
13743
  seconds: number().min(0).max(30)
13907
13744
  }), _void(), {
@@ -15114,54 +14951,12 @@ var HWACCEL_OPTIONS = [
15114
14951
  label: "DRM (Linux generic)"
15115
14952
  }
15116
14953
  ];
15117
- /**
15118
- * shm ring usage stats for a `frameSink: 'shm'` decoder session —
15119
- * exposed via `decoder.getShmStats` so downstream consumers can
15120
- * observe ring pressure (slot count, byte budget, hit/miss ratio).
15121
- */
15122
- var ShmRingStatsSchema = object({
15123
- sessionId: string(),
15124
- slotCount: number().int(),
15125
- slotByteLength: number().int(),
15126
- segmentBytes: number().int(),
15127
- budgetMb: number().int(),
15128
- framesWritten: number().int(),
15129
- getFrameHits: number().int(),
15130
- getFrameMisses: number().int()
15131
- });
15132
- method(object({ codec: string() }), boolean()), method(_void(), object({
14954
+ method(_void(), object({
15133
14955
  id: string(),
15134
14956
  name: string(),
15135
- isPullMode: boolean().optional(),
15136
- priority: number().optional(),
15137
14957
  hwaccel: string().optional(),
15138
14958
  probedBestHwaccel: string().optional()
15139
- })), method(DecoderSessionConfigSchema, object({
15140
- sessionId: string(),
15141
- nodeId: string()
15142
- })), method(object({ sessionId: string() }), _void()), method(object({
15143
- sessionId: string(),
15144
- packet: EncodedPacketSchema
15145
- }), _void()), method(object({
15146
- sessionId: string(),
15147
- url: string()
15148
- }), _void()), method(object({
15149
- sessionId: string(),
15150
- maxCount: number().default(1),
15151
- waitMs: number().optional()
15152
- }), array(DecodedFrameSchema)), method(object({
15153
- sessionId: string(),
15154
- maxCount: number().default(1),
15155
- waitMs: number().optional()
15156
- }), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
15157
- sessionId: string(),
15158
- config: DecoderSessionConfigSchema.partial()
15159
- }), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
15160
- sessionId: string(),
15161
- codec: string(),
15162
- outputFormat: string(),
15163
- createdAtMs: number()
15164
- })).readonly()), method(_void(), object({ backend: string() }), {
14959
+ })), method(_void(), object({ backend: string() }), {
15165
14960
  kind: "mutation",
15166
14961
  auth: "admin"
15167
14962
  });
@@ -22206,8 +22001,8 @@ Object.freeze(Object.fromEntries([{
22206
22001
  var CLUSTER_STEP_SETTING_FIELDS = [{
22207
22002
  stepId: "face-embedding",
22208
22003
  key: "minLandmarkFaceSize",
22209
- label: "Min face size for recognition (detection px)",
22210
- description: "Refuse to embed a face smaller than this IN THE DETECTION FRAME. Applies to every node — the enrolled gallery is one index, and two admission floors would fill it from two policies. 0 disables the gate.",
22004
+ label: "Min face size to embed (detection-frame px)",
22005
+ description: "Faces smaller than this in the small frame the detector sees are not embedded, so they can never be recognised. Below it the face cannot be aligned reliably and a bad embedding matches everyone. Same value on every node. 0 = no limit.",
22211
22006
  type: "slider",
22212
22007
  min: 0,
22213
22008
  max: 64,
@@ -24259,21 +24054,6 @@ var PipelineDefaultStepSchema = lazy(() => object({
24259
24054
  group: string().optional(),
24260
24055
  settings: record(string(), unknown()).optional()
24261
24056
  }));
24262
- var PipelineTemplateStepSchema = lazy(() => object({
24263
- addonId: string(),
24264
- enabled: boolean(),
24265
- modelId: string(),
24266
- children: array(PipelineTemplateStepSchema).readonly(),
24267
- settings: record(string(), unknown()).optional()
24268
- }));
24269
- var PipelineTemplateSchema$1 = object({
24270
- id: string(),
24271
- name: string(),
24272
- createdAt: string(),
24273
- updatedAt: string(),
24274
- engine: PipelineEngineChoiceSchema,
24275
- steps: array(PipelineTemplateStepSchema).readonly()
24276
- });
24277
24057
  var PipelineModelOptionSchema = object({
24278
24058
  id: string(),
24279
24059
  name: string(),
@@ -24485,15 +24265,7 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24485
24265
  }), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
24486
24266
  steps: array(PipelineStepInputSchema),
24487
24267
  deviceKey: string().optional()
24488
- }), PipelineValidationResultSchema), method(_void(), array(PipelineTemplateSchema$1).readonly()), method(object({
24489
- name: string(),
24490
- steps: array(PipelineTemplateStepSchema).readonly(),
24491
- engine: PipelineEngineChoiceSchema
24492
- }), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
24493
- id: string(),
24494
- name: string().optional(),
24495
- steps: array(PipelineTemplateStepSchema).readonly().optional()
24496
- }), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
24268
+ }), PipelineValidationResultSchema), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
24497
24269
  addonId: string(),
24498
24270
  modelId: string(),
24499
24271
  format: ModelFormatSchema$2
@@ -24658,148 +24430,17 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24658
24430
  settings: record(string(), unknown()).optional()
24659
24431
  }), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
24660
24432
  /**
24661
- * Wire shapes of the Load balancing surface (D748): the session placement
24662
- * policy, the atomic share write, the observed placement statistics, the
24663
- * hardware share suggestion and the stale device pins.
24664
- */
24665
- /**
24666
- * How a new detection session picks its node and device.
24667
- * - `least-loaded` — the historical rule: lowest `attached / weight`, a
24668
- * constant node order at a tie (D37). An idle node always ties at 0, so a
24669
- * weight only bites once a node already holds a session.
24670
- * - `share` — the share of PARALLEL sessions is held to the weights, and a
24671
- * full or drowning node yields to a free one (D748).
24672
- */
24673
- var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
24674
- var LoadBalancingSharesInputSchema = object({
24675
- /** nodeId → share (> 0). A node left out keeps its weight. */
24676
- nodes: record(string(), number().positive()).default({}),
24677
- /** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
24678
- devices: record(string(), record(string(), number().positive())).default({})
24679
- });
24680
- var PlacementStatsInputSchema = object({
24681
- /** Window the observed shares are averaged over (default 1 h, max 24 h). */
24682
- windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
24683
- var PlacementDeviceStatsSchema = object({
24684
- deviceKey: string(),
24685
- /** Sessions running on this device now. */
24686
- sessionsNow: number(),
24687
- /** Sessions started on this device inside the window. */
24688
- sessionsStarted: number(),
24689
- /** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
24690
- observedShare: number().nullable()
24691
- });
24692
- var PlacementNodeStatsSchema = object({
24693
- nodeId: string(),
24694
- sessionsNow: number(),
24695
- sessionsStarted: number(),
24696
- /** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
24697
- observedShare: number().nullable(),
24698
- /** Most sessions this node ran at once inside the window. */
24699
- peakSessions: number(),
24700
- /** Sessions a share election handed elsewhere because this node was full or drowning. */
24701
- yieldsAway: number(),
24702
- devices: array(PlacementDeviceStatsSchema).readonly()
24703
- });
24704
- /** A camera's device pin that the session path cannot honour. */
24705
- var StaleDevicePinSchema = object({
24706
- deviceId: number(),
24707
- deviceKey: string(),
24708
- /** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
24709
- reason: _enum(["disabled", "absent"])
24710
- });
24711
- var PlacementStatsSchema = object({
24712
- policy: SessionPlacementPolicySchema,
24713
- windowMs: number(),
24714
- /** How much of the window was actually observed (the hub keeps it in memory). */
24715
- observedForMs: number(),
24716
- sessionsNow: number(),
24717
- /** Most parallel sessions across the cluster inside the window. */
24718
- clusterPeakSessions: number(),
24719
- nodes: array(PlacementNodeStatsSchema).readonly(),
24720
- stalePins: array(StaleDevicePinSchema).readonly()
24721
- });
24722
- var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
24723
- var SuggestedDeviceShareSchema = object({
24724
- deviceKey: string(),
24725
- /** Share of the node (0–100, rounded). */
24726
- share: number(),
24727
- modelId: string().nullable(),
24728
- /** Inferences per second at that model, from the measured table. */
24729
- fps: number().nullable(),
24730
- measured: boolean(),
24731
- /** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
24732
- suggestedMaxSessions: number().nullable()
24733
- });
24734
- var SuggestedNodeShareSchema = object({
24735
- nodeId: string(),
24736
- /** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
24737
- share: number().nullable(),
24738
- /** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
24739
- capacitySessions: number(),
24740
- devices: array(SuggestedDeviceShareSchema).readonly(),
24741
- skippedReason: string().nullable()
24742
- });
24743
- var SuggestSharesResultSchema = object({
24744
- headroom: number(),
24745
- /** Camera detection rate the capacity is counted in (the fastest camera's fps). */
24746
- cameraFps: number(),
24747
- /** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
24748
- iterations: number(),
24749
- nodes: array(SuggestedNodeShareSchema).readonly()
24750
- });
24751
- /**
24752
- * Where the node and device shares come from (D750).
24753
- * - `auto` — computed by the system from the cluster's measured capacity at
24754
- * the Auto tune models, and recomputed whenever a node or device joins,
24755
- * leaves, is switched on or off, or changes model.
24756
- * - `manual` — the operator's stored sliders. A node or device that cannot
24757
- * take sessions gives its share to the others in proportion; the stored
24758
- * values are never rewritten for that.
24759
- */
24760
- var ShareSourceSchema = _enum(["auto", "manual"]);
24761
- var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
24762
- object({
24763
- nodes: record(string(), number()),
24764
- devices: record(string(), record(string(), number()))
24765
- });
24766
- var EffectiveDeviceShareSchema = object({
24767
- deviceKey: string(),
24768
- /** Can take sessions now (enabled, available, can run the root). */
24769
- eligible: boolean(),
24770
- /** The share the source assigns, as a percentage of the node's devices. */
24771
- configuredPct: number(),
24772
- /** The share actually used, after an ineligible device's share went to the others. */
24773
- effectivePct: number()
24774
- });
24775
- var EffectiveNodeShareSchema = object({
24776
- nodeId: string(),
24777
- eligible: boolean(),
24778
- configuredPct: number(),
24779
- effectivePct: number(),
24780
- devices: array(EffectiveDeviceShareSchema).readonly()
24781
- });
24782
- var EffectiveSharesSchema = object({
24783
- source: ShareSourceSchema,
24784
- policy: SessionPlacementPolicySchema,
24785
- /** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
24786
- autoPending: boolean(),
24787
- /** When the automatic shares were last computed (ms epoch); null = never. */
24788
- computedAt: number().nullable(),
24789
- /** What made the system recompute them last. */
24790
- trigger: string().nullable(),
24791
- nodes: array(EffectiveNodeShareSchema).readonly(),
24792
- /** The relative weights the election reads (before eligibility). */
24793
- nodeWeights: record(string(), number()),
24794
- deviceWeights: record(string(), record(string(), number()))
24795
- });
24796
- /**
24797
24433
  * The wire shapes of the Auto tune plan and apply (D745), used by the
24798
24434
  * `pipeline-orchestrator` cap. The recommender's own types
24799
- * (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
24435
+ * (`recommend.ts`) are the TS face of the same data; these
24800
24436
  * schemas are what crosses the cap boundary.
24801
24437
  */
24802
24438
  var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
24439
+ /** The operator's range for it. */
24440
+ var MIN_SESSIONS_PER_DEVICE_RANGE = {
24441
+ min: 1,
24442
+ max: 8
24443
+ };
24803
24444
  var HardwareClassIdSchema = _enum([
24804
24445
  "intel-core-ultra",
24805
24446
  "intel-n-series",
@@ -24817,8 +24458,9 @@ var AcceleratorKindSchema = _enum([
24817
24458
  ]);
24818
24459
  var RecommendationReasonSchema = discriminatedUnion("kind", [
24819
24460
  object({
24820
- kind: literal("fits"),
24821
- utilisation: number()
24461
+ kind: literal("capacity"),
24462
+ sessions: number(),
24463
+ minSessions: number()
24822
24464
  }),
24823
24465
  object({
24824
24466
  kind: literal("tie-faster"),
@@ -24833,16 +24475,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
24833
24475
  }),
24834
24476
  object({
24835
24477
  kind: literal("no-fit-lightest"),
24836
- utilisation: number()
24478
+ sessions: number(),
24479
+ minSessions: number()
24837
24480
  }),
24838
24481
  object({
24839
24482
  kind: literal("derived-latency"),
24840
24483
  modelId: string()
24841
24484
  }),
24842
- object({
24843
- kind: literal("estimated-load"),
24844
- observedForMs: number().nullable()
24845
- }),
24846
24485
  object({ kind: literal("cpu-device") }),
24847
24486
  object({ kind: literal("coral-untouched") }),
24848
24487
  object({ kind: literal("device-disabled") }),
@@ -24858,28 +24497,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
24858
24497
  format: ModelFormatSchema$1
24859
24498
  })
24860
24499
  ]);
24861
- var DeviceDemandSchema = object({
24862
- nodeId: string(),
24863
- deviceKey: string(),
24864
- demandFps: number(),
24865
- maxCameraFps: number(),
24866
- alwaysOnCameras: number(),
24867
- onMotionSessions: number(),
24868
- onMotionSource: _enum([
24869
- "observed-24h",
24870
- "estimate",
24871
- "none"
24872
- ]),
24873
- observedForMs: number().nullable(),
24874
- /** How on-motion sessions were charged: per-device observation, or split by share (D748). */
24875
- placement: SessionPlacementPolicySchema
24876
- });
24877
24500
  var DeviceModelChoiceSchema = object({
24878
24501
  modelId: string(),
24879
24502
  p50Ms: number(),
24880
24503
  fps: number(),
24881
24504
  measured: boolean(),
24882
- utilisation: number(),
24505
+ /** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
24506
+ capacitySessions: number(),
24883
24507
  personRecall: number()
24884
24508
  });
24885
24509
  var DeviceRecommendationSchema = object({
@@ -24887,7 +24511,6 @@ var DeviceRecommendationSchema = object({
24887
24511
  accelerator: AcceleratorKindSchema.nullable(),
24888
24512
  enabled: boolean(),
24889
24513
  available: boolean(),
24890
- demand: DeviceDemandSchema.nullable(),
24891
24514
  chosen: DeviceModelChoiceSchema.nullable(),
24892
24515
  reasons: array(RecommendationReasonSchema).readonly()
24893
24516
  });
@@ -24948,20 +24571,20 @@ var AutoTuneOptionsSchema = object({
24948
24571
  /** Share of each accelerator's throughput kept free (0.3–0.5). */
24949
24572
  headroom: number().min(.3).max(.5).default(.4),
24950
24573
  /**
24951
- * What-if shares (D748): plan as if these node/device shares were stored
24952
- * and the policy were `share`. Absent = the stored shares under the stored
24953
- * policy. A what-if plan is for display; apply always re-plans from what
24954
- * is stored.
24574
+ * The least number of parallel sessions every device must sustain at the
24575
+ * camera rate with the headroom kept free (D755). The most accurate model
24576
+ * that reaches it wins.
24955
24577
  */
24956
- shares: LoadBalancingSharesInputSchema.optional()
24578
+ minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
24957
24579
  });
24958
24580
  var AutoTunePlanSchema = object({
24959
24581
  /** Hash of everything the apply will write — the apply refuses a different one. */
24960
24582
  planHash: string(),
24961
24583
  family: literal("yolov9"),
24962
24584
  headroom: number(),
24963
- /** Planned under what-if shares (D748): for display — apply refuses it as stale. */
24964
- whatIf: boolean(),
24585
+ minSessionsPerDevice: number(),
24586
+ /** The detection rate a session is counted at (the fastest camera running the pipeline root). */
24587
+ cameraFps: number(),
24965
24588
  generatedAt: number(),
24966
24589
  nodes: array(NodeRecommendationSchema).readonly(),
24967
24590
  nodeChanges: array(NodeDeviceChangeSchema).readonly(),
@@ -24971,7 +24594,8 @@ var AutoTunePlanSchema = object({
24971
24594
  });
24972
24595
  var AutoTuneApplyInputSchema = object({
24973
24596
  planHash: string(),
24974
- headroom: number().min(.3).max(.5).default(.4)
24597
+ headroom: number().min(.3).max(.5).default(.4),
24598
+ minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
24975
24599
  });
24976
24600
  var AutoTunePhaseResultSchema = object({
24977
24601
  phase: _enum([
@@ -25003,6 +24627,177 @@ var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
25003
24627
  reason: _enum(["apply-in-progress"])
25004
24628
  })
25005
24629
  ]);
24630
+ /**
24631
+ * Wire shapes of the Load balancing surface (D748): the session placement
24632
+ * policy, the atomic share write, the observed placement statistics, the
24633
+ * hardware share suggestion and the stale device pins.
24634
+ */
24635
+ /**
24636
+ * How a new detection session picks its node and device.
24637
+ * - `least-loaded` — the historical rule: lowest `attached / weight`, a
24638
+ * constant node order at a tie (D37). An idle node always ties at 0, so a
24639
+ * weight only bites once a node already holds a session.
24640
+ * - `share` — the share of PARALLEL sessions is held to the weights, and a
24641
+ * full or drowning node yields to a free one (D748).
24642
+ */
24643
+ var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
24644
+ var LoadBalancingSharesInputSchema = object({
24645
+ /** nodeId → share (> 0). A node left out keeps its weight. */
24646
+ nodes: record(string(), number().positive()).default({}),
24647
+ /** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
24648
+ devices: record(string(), record(string(), number().positive())).default({})
24649
+ });
24650
+ var PlacementStatsInputSchema = object({
24651
+ /** Window the observed shares are averaged over (default 1 h, max 24 h). */
24652
+ windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
24653
+ var PlacementDeviceStatsSchema = object({
24654
+ deviceKey: string(),
24655
+ /** Sessions running on this device now. */
24656
+ sessionsNow: number(),
24657
+ /** Sessions started on this device inside the window. */
24658
+ sessionsStarted: number(),
24659
+ /** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
24660
+ observedShare: number().nullable()
24661
+ });
24662
+ var PlacementNodeStatsSchema = object({
24663
+ nodeId: string(),
24664
+ sessionsNow: number(),
24665
+ sessionsStarted: number(),
24666
+ /** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
24667
+ observedShare: number().nullable(),
24668
+ /** Most sessions this node ran at once inside the window. */
24669
+ peakSessions: number(),
24670
+ /** Sessions a share election handed elsewhere because this node was full or drowning. */
24671
+ yieldsAway: number(),
24672
+ devices: array(PlacementDeviceStatsSchema).readonly()
24673
+ });
24674
+ /** A camera's device pin that the session path cannot honour. */
24675
+ var StaleDevicePinSchema = object({
24676
+ deviceId: number(),
24677
+ deviceKey: string(),
24678
+ /** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
24679
+ reason: _enum(["disabled", "absent"])
24680
+ });
24681
+ var PlacementStatsSchema = object({
24682
+ policy: SessionPlacementPolicySchema,
24683
+ windowMs: number(),
24684
+ /** How much of the window was actually observed (the hub keeps it in memory). */
24685
+ observedForMs: number(),
24686
+ sessionsNow: number(),
24687
+ /** Most parallel sessions across the cluster inside the window. */
24688
+ clusterPeakSessions: number(),
24689
+ nodes: array(PlacementNodeStatsSchema).readonly(),
24690
+ stalePins: array(StaleDevicePinSchema).readonly()
24691
+ });
24692
+ /**
24693
+ * Where an automatic share's capacity comes from (D755).
24694
+ * - `hardware` — the static capacity of each device at its Auto tune model:
24695
+ * the measured latency table for the node's hardware class.
24696
+ * - `benchmark` — the node's own measured capacity (node benchmark results).
24697
+ * A node with no results falls back to `hardware`, and says so.
24698
+ */
24699
+ var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
24700
+ /** Why a node under the `benchmark` source was sized from hardware instead. */
24701
+ var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
24702
+ var SuggestSharesInputSchema = object({
24703
+ headroom: number().min(.3).max(.5).default(.4),
24704
+ /** Default `hardware`. */
24705
+ source: CapacitySourceSchema.default("hardware")
24706
+ });
24707
+ var SuggestedDeviceShareSchema = object({
24708
+ deviceKey: string(),
24709
+ /** Share of the node (0–100, rounded). */
24710
+ share: number(),
24711
+ modelId: string().nullable(),
24712
+ /** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
24713
+ fps: number().nullable(),
24714
+ /** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
24715
+ measured: boolean(),
24716
+ /**
24717
+ * Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
24718
+ * or the benchmark's measured max sessions. Never enforced.
24719
+ */
24720
+ suggestedMaxSessions: number().nullable()
24721
+ });
24722
+ var SuggestedNodeShareSchema = object({
24723
+ nodeId: string(),
24724
+ /** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
24725
+ share: number().nullable(),
24726
+ /** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
24727
+ capacitySessions: number(),
24728
+ devices: array(SuggestedDeviceShareSchema).readonly(),
24729
+ skippedReason: string().nullable(),
24730
+ /** What this node's capacity was read from; null when the node is skipped. */
24731
+ capacitySource: CapacitySourceSchema.nullable(),
24732
+ /** Set when the `benchmark` source was asked for and this node used `hardware`. */
24733
+ capacityFallback: CapacityFallbackSchema.nullable()
24734
+ });
24735
+ var SuggestSharesResultSchema = object({
24736
+ headroom: number(),
24737
+ /** The source asked for; each node says what it actually used. */
24738
+ source: CapacitySourceSchema,
24739
+ /** Camera detection rate the capacity is counted in (the fastest camera's fps). */
24740
+ cameraFps: number(),
24741
+ /** The Auto tune capacity floor the models were picked at. */
24742
+ minSessionsPerDevice: number(),
24743
+ nodes: array(SuggestedNodeShareSchema).readonly()
24744
+ });
24745
+ /**
24746
+ * Where the node and device shares come from (D750, D755).
24747
+ * - `hardware` (default) — computed by the system from each node's static
24748
+ * capacity (its accelerators at their Auto tune models, from the measured
24749
+ * latency table), recomputed whenever a node or device joins, leaves, is
24750
+ * switched on or off, or changes model. No load input.
24751
+ * - `benchmark` — the same, from each node's measured capacity (node
24752
+ * benchmark results); a node without results falls back to `hardware`.
24753
+ * - `manual` — the operator's stored sliders.
24754
+ * Either way a node or device that cannot take sessions gives its share to
24755
+ * the others in proportion; the stored values are never rewritten for that.
24756
+ */
24757
+ var ShareSourceSchema = _enum([
24758
+ "hardware",
24759
+ "benchmark",
24760
+ "manual"
24761
+ ]);
24762
+ var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
24763
+ object({
24764
+ nodes: record(string(), number()),
24765
+ devices: record(string(), record(string(), number()))
24766
+ });
24767
+ var EffectiveDeviceShareSchema = object({
24768
+ deviceKey: string(),
24769
+ /** Can take sessions now (enabled, available, can run the root). */
24770
+ eligible: boolean(),
24771
+ /** The share the source assigns, as a percentage of the node's devices. */
24772
+ configuredPct: number(),
24773
+ /** The share actually used, after an ineligible device's share went to the others. */
24774
+ effectivePct: number()
24775
+ });
24776
+ var EffectiveNodeShareSchema = object({
24777
+ nodeId: string(),
24778
+ eligible: boolean(),
24779
+ configuredPct: number(),
24780
+ effectivePct: number(),
24781
+ /** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
24782
+ capacitySource: CapacitySourceSchema.nullable(),
24783
+ /** Automatic `benchmark`: why this node used `hardware` instead. */
24784
+ capacityFallback: CapacityFallbackSchema.nullable(),
24785
+ devices: array(EffectiveDeviceShareSchema).readonly()
24786
+ });
24787
+ var EffectiveSharesSchema = object({
24788
+ source: ShareSourceSchema,
24789
+ policy: SessionPlacementPolicySchema,
24790
+ /** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
24791
+ autoPending: boolean(),
24792
+ /** When the automatic shares were last computed (ms epoch); null = never. */
24793
+ computedAt: number().nullable(),
24794
+ /** What made the system recompute them last. */
24795
+ trigger: string().nullable(),
24796
+ nodes: array(EffectiveNodeShareSchema).readonly(),
24797
+ /** The relative weights the election reads (before eligibility). */
24798
+ nodeWeights: record(string(), number()),
24799
+ deviceWeights: record(string(), record(string(), number()))
24800
+ });
25006
24801
  object({
25007
24802
  activeCameras: number(),
25008
24803
  throttledCameras: number(),
@@ -25880,14 +25675,15 @@ var RunnerLocalLoadSchema = object({
25880
25675
  * Per-inference-device live load (multi-device C4). One entry per deviceKey
25881
25676
  * this runner currently has attached cameras on, so the orchestrator's second
25882
25677
  * `balance()` pass (over a node's devices) weights on real per-pool session
25883
- * counts. Empty on single-device / pre-multi-device runners. `queueDepthTotal`
25884
- * per device is 0 until the pool backlog gets a public accessor (follow-up).
25678
+ * counts. Empty on single-device / pre-multi-device runners. There is no
25679
+ * per-device queue depth: the inference pool's backlog has no accessor, and
25680
+ * a field that always read 0 was removed rather than shown as a measurement
25681
+ * (D762).
25885
25682
  */
25886
25683
  devices: array(object({
25887
25684
  deviceKey: string(),
25888
25685
  backend: string(),
25889
- attachedCameras: number(),
25890
- queueDepthTotal: number()
25686
+ attachedCameras: number()
25891
25687
  })).default([]),
25892
25688
  /** Hardware capability flags reported by this node. */
25893
25689
  hardware: object({
@@ -26101,14 +25897,6 @@ var CameraPipelineConfigSchema = object({
26101
25897
  settings: record(string(), unknown()).readonly().optional()
26102
25898
  }).nullable().optional()
26103
25899
  });
26104
- var PipelineTemplateSchema = object({
26105
- id: string(),
26106
- name: string(),
26107
- description: string().optional(),
26108
- config: CameraPipelineConfigSchema,
26109
- createdAt: string(),
26110
- updatedAt: string()
26111
- });
26112
25900
  var DeviceStepConfigSchema = object({
26113
25901
  modelId: string().optional(),
26114
25902
  settings: record(string(), unknown()).optional(),
@@ -26182,8 +25970,10 @@ var CameraStepOverridePatchSchema = object({
26182
25970
  modelId: string().optional(),
26183
25971
  settings: record(string(), unknown()).readonly().optional()
26184
25972
  });
25973
+ var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
26185
25974
  var CameraPipelineSettingsSchema = object({
26186
25975
  stepToggles: record(string(), boolean()).optional(),
25976
+ stepSettings: CameraStepSettingsSchema.optional(),
26187
25977
  stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
26188
25978
  pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
26189
25979
  });
@@ -26216,7 +26006,10 @@ var PipelineAssignmentSchema = object({
26216
26006
  });
26217
26007
  /**
26218
26008
  * Per-agent load summary surfaced to the load balancer + dashboards.
26219
- * Aggregated from each runner's `getLocalLoad` cap call.
26009
+ * Aggregated from each runner's `getLocalLoad` cap call. In the
26010
+ * `getAgentLoad` report, a single-device node's default-pool sessions (no
26011
+ * `deviceKey`) are credited to its one eligible device in `load.devices` —
26012
+ * the default pool IS that device (D745); the balancer's census stays raw.
26220
26013
  */
26221
26014
  var AgentLoadSummarySchema = object({
26222
26015
  nodeId: string(),
@@ -26305,26 +26098,27 @@ var CameraBrokerStatusSchema = object({
26305
26098
  width: number(),
26306
26099
  height: number(),
26307
26100
  subscribers: number(),
26308
- inFps: number(),
26309
- outFps: number()
26101
+ /**
26102
+ * Encoded packets/s the broker receives from the camera. null when the
26103
+ * broker's stats read failed — unknown, never 0 (a 0 here reads as a stall).
26104
+ * There is no output rate: decoding runs in the session decode workers, not
26105
+ * in the broker, so the broker's own decoded-frame rate is 0 on every live
26106
+ * camera and is not served (D758).
26107
+ */
26108
+ inFps: number().nullable()
26310
26109
  })).readonly(),
26311
26110
  webrtcSessions: number(),
26312
26111
  rtspRestream: boolean()
26313
26112
  });
26314
- /** Shared-memory ring statistics within the decoder block. */
26315
- var CameraDecoderShmSchema = object({
26316
- framesWritten: number(),
26317
- getFrameHits: number(),
26318
- getFrameMisses: number(),
26319
- budgetMb: number()
26320
- });
26321
- /** Decoder block — null when the decoder stage is unreachable or inactive. */
26322
- var CameraDecoderStatusSchema = object({
26323
- nodeId: string(),
26324
- formats: array(string()).readonly(),
26325
- sessionCount: number(),
26326
- shm: CameraDecoderShmSchema
26327
- });
26113
+ /**
26114
+ * Decoder block — WHERE decode runs (co-located with the detection node by
26115
+ * construction); null when the camera has no detection node. It carries no
26116
+ * frame counter: the shared-memory plane whose counters it used to serve is
26117
+ * gone, and those fields read 0 forever. Whether frames actually flow is read
26118
+ * from `detection.actualFps` (frames delivered to and processed by the
26119
+ * detector), never from a counter nothing feeds.
26120
+ */
26121
+ var CameraDecoderStatusSchema = object({ nodeId: string() });
26328
26122
  /** Motion block — null when motion detection is not active for this device. */
26329
26123
  var CameraMotionStatusSchema = object({
26330
26124
  enabled: boolean(),
@@ -26747,6 +26541,13 @@ method(object({
26747
26541
  }), object({ success: literal(true) }), {
26748
26542
  kind: "mutation",
26749
26543
  auth: "admin"
26544
+ }), method(object({
26545
+ deviceId: number(),
26546
+ addonId: string(),
26547
+ settings: record(string(), unknown()).nullable()
26548
+ }), object({ success: literal(true) }), {
26549
+ kind: "mutation",
26550
+ auth: "admin"
26750
26551
  }), method(object({
26751
26552
  deviceId: number(),
26752
26553
  agentNodeId: string(),
@@ -26770,25 +26571,7 @@ method(object({
26770
26571
  }), method(_void(), DiskReconcileJobSchema, {
26771
26572
  kind: "mutation",
26772
26573
  auth: "admin"
26773
- }), method(_void(), DiskReconcileJobSchema, { auth: "admin" }), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
26774
- name: string(),
26775
- description: string().optional(),
26776
- config: CameraPipelineConfigSchema
26777
- }), PipelineTemplateSchema, {
26778
- kind: "mutation",
26779
- auth: "admin"
26780
- }), method(object({
26781
- id: string(),
26782
- name: string().optional(),
26783
- description: string().optional(),
26784
- config: CameraPipelineConfigSchema.optional()
26785
- }), PipelineTemplateSchema, {
26786
- kind: "mutation",
26787
- auth: "admin"
26788
- }), method(object({ id: string() }), object({ success: literal(true) }), {
26789
- kind: "mutation",
26790
- auth: "admin"
26791
- });
26574
+ }), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
26792
26575
  /**
26793
26576
  * Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
26794
26577
  * `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
@@ -29201,8 +28984,6 @@ var WebrtcStreamChoiceSchema = object({
29201
28984
  ]).nullable(),
29202
28985
  /** Input FPS from the camera (null for adaptive). */
29203
28986
  inputFps: number().nullable(),
29204
- /** Decoded FPS (null for adaptive). */
29205
- decodeFps: number().nullable(),
29206
28987
  /** Bitrate in kbps (null for adaptive). */
29207
28988
  bitrateKbps: number().nullable()
29208
28989
  });
@@ -39398,90 +39179,18 @@ Object.freeze({
39398
39179
  addonId: null,
39399
39180
  access: "create"
39400
39181
  },
39401
- "decoder.createSession": {
39402
- capName: "decoder",
39403
- capScope: "system",
39404
- addonId: null,
39405
- access: "view"
39406
- },
39407
- "decoder.destroySession": {
39408
- capName: "decoder",
39409
- capScope: "system",
39410
- addonId: null,
39411
- access: "delete"
39412
- },
39413
- "decoder.getFrame": {
39414
- capName: "decoder",
39415
- capScope: "system",
39416
- addonId: null,
39417
- access: "view"
39418
- },
39419
39182
  "decoder.getInfo": {
39420
39183
  capName: "decoder",
39421
39184
  capScope: "system",
39422
39185
  addonId: null,
39423
39186
  access: "view"
39424
39187
  },
39425
- "decoder.getShmStats": {
39426
- capName: "decoder",
39427
- capScope: "system",
39428
- addonId: null,
39429
- access: "view"
39430
- },
39431
- "decoder.getStats": {
39432
- capName: "decoder",
39433
- capScope: "system",
39434
- addonId: null,
39435
- access: "view"
39436
- },
39437
- "decoder.listActiveSessions": {
39438
- capName: "decoder",
39439
- capScope: "system",
39440
- addonId: null,
39441
- access: "view"
39442
- },
39443
- "decoder.openStream": {
39444
- capName: "decoder",
39445
- capScope: "system",
39446
- addonId: null,
39447
- access: "view"
39448
- },
39449
- "decoder.pullFrames": {
39450
- capName: "decoder",
39451
- capScope: "system",
39452
- addonId: null,
39453
- access: "view"
39454
- },
39455
- "decoder.pullHandles": {
39456
- capName: "decoder",
39457
- capScope: "system",
39458
- addonId: null,
39459
- access: "view"
39460
- },
39461
- "decoder.pushPacket": {
39462
- capName: "decoder",
39463
- capScope: "system",
39464
- addonId: null,
39465
- access: "view"
39466
- },
39467
39188
  "decoder.reprobeHwaccel": {
39468
39189
  capName: "decoder",
39469
39190
  capScope: "system",
39470
39191
  addonId: null,
39471
39192
  access: "create"
39472
39193
  },
39473
- "decoder.supportsCodec": {
39474
- capName: "decoder",
39475
- capScope: "system",
39476
- addonId: null,
39477
- access: "view"
39478
- },
39479
- "decoder.updateConfig": {
39480
- capName: "decoder",
39481
- capScope: "system",
39482
- addonId: null,
39483
- access: "view"
39484
- },
39485
39194
  "detectionPipeline.applyDeviceSettingsPatch": {
39486
39195
  capName: "detection-pipeline",
39487
39196
  capScope: "device",
@@ -42572,12 +42281,6 @@ Object.freeze({
42572
42281
  addonId: null,
42573
42282
  access: "delete"
42574
42283
  },
42575
- "pipelineExecutor.deleteTemplate": {
42576
- capName: "pipeline-executor",
42577
- capScope: "system",
42578
- addonId: null,
42579
- access: "delete"
42580
- },
42581
42284
  "pipelineExecutor.downloadModel": {
42582
42285
  capName: "pipeline-executor",
42583
42286
  capScope: "system",
@@ -42716,12 +42419,6 @@ Object.freeze({
42716
42419
  addonId: null,
42717
42420
  access: "view"
42718
42421
  },
42719
- "pipelineExecutor.listTemplates": {
42720
- capName: "pipeline-executor",
42721
- capScope: "system",
42722
- addonId: null,
42723
- access: "view"
42724
- },
42725
42422
  "pipelineExecutor.rearmInferenceDevice": {
42726
42423
  capName: "pipeline-executor",
42727
42424
  capScope: "system",
@@ -42746,12 +42443,6 @@ Object.freeze({
42746
42443
  addonId: null,
42747
42444
  access: "create"
42748
42445
  },
42749
- "pipelineExecutor.saveTemplate": {
42750
- capName: "pipeline-executor",
42751
- capScope: "system",
42752
- addonId: null,
42753
- access: "create"
42754
- },
42755
42446
  "pipelineExecutor.setVideoPipelineSteps": {
42756
42447
  capName: "pipeline-executor",
42757
42448
  capScope: "system",
@@ -42770,12 +42461,6 @@ Object.freeze({
42770
42461
  addonId: null,
42771
42462
  access: "create"
42772
42463
  },
42773
- "pipelineExecutor.updateTemplate": {
42774
- capName: "pipeline-executor",
42775
- capScope: "system",
42776
- addonId: null,
42777
- access: "create"
42778
- },
42779
42464
  "pipelineExecutor.validatePipeline": {
42780
42465
  capName: "pipeline-executor",
42781
42466
  capScope: "system",
@@ -42806,12 +42491,6 @@ Object.freeze({
42806
42491
  addonId: null,
42807
42492
  access: "create"
42808
42493
  },
42809
- "pipelineOrchestrator.deleteTemplate": {
42810
- capName: "pipeline-orchestrator",
42811
- capScope: "system",
42812
- addonId: null,
42813
- access: "delete"
42814
- },
42815
42494
  "pipelineOrchestrator.getAgentLoad": {
42816
42495
  capName: "pipeline-orchestrator",
42817
42496
  capScope: "system",
@@ -42962,12 +42641,6 @@ Object.freeze({
42962
42641
  addonId: null,
42963
42642
  access: "view"
42964
42643
  },
42965
- "pipelineOrchestrator.listTemplates": {
42966
- capName: "pipeline-orchestrator",
42967
- capScope: "system",
42968
- addonId: null,
42969
- access: "view"
42970
- },
42971
42644
  "pipelineOrchestrator.pauseForStorageMigration": {
42972
42645
  capName: "pipeline-orchestrator",
42973
42646
  capScope: "system",
@@ -43022,12 +42695,6 @@ Object.freeze({
43022
42695
  addonId: null,
43023
42696
  access: "create"
43024
42697
  },
43025
- "pipelineOrchestrator.saveTemplate": {
43026
- capName: "pipeline-orchestrator",
43027
- capScope: "system",
43028
- addonId: null,
43029
- access: "create"
43030
- },
43031
42698
  "pipelineOrchestrator.setAgentCapabilities": {
43032
42699
  capName: "pipeline-orchestrator",
43033
42700
  capScope: "system",
@@ -43076,6 +42743,12 @@ Object.freeze({
43076
42743
  addonId: null,
43077
42744
  access: "create"
43078
42745
  },
42746
+ "pipelineOrchestrator.setCameraStepSettings": {
42747
+ capName: "pipeline-orchestrator",
42748
+ capScope: "system",
42749
+ addonId: null,
42750
+ access: "create"
42751
+ },
43079
42752
  "pipelineOrchestrator.setCameraStepToggle": {
43080
42753
  capName: "pipeline-orchestrator",
43081
42754
  capScope: "system",
@@ -43130,12 +42803,6 @@ Object.freeze({
43130
42803
  addonId: null,
43131
42804
  access: "create"
43132
42805
  },
43133
- "pipelineOrchestrator.updateTemplate": {
43134
- capName: "pipeline-orchestrator",
43135
- capScope: "system",
43136
- addonId: null,
43137
- access: "create"
43138
- },
43139
42806
  "pipelineRunner.attachCamera": {
43140
42807
  capName: "pipeline-runner",
43141
42808
  capScope: "system",
@@ -44570,12 +44237,6 @@ Object.freeze({
44570
44237
  addonId: null,
44571
44238
  access: "view"
44572
44239
  },
44573
- "streamBroker.pullFrameHandles": {
44574
- capName: "stream-broker",
44575
- capScope: "system",
44576
- addonId: null,
44577
- access: "view"
44578
- },
44579
44240
  "streamBroker.regenerateRtspToken": {
44580
44241
  capName: "stream-broker",
44581
44242
  capScope: "system",
@@ -44642,12 +44303,6 @@ Object.freeze({
44642
44303
  addonId: null,
44643
44304
  access: "create"
44644
44305
  },
44645
- "streamBroker.subscribeFrames": {
44646
- capName: "stream-broker",
44647
- capScope: "system",
44648
- addonId: null,
44649
- access: "create"
44650
- },
44651
44306
  "streamBroker.unassignProfile": {
44652
44307
  capName: "stream-broker",
44653
44308
  capScope: "system",
@@ -44660,12 +44315,6 @@ Object.freeze({
44660
44315
  addonId: null,
44661
44316
  access: "create"
44662
44317
  },
44663
- "streamBroker.unsubscribeFrames": {
44664
- capName: "stream-broker",
44665
- capScope: "system",
44666
- addonId: null,
44667
- access: "create"
44668
- },
44669
44318
  "streamCatalog.getCatalog": {
44670
44319
  capName: "stream-catalog",
44671
44320
  capScope: "device",
@@ -47179,11 +46828,6 @@ Object.freeze({
47179
46828
  form: "single",
47180
46829
  optional: false
47181
46830
  }],
47182
- "decoder.createSession": [{
47183
- name: "deviceId",
47184
- form: "single",
47185
- optional: true
47186
- }],
47187
46831
  "detectionPipeline.applyDeviceSettingsPatch": [{
47188
46832
  name: "deviceId",
47189
46833
  form: "single",
@@ -48524,6 +48168,11 @@ Object.freeze({
48524
48168
  form: "single",
48525
48169
  optional: false
48526
48170
  }],
48171
+ "pipelineOrchestrator.setCameraStepSettings": [{
48172
+ name: "deviceId",
48173
+ form: "single",
48174
+ optional: false
48175
+ }],
48527
48176
  "pipelineOrchestrator.setCameraStepToggle": [{
48528
48177
  name: "deviceId",
48529
48178
  form: "single",