@camstack/addon-export-hap 1.2.151 → 1.2.153

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
  });
@@ -29781,6 +29562,59 @@ var AddonAutoUpdateSchema = ChannelWithInheritSchema;
29781
29562
  var RestartAddonResultSchema = unknown();
29782
29563
  var InstallPackageResultSchema = unknown();
29783
29564
  var ReloadPackagesResultSchema = unknown();
29565
+ /**
29566
+ * What an uninstall did on ONE node.
29567
+ * - `uninstalled` — removed: runner(s) stopped, caps gone, code deleted.
29568
+ * - `not-installed` — the node did not have it (nothing to do).
29569
+ * - `refused` — protected / bootstrap package; nothing touched.
29570
+ * - `failed` — attempted and did not complete; `error` says why.
29571
+ * - `pending-reconnect` — the node is OFFLINE: its record was pruned so the
29572
+ * back-fill never returns the package, and the stale-addon sweep removes the
29573
+ * copy when the node registers again (only once the hub no longer has it).
29574
+ */
29575
+ var UninstallNodeOutcomeSchema = _enum([
29576
+ "uninstalled",
29577
+ "not-installed",
29578
+ "refused",
29579
+ "failed",
29580
+ "pending-reconnect"
29581
+ ]);
29582
+ var UninstallNodeResultSchema = object({
29583
+ nodeId: string(),
29584
+ outcome: UninstallNodeOutcomeSchema,
29585
+ error: string().optional(),
29586
+ addonIds: array(string()).readonly(),
29587
+ runnersStopped: array(string()).readonly(),
29588
+ warnings: array(string()).readonly()
29589
+ });
29590
+ var UninstallPackageResultSchema = object({
29591
+ /** Every targeted node ended `uninstalled`, `not-installed` or `pending-reconnect`. */
29592
+ success: boolean(),
29593
+ packageName: string(),
29594
+ results: array(UninstallNodeResultSchema).readonly()
29595
+ });
29596
+ /**
29597
+ * `unreachable` lists online agents whose status read FAILED — absence from
29598
+ * `installations` is only "not installed" for a node that answered (D315).
29599
+ */
29600
+ var PackageInstallationsSchema = object({
29601
+ installations: array(object({
29602
+ packageName: string(),
29603
+ nodeId: string(),
29604
+ nodeName: string(),
29605
+ isHub: boolean(),
29606
+ isOnline: boolean(),
29607
+ version: string().nullable(),
29608
+ addonIds: array(string()).readonly(),
29609
+ source: _enum(["live", "recorded"]),
29610
+ /** The hub installs this package too. `false` on an agent row = an orphan. */
29611
+ onHub: boolean()
29612
+ })).readonly(),
29613
+ unreachable: array(object({
29614
+ nodeId: string(),
29615
+ error: string()
29616
+ })).readonly()
29617
+ });
29784
29618
  var BulkUpdateItemStatusSchema = _enum([
29785
29619
  "queued",
29786
29620
  "updating",
@@ -29863,10 +29697,14 @@ method(_void(), array(AddonListItemSchema).readonly()), method(object({
29863
29697
  }), method(object({ packageName: string() }), InstallPackageResultSchema, {
29864
29698
  kind: "mutation",
29865
29699
  auth: "admin"
29866
- }), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({ packageName: string() }), unknown(), {
29700
+ }), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({
29701
+ packageName: string().min(1),
29702
+ nodeId: string().optional(),
29703
+ everywhere: boolean().optional()
29704
+ }), UninstallPackageResultSchema, {
29867
29705
  kind: "mutation",
29868
29706
  auth: "admin"
29869
- }), method(_void(), ReloadPackagesResultSchema, {
29707
+ }), method(object({ packageName: string().optional() }), PackageInstallationsSchema, { auth: "admin" }), method(_void(), ReloadPackagesResultSchema, {
29870
29708
  kind: "mutation",
29871
29709
  auth: "admin"
29872
29710
  }), method(object({ query: string().optional() }), array(SearchResultSchema)), method(object({ nodeId: string().optional() }), array(PackageUpdateSchema).readonly(), { auth: "admin" }), method(object({
@@ -38216,6 +38054,12 @@ Object.freeze({
38216
38054
  addonId: null,
38217
38055
  access: "view"
38218
38056
  },
38057
+ "addons.listInstallations": {
38058
+ capName: "addons",
38059
+ capScope: "system",
38060
+ addonId: null,
38061
+ access: "view"
38062
+ },
38219
38063
  "addons.listJobs": {
38220
38064
  capName: "addons",
38221
38065
  capScope: "system",
@@ -39398,90 +39242,18 @@ Object.freeze({
39398
39242
  addonId: null,
39399
39243
  access: "create"
39400
39244
  },
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
39245
  "decoder.getInfo": {
39420
39246
  capName: "decoder",
39421
39247
  capScope: "system",
39422
39248
  addonId: null,
39423
39249
  access: "view"
39424
39250
  },
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
39251
  "decoder.reprobeHwaccel": {
39468
39252
  capName: "decoder",
39469
39253
  capScope: "system",
39470
39254
  addonId: null,
39471
39255
  access: "create"
39472
39256
  },
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
39257
  "detectionPipeline.applyDeviceSettingsPatch": {
39486
39258
  capName: "detection-pipeline",
39487
39259
  capScope: "device",
@@ -42572,12 +42344,6 @@ Object.freeze({
42572
42344
  addonId: null,
42573
42345
  access: "delete"
42574
42346
  },
42575
- "pipelineExecutor.deleteTemplate": {
42576
- capName: "pipeline-executor",
42577
- capScope: "system",
42578
- addonId: null,
42579
- access: "delete"
42580
- },
42581
42347
  "pipelineExecutor.downloadModel": {
42582
42348
  capName: "pipeline-executor",
42583
42349
  capScope: "system",
@@ -42716,12 +42482,6 @@ Object.freeze({
42716
42482
  addonId: null,
42717
42483
  access: "view"
42718
42484
  },
42719
- "pipelineExecutor.listTemplates": {
42720
- capName: "pipeline-executor",
42721
- capScope: "system",
42722
- addonId: null,
42723
- access: "view"
42724
- },
42725
42485
  "pipelineExecutor.rearmInferenceDevice": {
42726
42486
  capName: "pipeline-executor",
42727
42487
  capScope: "system",
@@ -42746,12 +42506,6 @@ Object.freeze({
42746
42506
  addonId: null,
42747
42507
  access: "create"
42748
42508
  },
42749
- "pipelineExecutor.saveTemplate": {
42750
- capName: "pipeline-executor",
42751
- capScope: "system",
42752
- addonId: null,
42753
- access: "create"
42754
- },
42755
42509
  "pipelineExecutor.setVideoPipelineSteps": {
42756
42510
  capName: "pipeline-executor",
42757
42511
  capScope: "system",
@@ -42770,12 +42524,6 @@ Object.freeze({
42770
42524
  addonId: null,
42771
42525
  access: "create"
42772
42526
  },
42773
- "pipelineExecutor.updateTemplate": {
42774
- capName: "pipeline-executor",
42775
- capScope: "system",
42776
- addonId: null,
42777
- access: "create"
42778
- },
42779
42527
  "pipelineExecutor.validatePipeline": {
42780
42528
  capName: "pipeline-executor",
42781
42529
  capScope: "system",
@@ -42806,12 +42554,6 @@ Object.freeze({
42806
42554
  addonId: null,
42807
42555
  access: "create"
42808
42556
  },
42809
- "pipelineOrchestrator.deleteTemplate": {
42810
- capName: "pipeline-orchestrator",
42811
- capScope: "system",
42812
- addonId: null,
42813
- access: "delete"
42814
- },
42815
42557
  "pipelineOrchestrator.getAgentLoad": {
42816
42558
  capName: "pipeline-orchestrator",
42817
42559
  capScope: "system",
@@ -42962,12 +42704,6 @@ Object.freeze({
42962
42704
  addonId: null,
42963
42705
  access: "view"
42964
42706
  },
42965
- "pipelineOrchestrator.listTemplates": {
42966
- capName: "pipeline-orchestrator",
42967
- capScope: "system",
42968
- addonId: null,
42969
- access: "view"
42970
- },
42971
42707
  "pipelineOrchestrator.pauseForStorageMigration": {
42972
42708
  capName: "pipeline-orchestrator",
42973
42709
  capScope: "system",
@@ -43022,12 +42758,6 @@ Object.freeze({
43022
42758
  addonId: null,
43023
42759
  access: "create"
43024
42760
  },
43025
- "pipelineOrchestrator.saveTemplate": {
43026
- capName: "pipeline-orchestrator",
43027
- capScope: "system",
43028
- addonId: null,
43029
- access: "create"
43030
- },
43031
42761
  "pipelineOrchestrator.setAgentCapabilities": {
43032
42762
  capName: "pipeline-orchestrator",
43033
42763
  capScope: "system",
@@ -43076,6 +42806,12 @@ Object.freeze({
43076
42806
  addonId: null,
43077
42807
  access: "create"
43078
42808
  },
42809
+ "pipelineOrchestrator.setCameraStepSettings": {
42810
+ capName: "pipeline-orchestrator",
42811
+ capScope: "system",
42812
+ addonId: null,
42813
+ access: "create"
42814
+ },
43079
42815
  "pipelineOrchestrator.setCameraStepToggle": {
43080
42816
  capName: "pipeline-orchestrator",
43081
42817
  capScope: "system",
@@ -43130,12 +42866,6 @@ Object.freeze({
43130
42866
  addonId: null,
43131
42867
  access: "create"
43132
42868
  },
43133
- "pipelineOrchestrator.updateTemplate": {
43134
- capName: "pipeline-orchestrator",
43135
- capScope: "system",
43136
- addonId: null,
43137
- access: "create"
43138
- },
43139
42869
  "pipelineRunner.attachCamera": {
43140
42870
  capName: "pipeline-runner",
43141
42871
  capScope: "system",
@@ -44570,12 +44300,6 @@ Object.freeze({
44570
44300
  addonId: null,
44571
44301
  access: "view"
44572
44302
  },
44573
- "streamBroker.pullFrameHandles": {
44574
- capName: "stream-broker",
44575
- capScope: "system",
44576
- addonId: null,
44577
- access: "view"
44578
- },
44579
44303
  "streamBroker.regenerateRtspToken": {
44580
44304
  capName: "stream-broker",
44581
44305
  capScope: "system",
@@ -44642,12 +44366,6 @@ Object.freeze({
44642
44366
  addonId: null,
44643
44367
  access: "create"
44644
44368
  },
44645
- "streamBroker.subscribeFrames": {
44646
- capName: "stream-broker",
44647
- capScope: "system",
44648
- addonId: null,
44649
- access: "create"
44650
- },
44651
44369
  "streamBroker.unassignProfile": {
44652
44370
  capName: "stream-broker",
44653
44371
  capScope: "system",
@@ -44660,12 +44378,6 @@ Object.freeze({
44660
44378
  addonId: null,
44661
44379
  access: "create"
44662
44380
  },
44663
- "streamBroker.unsubscribeFrames": {
44664
- capName: "stream-broker",
44665
- capScope: "system",
44666
- addonId: null,
44667
- access: "create"
44668
- },
44669
44381
  "streamCatalog.getCatalog": {
44670
44382
  capName: "stream-catalog",
44671
44383
  capScope: "device",
@@ -47179,11 +46891,6 @@ Object.freeze({
47179
46891
  form: "single",
47180
46892
  optional: false
47181
46893
  }],
47182
- "decoder.createSession": [{
47183
- name: "deviceId",
47184
- form: "single",
47185
- optional: true
47186
- }],
47187
46894
  "detectionPipeline.applyDeviceSettingsPatch": [{
47188
46895
  name: "deviceId",
47189
46896
  form: "single",
@@ -48524,6 +48231,11 @@ Object.freeze({
48524
48231
  form: "single",
48525
48232
  optional: false
48526
48233
  }],
48234
+ "pipelineOrchestrator.setCameraStepSettings": [{
48235
+ name: "deviceId",
48236
+ form: "single",
48237
+ optional: false
48238
+ }],
48527
48239
  "pipelineOrchestrator.setCameraStepToggle": [{
48528
48240
  name: "deviceId",
48529
48241
  form: "single",