@camstack/addon-export-hap 1.2.150 → 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-DXKLNFvA.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.
@@ -11396,7 +11248,18 @@ var LABEL_SUPPLY_STEP_IDS = [
11396
11248
  ];
11397
11249
  /** Steps whose box a root detection can BE. */
11398
11250
  var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
11399
- [...LABEL_SUPPLY_STEP_IDS, ...CROP_SUPPLY_STEP_IDS];
11251
+ /**
11252
+ * Steps whose per-detection MASK a root detection can carry (D737). The live
11253
+ * mask step is `segmentation` — a frame-plane refiner that runs its own model
11254
+ * once per detection crop. (`instance-segmentation` is a dormant step id that
11255
+ * no camera tree carries.)
11256
+ */
11257
+ var MASK_SUPPLY_STEP_IDS = ["segmentation"];
11258
+ [
11259
+ ...LABEL_SUPPLY_STEP_IDS,
11260
+ ...CROP_SUPPLY_STEP_IDS,
11261
+ ...MASK_SUPPLY_STEP_IDS
11262
+ ];
11400
11263
  var MODEL_FORMATS = [
11401
11264
  "onnx",
11402
11265
  "coreml",
@@ -11425,7 +11288,53 @@ var ModelFormatEntrySchema = object({
11425
11288
  /** Multi-file payload (directory members or sibling files). */
11426
11289
  files: array(string()).readonly().optional(),
11427
11290
  /** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
11428
- runtimes: array(_enum(["python"])).readonly().optional()
11291
+ runtimes: array(_enum(["python"])).readonly().optional(),
11292
+ /**
11293
+ * Content revision of the artefact, for one hosted OFF the CamStack mirror.
11294
+ * A format on the mirror leaves it unset: its revision (the sha256 of its
11295
+ * weight file) comes from the downloader's generated table, kept in step
11296
+ * with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
11297
+ * node records the revision it downloaded next to the file
11298
+ * (`<file>.revision`); a copy with no record or a different one is stale
11299
+ * unless its weight file hashes to the revision, and a stale copy is
11300
+ * downloaded again, the old one serving until the new one is complete. No
11301
+ * revision at all ⇒ a file on disk is current, whatever it holds (D743).
11302
+ */
11303
+ revision: string().min(1).optional()
11304
+ });
11305
+ /**
11306
+ * What a node holds for one (model, format) (D746). `current` is a complete
11307
+ * copy at its catalog revision — exactly what `downloaded: true` means.
11308
+ * `stale` is bytes on disk that are not (yet) proven current under D743/D744:
11309
+ * no or a different revision record, or a missing sibling. `missing` is no
11310
+ * copy. `downloaded` alone folds `stale` into "not downloaded", which hid
11311
+ * reclaimable bytes and a copy about to be replaced.
11312
+ */
11313
+ var ModelOnDiskStateSchema = _enum([
11314
+ "current",
11315
+ "stale",
11316
+ "missing"
11317
+ ]);
11318
+ /**
11319
+ * The numeric precision of one format's BUILD (D746) — reported only when the
11320
+ * build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
11321
+ * CamStack Core ML export). Absent means "not stated", never "fp32".
11322
+ */
11323
+ var ModelFormatPrecisionSchema = _enum([
11324
+ "fp32",
11325
+ "fp16",
11326
+ "int8"
11327
+ ]);
11328
+ /**
11329
+ * One format of one model as a node's `pipelineExecutor.getSchema` reports it.
11330
+ * `onDisk` / `precision` are optional for version skew: a runner that predates
11331
+ * them omits them, and a reader falls back to `downloaded`.
11332
+ */
11333
+ var PipelineModelFormatStatusSchema = object({
11334
+ downloaded: boolean(),
11335
+ sizeMB: number(),
11336
+ onDisk: ModelOnDiskStateSchema.optional(),
11337
+ precision: ModelFormatPrecisionSchema.optional()
11429
11338
  });
11430
11339
  /**
11431
11340
  * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
@@ -11539,25 +11448,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
11539
11448
  * - `crop`: the root draws the box the step would have found (`license_plate`
11540
11449
  * for plate-detection, `face` for face-detection). The box becomes a detail
11541
11450
  * child of the `parentMacro` detection that contains it — never a track.
11451
+ * - `mask`: the root's decode emits an instance mask with every detection (a
11452
+ * YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
11453
+ * detection in the shape that step produces. Derived from the model's
11454
+ * postprocessor on read, never stored by an import.
11542
11455
  */
11543
- var RootStepSupplySchema = discriminatedUnion("kind", [object({
11544
- kind: literal("label"),
11545
- stepId: _enum(LABEL_SUPPLY_STEP_IDS),
11546
- labelToEffect: record(string(), string()),
11547
- uncovered: array(string()).readonly()
11548
- }), object({
11549
- kind: literal("crop"),
11550
- stepId: _enum(CROP_SUPPLY_STEP_IDS),
11551
- rootLabels: array(string()).readonly(),
11552
- parentMacro: _enum(["vehicle", "person"]),
11553
- childClass: _enum(["plate", "face"]),
11554
- /**
11555
- * The root's smaller input side, stamped on read by `rootSuppliesOf` from
11556
- * the model entry — what a step's `minRootInputPx` gate judges. Never
11557
- * stored by an import.
11558
- */
11559
- rootInputPx: number().int().positive().optional()
11560
- })]);
11456
+ var RootStepSupplySchema = discriminatedUnion("kind", [
11457
+ object({
11458
+ kind: literal("label"),
11459
+ stepId: _enum(LABEL_SUPPLY_STEP_IDS),
11460
+ labelToEffect: record(string(), string()),
11461
+ uncovered: array(string()).readonly()
11462
+ }),
11463
+ object({
11464
+ kind: literal("crop"),
11465
+ stepId: _enum(CROP_SUPPLY_STEP_IDS),
11466
+ rootLabels: array(string()).readonly(),
11467
+ parentMacro: _enum(["vehicle", "person"]),
11468
+ childClass: _enum(["plate", "face"]),
11469
+ /**
11470
+ * The root's smaller input side, stamped on read by `rootSuppliesOf` from
11471
+ * the model entry — what a step's `minRootInputPx` gate judges. Never
11472
+ * stored by an import.
11473
+ */
11474
+ rootInputPx: number().int().positive().optional()
11475
+ }),
11476
+ object({
11477
+ kind: literal("mask"),
11478
+ stepId: _enum(MASK_SUPPLY_STEP_IDS)
11479
+ })
11480
+ ]);
11561
11481
  var ModelCatalogEntrySchema = object({
11562
11482
  id: string(),
11563
11483
  name: string(),
@@ -11623,6 +11543,35 @@ var ModelCatalogEntrySchema = object({
11623
11543
  */
11624
11544
  defaultConfidence: number().min(0).max(1).optional(),
11625
11545
  /**
11546
+ * Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
11547
+ * on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
11548
+ * absent here runs at the step slider's global default. The same row shape
11549
+ * the floor measurement produces (`model-floors.json`: modelId → floors), so
11550
+ * a measured table is copied in as-is. An operator override is bound to the
11551
+ * model it was made for and does not survive a model change (D738). A custom
11552
+ * / imported model may declare it; without it, the global defaults apply.
11553
+ */
11554
+ defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
11555
+ /**
11556
+ * The inference precision this model's OpenVINO IR needs on an Intel GPU.
11557
+ * Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
11558
+ * that produces invalid output at f16 — measured 2026-10-07 for YOLO26
11559
+ * base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
11560
+ * scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
11561
+ * `PoolModelConfig.gpuInferencePrecision`; the pool sets
11562
+ * INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
11563
+ */
11564
+ gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
11565
+ /**
11566
+ * ROOT detectors only: per supplied step (`animal-classifier`, …), the
11567
+ * minimum DETECTION score from which this root's own fine label (species,
11568
+ * vehicle type — D736 root supply) is taken (D741). Below it the detection
11569
+ * keeps its macro class without the fine label. `1` = never take it from
11570
+ * this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
11571
+ * `minConfidence` slider, bound to the ROOT model, overrides it.
11572
+ */
11573
+ suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
11574
+ /**
11626
11575
  * When true, the executor produces a landmark-aligned crop (similarity warp
11627
11576
  * onto the canonical template) before this step runs, instead of a plain
11628
11577
  * axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
@@ -13295,13 +13244,6 @@ var BrokerRtspClientSchema = object({
13295
13244
  lastRtpAt: number(),
13296
13245
  bytesSent: number()
13297
13246
  });
13298
- var BrokerDecodedClientSchema = object({
13299
- tag: string(),
13300
- subscribedAt: number(),
13301
- maxFps: number(),
13302
- framesDelivered: number(),
13303
- framesDropped: number()
13304
- });
13305
13247
  var BrokerAudioClientSchema = object({
13306
13248
  tag: string(),
13307
13249
  subscribedAt: number(),
@@ -13393,7 +13335,6 @@ var BrokerEncodedClientSchema = object({
13393
13335
  });
13394
13336
  var BrokerClientsSchema = object({
13395
13337
  rtsp: array(BrokerRtspClientSchema).readonly(),
13396
- decoded: array(BrokerDecodedClientSchema).readonly(),
13397
13338
  audio: array(BrokerAudioClientSchema).readonly(),
13398
13339
  encoded: array(BrokerEncodedClientSchema).readonly(),
13399
13340
  pipeClients: number(),
@@ -13762,11 +13703,7 @@ method(object({
13762
13703
  auth: "admin"
13763
13704
  }), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
13764
13705
  brokerId: string(),
13765
- channel: _enum([
13766
- "rtsp",
13767
- "decoded",
13768
- "audio"
13769
- ]),
13706
+ channel: _enum(["rtsp", "audio"]),
13770
13707
  handle: string()
13771
13708
  }), object({ killed: boolean() }), {
13772
13709
  kind: "mutation",
@@ -13801,10 +13738,7 @@ method(object({
13801
13738
  }), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
13802
13739
  subscriptionId: string(),
13803
13740
  maxCount: number().int().positive().default(8)
13804
- }), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(SubscribeFramesInputSchema, SubscribeFramesResultSchema, { kind: "mutation" }), method(object({
13805
- subscriptionId: string(),
13806
- maxCount: number().int().positive().default(4)
13807
- }), 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({
13808
13742
  brokerId: string(),
13809
13743
  seconds: number().min(0).max(30)
13810
13744
  }), _void(), {
@@ -15017,54 +14951,12 @@ var HWACCEL_OPTIONS = [
15017
14951
  label: "DRM (Linux generic)"
15018
14952
  }
15019
14953
  ];
15020
- /**
15021
- * shm ring usage stats for a `frameSink: 'shm'` decoder session —
15022
- * exposed via `decoder.getShmStats` so downstream consumers can
15023
- * observe ring pressure (slot count, byte budget, hit/miss ratio).
15024
- */
15025
- var ShmRingStatsSchema = object({
15026
- sessionId: string(),
15027
- slotCount: number().int(),
15028
- slotByteLength: number().int(),
15029
- segmentBytes: number().int(),
15030
- budgetMb: number().int(),
15031
- framesWritten: number().int(),
15032
- getFrameHits: number().int(),
15033
- getFrameMisses: number().int()
15034
- });
15035
- method(object({ codec: string() }), boolean()), method(_void(), object({
14954
+ method(_void(), object({
15036
14955
  id: string(),
15037
14956
  name: string(),
15038
- isPullMode: boolean().optional(),
15039
- priority: number().optional(),
15040
14957
  hwaccel: string().optional(),
15041
14958
  probedBestHwaccel: string().optional()
15042
- })), method(DecoderSessionConfigSchema, object({
15043
- sessionId: string(),
15044
- nodeId: string()
15045
- })), method(object({ sessionId: string() }), _void()), method(object({
15046
- sessionId: string(),
15047
- packet: EncodedPacketSchema
15048
- }), _void()), method(object({
15049
- sessionId: string(),
15050
- url: string()
15051
- }), _void()), method(object({
15052
- sessionId: string(),
15053
- maxCount: number().default(1),
15054
- waitMs: number().optional()
15055
- }), array(DecodedFrameSchema)), method(object({
15056
- sessionId: string(),
15057
- maxCount: number().default(1),
15058
- waitMs: number().optional()
15059
- }), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
15060
- sessionId: string(),
15061
- config: DecoderSessionConfigSchema.partial()
15062
- }), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
15063
- sessionId: string(),
15064
- codec: string(),
15065
- outputFormat: string(),
15066
- createdAtMs: number()
15067
- })).readonly()), method(_void(), object({ backend: string() }), {
14959
+ })), method(_void(), object({ backend: string() }), {
15068
14960
  kind: "mutation",
15069
14961
  auth: "admin"
15070
14962
  });
@@ -16933,6 +16825,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
16933
16825
  kind: "mutation",
16934
16826
  auth: "admin"
16935
16827
  });
16828
+ var HUB_ADDRESS_ROLES = [
16829
+ "appConnections",
16830
+ "notificationTaps",
16831
+ "internal",
16832
+ "publicEndpoint"
16833
+ ];
16936
16834
  /**
16937
16835
  * Transport bounds for AI capability methods.
16938
16836
  *
@@ -21104,7 +21002,13 @@ var NcAlarmModeDelaysListSchema = array(object({
21104
21002
  * Absent = false (logged, not sent). Even when true it is not sent when that same sensor
21105
21003
  * is the one that starts the entry delay — the entry-delay notification already names it.
21106
21004
  */
21107
- notifySensorRewatched: boolean().optional()
21005
+ notifySensorRewatched: boolean().optional(),
21006
+ /**
21007
+ * D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
21008
+ * change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
21009
+ * re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
21010
+ */
21011
+ notifySensorIgnored: boolean().optional()
21108
21012
  })).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
21109
21013
  var NcAlarmModeDelaysEditListSchema = array(object({
21110
21014
  mode: AlarmArmModeSchema,
@@ -21117,7 +21021,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
21117
21021
  /** D706: set the switch, or `null` to clear it (back to the default, false). */
21118
21022
  notifyDuringEntryDelay: boolean().nullable().optional(),
21119
21023
  /** D706: set the switch, or `null` to clear it (back to the default, false). */
21120
- notifySensorRewatched: boolean().nullable().optional()
21024
+ notifySensorRewatched: boolean().nullable().optional(),
21025
+ /** D735: set the switch, or `null` to clear it (back to the default, false). */
21026
+ notifySensorIgnored: boolean().nullable().optional()
21121
21027
  })).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
21122
21028
  /** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
21123
21029
  var NcAlarmNonBlockingEditSchema = object({
@@ -22095,8 +22001,8 @@ Object.freeze(Object.fromEntries([{
22095
22001
  var CLUSTER_STEP_SETTING_FIELDS = [{
22096
22002
  stepId: "face-embedding",
22097
22003
  key: "minLandmarkFaceSize",
22098
- label: "Min face size for recognition (detection px)",
22099
- 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.",
22100
22006
  type: "slider",
22101
22007
  min: 0,
22102
22008
  max: 64,
@@ -24091,7 +23997,7 @@ var FrameRefSchema = object({
24091
23997
  timestamp: number(),
24092
23998
  capturedAt: number().optional()
24093
23999
  });
24094
- var ModelFormatSchema$1 = _enum([
24000
+ var ModelFormatSchema$2 = _enum([
24095
24001
  "onnx",
24096
24002
  "coreml",
24097
24003
  "openvino",
@@ -24109,7 +24015,7 @@ var PipelineSlotSchema = _enum([
24109
24015
  var PipelineEngineChoiceSchema = object({
24110
24016
  runtime: literal("python"),
24111
24017
  backend: string(),
24112
- format: ModelFormatSchema$1,
24018
+ format: ModelFormatSchema$2,
24113
24019
  device: string().optional()
24114
24020
  });
24115
24021
  /**
@@ -24148,28 +24054,10 @@ var PipelineDefaultStepSchema = lazy(() => object({
24148
24054
  group: string().optional(),
24149
24055
  settings: record(string(), unknown()).optional()
24150
24056
  }));
24151
- var PipelineTemplateStepSchema = lazy(() => object({
24152
- addonId: string(),
24153
- enabled: boolean(),
24154
- modelId: string(),
24155
- children: array(PipelineTemplateStepSchema).readonly(),
24156
- settings: record(string(), unknown()).optional()
24157
- }));
24158
- var PipelineTemplateSchema$1 = object({
24159
- id: string(),
24160
- name: string(),
24161
- createdAt: string(),
24162
- updatedAt: string(),
24163
- engine: PipelineEngineChoiceSchema,
24164
- steps: array(PipelineTemplateStepSchema).readonly()
24165
- });
24166
24057
  var PipelineModelOptionSchema = object({
24167
24058
  id: string(),
24168
24059
  name: string(),
24169
- formats: record(string(), object({
24170
- downloaded: boolean(),
24171
- sizeMB: number()
24172
- })),
24060
+ formats: record(string(), PipelineModelFormatStatusSchema),
24173
24061
  group: ModelVariantGroupSchema.optional(),
24174
24062
  legacy: boolean().optional(),
24175
24063
  provider: ModelProviderIdSchema.optional(),
@@ -24336,6 +24224,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24336
24224
  }), {
24337
24225
  kind: "mutation",
24338
24226
  auth: "admin"
24227
+ }), method(object({
24228
+ nodeId: string(),
24229
+ deviceIds: array(number()).readonly().optional(),
24230
+ dryRun: boolean()
24231
+ }), object({
24232
+ entries: array(object({
24233
+ deviceId: number(),
24234
+ keys: array(string()).readonly()
24235
+ })).readonly(),
24236
+ refused: array(object({
24237
+ deviceId: number(),
24238
+ reason: string()
24239
+ })).readonly()
24240
+ }), {
24241
+ kind: "mutation",
24242
+ auth: "admin"
24339
24243
  }), method(object({ nodeId: string() }), object({ unhealthy: array(object({
24340
24244
  /** `<backend>:<device>`, e.g. `openvino:gpu`. */
24341
24245
  deviceKey: string(),
@@ -24361,22 +24265,14 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24361
24265
  }), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
24362
24266
  steps: array(PipelineStepInputSchema),
24363
24267
  deviceKey: string().optional()
24364
- }), PipelineValidationResultSchema), method(_void(), array(PipelineTemplateSchema$1).readonly()), method(object({
24365
- name: string(),
24366
- steps: array(PipelineTemplateStepSchema).readonly(),
24367
- engine: PipelineEngineChoiceSchema
24368
- }), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
24369
- id: string(),
24370
- name: string().optional(),
24371
- steps: array(PipelineTemplateStepSchema).readonly().optional()
24372
- }), 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({
24373
24269
  addonId: string(),
24374
24270
  modelId: string(),
24375
- format: ModelFormatSchema$1
24271
+ format: ModelFormatSchema$2
24376
24272
  }), DownloadModelResultSchema, { kind: "mutation" }), method(object({
24377
24273
  addonId: string(),
24378
24274
  modelId: string(),
24379
- format: ModelFormatSchema$1
24275
+ format: ModelFormatSchema$2
24380
24276
  }), object({ success: literal(true) }), { kind: "mutation" }), method(object({
24381
24277
  steps: array(PipelineStepInputSchema).min(1),
24382
24278
  frame: FrameInputSchema.optional(),
@@ -24533,6 +24429,375 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24533
24429
  filename: string().optional(),
24534
24430
  settings: record(string(), unknown()).optional()
24535
24431
  }), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
24432
+ /**
24433
+ * The wire shapes of the Auto tune plan and apply (D745), used by the
24434
+ * `pipeline-orchestrator` cap. The recommender's own types
24435
+ * (`recommend.ts`) are the TS face of the same data; these
24436
+ * schemas are what crosses the cap boundary.
24437
+ */
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
+ };
24444
+ var HardwareClassIdSchema = _enum([
24445
+ "intel-core-ultra",
24446
+ "intel-n-series",
24447
+ "apple-m-base",
24448
+ "apple-m-pro",
24449
+ "unknown"
24450
+ ]);
24451
+ var AcceleratorKindSchema = _enum([
24452
+ "intel-npu",
24453
+ "intel-igpu",
24454
+ "x86-cpu",
24455
+ "arm-cpu",
24456
+ "apple-ane",
24457
+ "coral"
24458
+ ]);
24459
+ var RecommendationReasonSchema = discriminatedUnion("kind", [
24460
+ object({
24461
+ kind: literal("capacity"),
24462
+ sessions: number(),
24463
+ minSessions: number()
24464
+ }),
24465
+ object({
24466
+ kind: literal("tie-faster"),
24467
+ over: string(),
24468
+ recallDelta: number()
24469
+ }),
24470
+ object({
24471
+ kind: literal("stepped-down"),
24472
+ from: string(),
24473
+ to: string(),
24474
+ limitedBy: string()
24475
+ }),
24476
+ object({
24477
+ kind: literal("no-fit-lightest"),
24478
+ sessions: number(),
24479
+ minSessions: number()
24480
+ }),
24481
+ object({
24482
+ kind: literal("derived-latency"),
24483
+ modelId: string()
24484
+ }),
24485
+ object({ kind: literal("cpu-device") }),
24486
+ object({ kind: literal("coral-untouched") }),
24487
+ object({ kind: literal("device-disabled") }),
24488
+ object({ kind: literal("device-unavailable") }),
24489
+ object({ kind: literal("node-offline") }),
24490
+ object({ kind: literal("no-hardware-facts") }),
24491
+ object({
24492
+ kind: literal("no-measured-data"),
24493
+ hardwareClass: HardwareClassIdSchema
24494
+ }),
24495
+ object({
24496
+ kind: literal("no-family-build"),
24497
+ format: ModelFormatSchema$1
24498
+ })
24499
+ ]);
24500
+ var DeviceModelChoiceSchema = object({
24501
+ modelId: string(),
24502
+ p50Ms: number(),
24503
+ fps: number(),
24504
+ measured: boolean(),
24505
+ /** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
24506
+ capacitySessions: number(),
24507
+ personRecall: number()
24508
+ });
24509
+ var DeviceRecommendationSchema = object({
24510
+ deviceKey: string(),
24511
+ accelerator: AcceleratorKindSchema.nullable(),
24512
+ enabled: boolean(),
24513
+ available: boolean(),
24514
+ chosen: DeviceModelChoiceSchema.nullable(),
24515
+ reasons: array(RecommendationReasonSchema).readonly()
24516
+ });
24517
+ var NodeRecommendationSchema = object({
24518
+ nodeId: string(),
24519
+ reachable: boolean(),
24520
+ hardwareClass: HardwareClassIdSchema.nullable(),
24521
+ cpuModel: string().nullable(),
24522
+ skipped: boolean(),
24523
+ acceleratorModelId: string().nullable(),
24524
+ devices: array(DeviceRecommendationSchema).readonly(),
24525
+ reasons: array(RecommendationReasonSchema).readonly()
24526
+ });
24527
+ var ModelPinChangeSchema = object({
24528
+ stepId: string(),
24529
+ before: string().nullable(),
24530
+ after: string().nullable()
24531
+ });
24532
+ var NodeDeviceChangeSchema = object({
24533
+ nodeId: string(),
24534
+ deviceKey: string(),
24535
+ madeExplicit: boolean(),
24536
+ modelPins: array(ModelPinChangeSchema).readonly(),
24537
+ thresholds: array(object({
24538
+ stepId: string(),
24539
+ keys: array(string()).readonly()
24540
+ })).readonly()
24541
+ });
24542
+ var CameraOverrideClearSchema = object({
24543
+ deviceId: number(),
24544
+ source: _enum(["step-override", "wholesale"]),
24545
+ nodeId: string(),
24546
+ deviceKey: string().nullable(),
24547
+ stepId: string(),
24548
+ modelIdBefore: string().nullable(),
24549
+ keys: array(string()).readonly()
24550
+ });
24551
+ var DetectorStoreClearSchema = object({
24552
+ deviceId: number(),
24553
+ keys: array(string()).readonly()
24554
+ });
24555
+ var AutoTuneWarningSchema = discriminatedUnion("kind", [
24556
+ object({
24557
+ kind: literal("detector-store-cluster-wide"),
24558
+ skippedNodes: array(string()).readonly()
24559
+ }),
24560
+ object({
24561
+ kind: literal("detector-store-unreadable"),
24562
+ error: string()
24563
+ }),
24564
+ object({
24565
+ kind: literal("coral-enabled"),
24566
+ nodeId: string(),
24567
+ deviceKey: string()
24568
+ })
24569
+ ]);
24570
+ var AutoTuneOptionsSchema = object({
24571
+ /** Share of each accelerator's throughput kept free (0.3–0.5). */
24572
+ headroom: number().min(.3).max(.5).default(.4),
24573
+ /**
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.
24577
+ */
24578
+ minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
24579
+ });
24580
+ var AutoTunePlanSchema = object({
24581
+ /** Hash of everything the apply will write — the apply refuses a different one. */
24582
+ planHash: string(),
24583
+ family: literal("yolov9"),
24584
+ headroom: number(),
24585
+ minSessionsPerDevice: number(),
24586
+ /** The detection rate a session is counted at (the fastest camera running the pipeline root). */
24587
+ cameraFps: number(),
24588
+ generatedAt: number(),
24589
+ nodes: array(NodeRecommendationSchema).readonly(),
24590
+ nodeChanges: array(NodeDeviceChangeSchema).readonly(),
24591
+ cameraClears: array(CameraOverrideClearSchema).readonly(),
24592
+ detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
24593
+ warnings: array(AutoTuneWarningSchema).readonly()
24594
+ });
24595
+ var AutoTuneApplyInputSchema = object({
24596
+ planHash: string(),
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)
24599
+ });
24600
+ var AutoTunePhaseResultSchema = object({
24601
+ phase: _enum([
24602
+ "download",
24603
+ "camera-overrides",
24604
+ "detector-thresholds",
24605
+ "node-models",
24606
+ "redispatch"
24607
+ ]),
24608
+ ok: boolean(),
24609
+ detail: string()
24610
+ });
24611
+ var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
24612
+ object({
24613
+ kind: literal("applied"),
24614
+ planHash: string(),
24615
+ phases: array(AutoTunePhaseResultSchema).readonly()
24616
+ }),
24617
+ object({
24618
+ kind: literal("aborted"),
24619
+ phases: array(AutoTunePhaseResultSchema).readonly()
24620
+ }),
24621
+ object({
24622
+ kind: literal("stale"),
24623
+ plan: AutoTunePlanSchema
24624
+ }),
24625
+ object({
24626
+ kind: literal("refused"),
24627
+ reason: _enum(["apply-in-progress"])
24628
+ })
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
+ });
24536
24801
  object({
24537
24802
  activeCameras: number(),
24538
24803
  throttledCameras: number(),
@@ -25410,14 +25675,15 @@ var RunnerLocalLoadSchema = object({
25410
25675
  * Per-inference-device live load (multi-device C4). One entry per deviceKey
25411
25676
  * this runner currently has attached cameras on, so the orchestrator's second
25412
25677
  * `balance()` pass (over a node's devices) weights on real per-pool session
25413
- * counts. Empty on single-device / pre-multi-device runners. `queueDepthTotal`
25414
- * 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).
25415
25682
  */
25416
25683
  devices: array(object({
25417
25684
  deviceKey: string(),
25418
25685
  backend: string(),
25419
- attachedCameras: number(),
25420
- queueDepthTotal: number()
25686
+ attachedCameras: number()
25421
25687
  })).default([]),
25422
25688
  /** Hardware capability flags reported by this node. */
25423
25689
  hardware: object({
@@ -25631,14 +25897,6 @@ var CameraPipelineConfigSchema = object({
25631
25897
  settings: record(string(), unknown()).readonly().optional()
25632
25898
  }).nullable().optional()
25633
25899
  });
25634
- var PipelineTemplateSchema = object({
25635
- id: string(),
25636
- name: string(),
25637
- description: string().optional(),
25638
- config: CameraPipelineConfigSchema,
25639
- createdAt: string(),
25640
- updatedAt: string()
25641
- });
25642
25900
  var DeviceStepConfigSchema = object({
25643
25901
  modelId: string().optional(),
25644
25902
  settings: record(string(), unknown()).optional(),
@@ -25712,9 +25970,10 @@ var CameraStepOverridePatchSchema = object({
25712
25970
  modelId: string().optional(),
25713
25971
  settings: record(string(), unknown()).readonly().optional()
25714
25972
  });
25973
+ var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
25715
25974
  var CameraPipelineSettingsSchema = object({
25716
- pinnedAgentNodeId: string().optional(),
25717
25975
  stepToggles: record(string(), boolean()).optional(),
25976
+ stepSettings: CameraStepSettingsSchema.optional(),
25718
25977
  stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
25719
25978
  pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
25720
25979
  });
@@ -25747,7 +26006,10 @@ var PipelineAssignmentSchema = object({
25747
26006
  });
25748
26007
  /**
25749
26008
  * Per-agent load summary surfaced to the load balancer + dashboards.
25750
- * 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.
25751
26013
  */
25752
26014
  var AgentLoadSummarySchema = object({
25753
26015
  nodeId: string(),
@@ -25836,26 +26098,27 @@ var CameraBrokerStatusSchema = object({
25836
26098
  width: number(),
25837
26099
  height: number(),
25838
26100
  subscribers: number(),
25839
- inFps: number(),
25840
- 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()
25841
26109
  })).readonly(),
25842
26110
  webrtcSessions: number(),
25843
26111
  rtspRestream: boolean()
25844
26112
  });
25845
- /** Shared-memory ring statistics within the decoder block. */
25846
- var CameraDecoderShmSchema = object({
25847
- framesWritten: number(),
25848
- getFrameHits: number(),
25849
- getFrameMisses: number(),
25850
- budgetMb: number()
25851
- });
25852
- /** Decoder block — null when the decoder stage is unreachable or inactive. */
25853
- var CameraDecoderStatusSchema = object({
25854
- nodeId: string(),
25855
- formats: array(string()).readonly(),
25856
- sessionCount: number(),
25857
- shm: CameraDecoderShmSchema
25858
- });
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() });
25859
26122
  /** Motion block — null when motion detection is not active for this device. */
25860
26123
  var CameraMotionStatusSchema = object({
25861
26124
  enabled: boolean(),
@@ -26212,12 +26475,6 @@ method(object({
26212
26475
  }), object({ success: literal(true) }), {
26213
26476
  kind: "mutation",
26214
26477
  auth: "admin"
26215
- }), method(object({
26216
- agentNodeId: string(),
26217
- detectWeight: number().positive().nullable()
26218
- }), object({ success: literal(true) }), {
26219
- kind: "mutation",
26220
- auth: "admin"
26221
26478
  }), method(object({
26222
26479
  agentNodeId: string(),
26223
26480
  detect: boolean().nullable().optional(),
@@ -26259,6 +26516,15 @@ method(object({
26259
26516
  }), {
26260
26517
  kind: "mutation",
26261
26518
  auth: "admin"
26519
+ }), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
26520
+ kind: "mutation",
26521
+ auth: "admin"
26522
+ }), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
26523
+ kind: "mutation",
26524
+ auth: "admin"
26525
+ }), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
26526
+ kind: "mutation",
26527
+ auth: "admin"
26262
26528
  }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
26263
26529
  deviceId: number(),
26264
26530
  addonId: string(),
@@ -26275,6 +26541,13 @@ method(object({
26275
26541
  }), object({ success: literal(true) }), {
26276
26542
  kind: "mutation",
26277
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"
26278
26551
  }), method(object({
26279
26552
  deviceId: number(),
26280
26553
  agentNodeId: string(),
@@ -26298,25 +26571,7 @@ method(object({
26298
26571
  }), method(_void(), DiskReconcileJobSchema, {
26299
26572
  kind: "mutation",
26300
26573
  auth: "admin"
26301
- }), method(_void(), DiskReconcileJobSchema, { auth: "admin" }), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
26302
- name: string(),
26303
- description: string().optional(),
26304
- config: CameraPipelineConfigSchema
26305
- }), PipelineTemplateSchema, {
26306
- kind: "mutation",
26307
- auth: "admin"
26308
- }), method(object({
26309
- id: string(),
26310
- name: string().optional(),
26311
- description: string().optional(),
26312
- config: CameraPipelineConfigSchema.optional()
26313
- }), PipelineTemplateSchema, {
26314
- kind: "mutation",
26315
- auth: "admin"
26316
- }), method(object({ id: string() }), object({ success: literal(true) }), {
26317
- kind: "mutation",
26318
- auth: "admin"
26319
- });
26574
+ }), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
26320
26575
  /**
26321
26576
  * Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
26322
26577
  * `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
@@ -28729,8 +28984,6 @@ var WebrtcStreamChoiceSchema = object({
28729
28984
  ]).nullable(),
28730
28985
  /** Input FPS from the camera (null for adaptive). */
28731
28986
  inputFps: number().nullable(),
28732
- /** Decoded FPS (null for adaptive). */
28733
- decodeFps: number().nullable(),
28734
28987
  /** Bitrate in kbps (null for adaptive). */
28735
28988
  bitrateKbps: number().nullable()
28736
28989
  });
@@ -29062,6 +29315,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
29062
29315
  */
29063
29316
  alive: boolean()
29064
29317
  })), method(object({
29318
+ deviceId: number().int().nonnegative(),
29319
+ sessionId: string(),
29320
+ downlinkMbps: number().nonnegative()
29321
+ }), object({
29322
+ outcome: _enum(["switching", "held"]),
29323
+ tier: CamProfileSchema.nullable(),
29324
+ reason: string()
29325
+ }), { kind: "mutation" }), method(object({
29065
29326
  deviceId: number().int().nonnegative(),
29066
29327
  sessionId: string()
29067
29328
  }), WebrtcSessionDebugSchema, { kind: "query" });
@@ -31773,7 +32034,8 @@ var ConnectionEndpointSchema = object({
31773
32034
  "lan-ipv6",
31774
32035
  "public",
31775
32036
  "loopback",
31776
- "app-link"
32037
+ "app-link",
32038
+ "custom"
31777
32039
  ]),
31778
32040
  /**
31779
32041
  * Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
@@ -31842,7 +32104,7 @@ var GetConnectionEndpointsResultSchema = object({
31842
32104
  localPort: AdvertisedLocalPortSchema
31843
32105
  });
31844
32106
  /**
31845
- * The address flagged for notification links. `baseUrl: null` = AUTO, which
32107
+ * The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
31846
32108
  * since D709 is the CamStack app link; `resolved` reports the effective value,
31847
32109
  * so the UI can show it either way.
31848
32110
  */
@@ -31876,13 +32138,12 @@ var ViewerEndpointsSchema = object({
31876
32138
  resolved: array(string()).readonly()
31877
32139
  });
31878
32140
  /**
31879
- * One audience's hub address (see `hub-address.ts`): the operator's stored
31880
- * override, the address in use, and where it came from.
32141
+ * DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
32142
+ * for addons built against it): `cluster` is the `internal` role, `browser`
32143
+ * the `publicEndpoint` role; `override` is the flagged address.
31881
32144
  */
31882
32145
  var HubAddressSnapshotSchema = object({
31883
- /** The operator's override, or null for automatic. */
31884
32146
  override: string().nullable(),
31885
- /** The address in use, or null when nothing qualifies (never loopback). */
31886
32147
  resolved: string().nullable(),
31887
32148
  source: _enum([
31888
32149
  "override",
@@ -31891,11 +32152,57 @@ var HubAddressSnapshotSchema = object({
31891
32152
  ])
31892
32153
  });
31893
32154
  var HubAddressesSchema = object({
31894
- /** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
31895
32155
  cluster: HubAddressSnapshotSchema,
31896
- /** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
31897
32156
  browser: HubAddressSnapshotSchema
31898
32157
  });
32158
+ /**
32159
+ * What an address is used for (`hub-address.ts`, D734). `appConnections` is
32160
+ * many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
32161
+ * by at most one address.
32162
+ */
32163
+ var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
32164
+ var RoleSourceSchema = _enum([
32165
+ "flagged",
32166
+ "auto",
32167
+ "none"
32168
+ ]);
32169
+ /** One single-valued role: the flagged address, the one in use, and why. */
32170
+ var HubAddressRoleResolutionSchema = object({
32171
+ /** The address carrying the flag, or null = automatic. */
32172
+ flagged: string().nullable(),
32173
+ /** The address in use, or null when nothing qualifies (never loopback). */
32174
+ resolved: string().nullable(),
32175
+ source: RoleSourceSchema
32176
+ });
32177
+ var HubAppConnectionsResolutionSchema = object({
32178
+ /** The addresses flagged `appConnections`, or empty = automatic. */
32179
+ flagged: array(string()).readonly(),
32180
+ /** What the apps race right now. */
32181
+ resolved: array(string()).readonly(),
32182
+ source: RoleSourceSchema
32183
+ });
32184
+ var HubAddressBookSchema = object({
32185
+ rows: array(ConnectionEndpointSchema.extend({
32186
+ /** In the hub's detected palette right now. */
32187
+ detected: boolean(),
32188
+ /** Entered by the operator (removable). */
32189
+ custom: boolean(),
32190
+ /** The roles explicitly flagged on this address. */
32191
+ flags: array(HubAddressRoleSchema).readonly(),
32192
+ /** The roles this address serves right now — flagged or automatic. */
32193
+ inUse: array(HubAddressRoleSchema).readonly(),
32194
+ /** The roles this address may be flagged with. */
32195
+ eligible: array(HubAddressRoleSchema).readonly()
32196
+ })).readonly(),
32197
+ roles: object({
32198
+ appConnections: HubAppConnectionsResolutionSchema,
32199
+ notificationTaps: HubAddressRoleResolutionSchema,
32200
+ internal: HubAddressRoleResolutionSchema,
32201
+ publicEndpoint: HubAddressRoleResolutionSchema
32202
+ }),
32203
+ /** The `hub=` an app link carries (D709), or null. */
32204
+ appLinkHub: string().nullable()
32205
+ });
31899
32206
  var AllowedAddressesSchema = object({
31900
32207
  /**
31901
32208
  * Allowlist of interface addresses operators have explicitly opted
@@ -31939,16 +32246,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
31939
32246
  * tunnel always emits `https://` regardless. */
31940
32247
  scheme: _enum(["http", "https"]).optional(),
31941
32248
  /** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
31942
- * an address notification links can be flagged with, not a hub
32249
+ * an address notification taps can be flagged with, not a hub
31943
32250
  * route. Default `false`: racers and rankers never see it. */
31944
32251
  includeAppLink: boolean().optional()
31945
- }), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(_void(), HubAddressesSchema), method(object({
31946
- audience: _enum(["cluster", "browser"]),
31947
- baseUrl: string().nullable()
31948
- }), HubAddressesSchema, {
32252
+ }), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(object({ scheme: _enum(["http", "https"]).optional() }).optional(), HubAddressBookSchema), method(object({
32253
+ baseUrl: string(),
32254
+ label: string().max(80)
32255
+ }), HubAddressBookSchema, {
31949
32256
  kind: "mutation",
31950
32257
  auth: "admin"
31951
- }), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
32258
+ }), method(object({ baseUrl: string() }), HubAddressBookSchema, {
32259
+ kind: "mutation",
32260
+ auth: "admin"
32261
+ }), method(object({
32262
+ role: HubAddressRoleSchema,
32263
+ baseUrl: string().nullable(),
32264
+ enabled: boolean(),
32265
+ acceptInsecureHttp: boolean().optional()
32266
+ }), HubAddressBookSchema, {
32267
+ kind: "mutation",
32268
+ auth: "admin"
32269
+ }), method(_void(), HubAddressesSchema), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
31952
32270
  kind: "mutation",
31953
32271
  auth: "admin"
31954
32272
  }), method(object({
@@ -37495,6 +37813,16 @@ DeviceType.Camera, method(object({
37495
37813
  package: array(ZoneRuleSchema).readonly()
37496
37814
  });
37497
37815
  SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
37816
+ Object.freeze({
37817
+ person: .5,
37818
+ vehicle: .5,
37819
+ animal: .5
37820
+ });
37821
+ Object.freeze({
37822
+ person: .65,
37823
+ vehicle: .65,
37824
+ animal: .65
37825
+ });
37498
37826
  /**
37499
37827
  * Accessory device helpers — shared across drivers.
37500
37828
  *
@@ -38851,90 +39179,18 @@ Object.freeze({
38851
39179
  addonId: null,
38852
39180
  access: "create"
38853
39181
  },
38854
- "decoder.createSession": {
38855
- capName: "decoder",
38856
- capScope: "system",
38857
- addonId: null,
38858
- access: "view"
38859
- },
38860
- "decoder.destroySession": {
38861
- capName: "decoder",
38862
- capScope: "system",
38863
- addonId: null,
38864
- access: "delete"
38865
- },
38866
- "decoder.getFrame": {
38867
- capName: "decoder",
38868
- capScope: "system",
38869
- addonId: null,
38870
- access: "view"
38871
- },
38872
39182
  "decoder.getInfo": {
38873
39183
  capName: "decoder",
38874
39184
  capScope: "system",
38875
39185
  addonId: null,
38876
39186
  access: "view"
38877
39187
  },
38878
- "decoder.getShmStats": {
38879
- capName: "decoder",
38880
- capScope: "system",
38881
- addonId: null,
38882
- access: "view"
38883
- },
38884
- "decoder.getStats": {
38885
- capName: "decoder",
38886
- capScope: "system",
38887
- addonId: null,
38888
- access: "view"
38889
- },
38890
- "decoder.listActiveSessions": {
38891
- capName: "decoder",
38892
- capScope: "system",
38893
- addonId: null,
38894
- access: "view"
38895
- },
38896
- "decoder.openStream": {
38897
- capName: "decoder",
38898
- capScope: "system",
38899
- addonId: null,
38900
- access: "view"
38901
- },
38902
- "decoder.pullFrames": {
38903
- capName: "decoder",
38904
- capScope: "system",
38905
- addonId: null,
38906
- access: "view"
38907
- },
38908
- "decoder.pullHandles": {
38909
- capName: "decoder",
38910
- capScope: "system",
38911
- addonId: null,
38912
- access: "view"
38913
- },
38914
- "decoder.pushPacket": {
38915
- capName: "decoder",
38916
- capScope: "system",
38917
- addonId: null,
38918
- access: "view"
38919
- },
38920
39188
  "decoder.reprobeHwaccel": {
38921
39189
  capName: "decoder",
38922
39190
  capScope: "system",
38923
39191
  addonId: null,
38924
39192
  access: "create"
38925
39193
  },
38926
- "decoder.supportsCodec": {
38927
- capName: "decoder",
38928
- capScope: "system",
38929
- addonId: null,
38930
- access: "view"
38931
- },
38932
- "decoder.updateConfig": {
38933
- capName: "decoder",
38934
- capScope: "system",
38935
- addonId: null,
38936
- access: "view"
38937
- },
38938
39194
  "detectionPipeline.applyDeviceSettingsPatch": {
38939
39195
  capName: "detection-pipeline",
38940
39196
  capScope: "device",
@@ -40423,12 +40679,24 @@ Object.freeze({
40423
40679
  addonId: null,
40424
40680
  access: "view"
40425
40681
  },
40682
+ "localNetwork.addCustomAddress": {
40683
+ capName: "local-network",
40684
+ capScope: "system",
40685
+ addonId: null,
40686
+ access: "create"
40687
+ },
40426
40688
  "localNetwork.downloadCa": {
40427
40689
  capName: "local-network",
40428
40690
  capScope: "system",
40429
40691
  addonId: null,
40430
40692
  access: "view"
40431
40693
  },
40694
+ "localNetwork.getAddresses": {
40695
+ capName: "local-network",
40696
+ capScope: "system",
40697
+ addonId: null,
40698
+ access: "view"
40699
+ },
40432
40700
  "localNetwork.getAllowedAddresses": {
40433
40701
  capName: "local-network",
40434
40702
  capScope: "system",
@@ -40483,6 +40751,12 @@ Object.freeze({
40483
40751
  addonId: null,
40484
40752
  access: "create"
40485
40753
  },
40754
+ "localNetwork.removeCustomAddress": {
40755
+ capName: "local-network",
40756
+ capScope: "system",
40757
+ addonId: null,
40758
+ access: "delete"
40759
+ },
40486
40760
  "localNetwork.resetAllowlistToBestMatch": {
40487
40761
  capName: "local-network",
40488
40762
  capScope: "system",
@@ -40495,13 +40769,13 @@ Object.freeze({
40495
40769
  addonId: null,
40496
40770
  access: "create"
40497
40771
  },
40498
- "localNetwork.setAllowedAddresses": {
40772
+ "localNetwork.setAddressRole": {
40499
40773
  capName: "local-network",
40500
40774
  capScope: "system",
40501
40775
  addonId: null,
40502
40776
  access: "create"
40503
40777
  },
40504
- "localNetwork.setHubAddress": {
40778
+ "localNetwork.setAllowedAddresses": {
40505
40779
  capName: "local-network",
40506
40780
  capScope: "system",
40507
40781
  addonId: null,
@@ -41995,13 +42269,13 @@ Object.freeze({
41995
42269
  addonId: null,
41996
42270
  access: "delete"
41997
42271
  },
41998
- "pipelineExecutor.deleteModel": {
42272
+ "pipelineExecutor.clearModelBoundDeviceOverrides": {
41999
42273
  capName: "pipeline-executor",
42000
42274
  capScope: "system",
42001
42275
  addonId: null,
42002
42276
  access: "delete"
42003
42277
  },
42004
- "pipelineExecutor.deleteTemplate": {
42278
+ "pipelineExecutor.deleteModel": {
42005
42279
  capName: "pipeline-executor",
42006
42280
  capScope: "system",
42007
42281
  addonId: null,
@@ -42145,12 +42419,6 @@ Object.freeze({
42145
42419
  addonId: null,
42146
42420
  access: "view"
42147
42421
  },
42148
- "pipelineExecutor.listTemplates": {
42149
- capName: "pipeline-executor",
42150
- capScope: "system",
42151
- addonId: null,
42152
- access: "view"
42153
- },
42154
42422
  "pipelineExecutor.rearmInferenceDevice": {
42155
42423
  capName: "pipeline-executor",
42156
42424
  capScope: "system",
@@ -42175,12 +42443,6 @@ Object.freeze({
42175
42443
  addonId: null,
42176
42444
  access: "create"
42177
42445
  },
42178
- "pipelineExecutor.saveTemplate": {
42179
- capName: "pipeline-executor",
42180
- capScope: "system",
42181
- addonId: null,
42182
- access: "create"
42183
- },
42184
42446
  "pipelineExecutor.setVideoPipelineSteps": {
42185
42447
  capName: "pipeline-executor",
42186
42448
  capScope: "system",
@@ -42199,41 +42461,35 @@ Object.freeze({
42199
42461
  addonId: null,
42200
42462
  access: "create"
42201
42463
  },
42202
- "pipelineExecutor.updateTemplate": {
42203
- capName: "pipeline-executor",
42204
- capScope: "system",
42205
- addonId: null,
42206
- access: "create"
42207
- },
42208
42464
  "pipelineExecutor.validatePipeline": {
42209
42465
  capName: "pipeline-executor",
42210
42466
  capScope: "system",
42211
42467
  addonId: null,
42212
42468
  access: "view"
42213
42469
  },
42214
- "pipelineOrchestrator.applyDeviceSettingsPatch": {
42470
+ "pipelineOrchestrator.applyAutoTune": {
42215
42471
  capName: "pipeline-orchestrator",
42216
42472
  capScope: "system",
42217
42473
  addonId: null,
42218
42474
  access: "create"
42219
42475
  },
42220
- "pipelineOrchestrator.assignAudio": {
42476
+ "pipelineOrchestrator.applyDeviceSettingsPatch": {
42221
42477
  capName: "pipeline-orchestrator",
42222
42478
  capScope: "system",
42223
42479
  addonId: null,
42224
42480
  access: "create"
42225
42481
  },
42226
- "pipelineOrchestrator.assignPipeline": {
42482
+ "pipelineOrchestrator.assignAudio": {
42227
42483
  capName: "pipeline-orchestrator",
42228
42484
  capScope: "system",
42229
42485
  addonId: null,
42230
42486
  access: "create"
42231
42487
  },
42232
- "pipelineOrchestrator.deleteTemplate": {
42488
+ "pipelineOrchestrator.assignPipeline": {
42233
42489
  capName: "pipeline-orchestrator",
42234
42490
  capScope: "system",
42235
42491
  addonId: null,
42236
- access: "delete"
42492
+ access: "create"
42237
42493
  },
42238
42494
  "pipelineOrchestrator.getAgentLoad": {
42239
42495
  capName: "pipeline-orchestrator",
@@ -42325,6 +42581,12 @@ Object.freeze({
42325
42581
  addonId: null,
42326
42582
  access: "view"
42327
42583
  },
42584
+ "pipelineOrchestrator.getEffectiveShares": {
42585
+ capName: "pipeline-orchestrator",
42586
+ capScope: "system",
42587
+ addonId: null,
42588
+ access: "view"
42589
+ },
42328
42590
  "pipelineOrchestrator.getGlobalMetrics": {
42329
42591
  capName: "pipeline-orchestrator",
42330
42592
  capScope: "system",
@@ -42361,19 +42623,19 @@ Object.freeze({
42361
42623
  addonId: null,
42362
42624
  access: "view"
42363
42625
  },
42364
- "pipelineOrchestrator.getReconcileFromDiskStatus": {
42626
+ "pipelineOrchestrator.getPlacementStats": {
42365
42627
  capName: "pipeline-orchestrator",
42366
42628
  capScope: "system",
42367
42629
  addonId: null,
42368
42630
  access: "view"
42369
42631
  },
42370
- "pipelineOrchestrator.listAgentSettings": {
42632
+ "pipelineOrchestrator.getReconcileFromDiskStatus": {
42371
42633
  capName: "pipeline-orchestrator",
42372
42634
  capScope: "system",
42373
42635
  addonId: null,
42374
42636
  access: "view"
42375
42637
  },
42376
- "pipelineOrchestrator.listTemplates": {
42638
+ "pipelineOrchestrator.listAgentSettings": {
42377
42639
  capName: "pipeline-orchestrator",
42378
42640
  capScope: "system",
42379
42641
  addonId: null,
@@ -42385,6 +42647,12 @@ Object.freeze({
42385
42647
  addonId: null,
42386
42648
  access: "create"
42387
42649
  },
42650
+ "pipelineOrchestrator.planAutoTune": {
42651
+ capName: "pipeline-orchestrator",
42652
+ capScope: "system",
42653
+ addonId: null,
42654
+ access: "view"
42655
+ },
42388
42656
  "pipelineOrchestrator.rebalance": {
42389
42657
  capName: "pipeline-orchestrator",
42390
42658
  capScope: "system",
@@ -42427,12 +42695,6 @@ Object.freeze({
42427
42695
  addonId: null,
42428
42696
  access: "create"
42429
42697
  },
42430
- "pipelineOrchestrator.saveTemplate": {
42431
- capName: "pipeline-orchestrator",
42432
- capScope: "system",
42433
- addonId: null,
42434
- access: "create"
42435
- },
42436
42698
  "pipelineOrchestrator.setAgentCapabilities": {
42437
42699
  capName: "pipeline-orchestrator",
42438
42700
  capScope: "system",
@@ -42445,12 +42707,6 @@ Object.freeze({
42445
42707
  addonId: null,
42446
42708
  access: "create"
42447
42709
  },
42448
- "pipelineOrchestrator.setAgentDetectWeight": {
42449
- capName: "pipeline-orchestrator",
42450
- capScope: "system",
42451
- addonId: null,
42452
- access: "create"
42453
- },
42454
42710
  "pipelineOrchestrator.setAgentInferenceDevices": {
42455
42711
  capName: "pipeline-orchestrator",
42456
42712
  capScope: "system",
@@ -42487,6 +42743,12 @@ Object.freeze({
42487
42743
  addonId: null,
42488
42744
  access: "create"
42489
42745
  },
42746
+ "pipelineOrchestrator.setCameraStepSettings": {
42747
+ capName: "pipeline-orchestrator",
42748
+ capScope: "system",
42749
+ addonId: null,
42750
+ access: "create"
42751
+ },
42490
42752
  "pipelineOrchestrator.setCameraStepToggle": {
42491
42753
  capName: "pipeline-orchestrator",
42492
42754
  capScope: "system",
@@ -42505,25 +42767,37 @@ Object.freeze({
42505
42767
  addonId: null,
42506
42768
  access: "create"
42507
42769
  },
42770
+ "pipelineOrchestrator.setLoadBalancingShares": {
42771
+ capName: "pipeline-orchestrator",
42772
+ capScope: "system",
42773
+ addonId: null,
42774
+ access: "create"
42775
+ },
42508
42776
  "pipelineOrchestrator.setPipelineDevicePin": {
42509
42777
  capName: "pipeline-orchestrator",
42510
42778
  capScope: "system",
42511
42779
  addonId: null,
42512
42780
  access: "create"
42513
42781
  },
42514
- "pipelineOrchestrator.unassignAudio": {
42782
+ "pipelineOrchestrator.setShareSource": {
42515
42783
  capName: "pipeline-orchestrator",
42516
42784
  capScope: "system",
42517
42785
  addonId: null,
42518
42786
  access: "create"
42519
42787
  },
42520
- "pipelineOrchestrator.unassignPipeline": {
42788
+ "pipelineOrchestrator.suggestShares": {
42789
+ capName: "pipeline-orchestrator",
42790
+ capScope: "system",
42791
+ addonId: null,
42792
+ access: "view"
42793
+ },
42794
+ "pipelineOrchestrator.unassignAudio": {
42521
42795
  capName: "pipeline-orchestrator",
42522
42796
  capScope: "system",
42523
42797
  addonId: null,
42524
42798
  access: "create"
42525
42799
  },
42526
- "pipelineOrchestrator.updateTemplate": {
42800
+ "pipelineOrchestrator.unassignPipeline": {
42527
42801
  capName: "pipeline-orchestrator",
42528
42802
  capScope: "system",
42529
42803
  addonId: null,
@@ -43963,12 +44237,6 @@ Object.freeze({
43963
44237
  addonId: null,
43964
44238
  access: "view"
43965
44239
  },
43966
- "streamBroker.pullFrameHandles": {
43967
- capName: "stream-broker",
43968
- capScope: "system",
43969
- addonId: null,
43970
- access: "view"
43971
- },
43972
44240
  "streamBroker.regenerateRtspToken": {
43973
44241
  capName: "stream-broker",
43974
44242
  capScope: "system",
@@ -44035,12 +44303,6 @@ Object.freeze({
44035
44303
  addonId: null,
44036
44304
  access: "create"
44037
44305
  },
44038
- "streamBroker.subscribeFrames": {
44039
- capName: "stream-broker",
44040
- capScope: "system",
44041
- addonId: null,
44042
- access: "create"
44043
- },
44044
44306
  "streamBroker.unassignProfile": {
44045
44307
  capName: "stream-broker",
44046
44308
  capScope: "system",
@@ -44053,12 +44315,6 @@ Object.freeze({
44053
44315
  addonId: null,
44054
44316
  access: "create"
44055
44317
  },
44056
- "streamBroker.unsubscribeFrames": {
44057
- capName: "stream-broker",
44058
- capScope: "system",
44059
- addonId: null,
44060
- access: "create"
44061
- },
44062
44318
  "streamCatalog.getCatalog": {
44063
44319
  capName: "stream-catalog",
44064
44320
  capScope: "device",
@@ -44755,6 +45011,12 @@ Object.freeze({
44755
45011
  addonId: null,
44756
45012
  access: "create"
44757
45013
  },
45014
+ "webrtcSession.applyDownlinkProbe": {
45015
+ capName: "webrtc-session",
45016
+ capScope: "device",
45017
+ addonId: null,
45018
+ access: "create"
45019
+ },
44758
45020
  "webrtcSession.closeSession": {
44759
45021
  capName: "webrtc-session",
44760
45022
  capScope: "device",
@@ -46566,11 +46828,6 @@ Object.freeze({
46566
46828
  form: "single",
46567
46829
  optional: false
46568
46830
  }],
46569
- "decoder.createSession": [{
46570
- name: "deviceId",
46571
- form: "single",
46572
- optional: true
46573
- }],
46574
46831
  "detectionPipeline.applyDeviceSettingsPatch": [{
46575
46832
  name: "deviceId",
46576
46833
  form: "single",
@@ -47801,6 +48058,11 @@ Object.freeze({
47801
48058
  form: "single",
47802
48059
  optional: false
47803
48060
  }],
48061
+ "pipelineExecutor.clearModelBoundDeviceOverrides": [{
48062
+ name: "deviceIds",
48063
+ form: "array",
48064
+ optional: true
48065
+ }],
47804
48066
  "pipelineExecutor.runPipeline": [{
47805
48067
  name: "deviceId",
47806
48068
  form: "single",
@@ -47906,6 +48168,11 @@ Object.freeze({
47906
48168
  form: "single",
47907
48169
  optional: false
47908
48170
  }],
48171
+ "pipelineOrchestrator.setCameraStepSettings": [{
48172
+ name: "deviceId",
48173
+ form: "single",
48174
+ optional: false
48175
+ }],
47909
48176
  "pipelineOrchestrator.setCameraStepToggle": [{
47910
48177
  name: "deviceId",
47911
48178
  form: "single",
@@ -48677,6 +48944,11 @@ Object.freeze({
48677
48944
  form: "single",
48678
48945
  optional: false
48679
48946
  }],
48947
+ "webrtcSession.applyDownlinkProbe": [{
48948
+ name: "deviceId",
48949
+ form: "single",
48950
+ optional: false
48951
+ }],
48680
48952
  "webrtcSession.closeSession": [{
48681
48953
  name: "deviceId",
48682
48954
  form: "single",
@@ -116152,7 +116424,6 @@ var HAP_STREAM_PREFERENCE_OPTIONS = [
116152
116424
  ];
116153
116425
  var DEFAULT_CONFIG = {
116154
116426
  bridgeName: "CamStack Bridge",
116155
- port: 0,
116156
116427
  fixedPin: "",
116157
116428
  interfaceName: "",
116158
116429
  ptzPulseMs: 400,
@@ -116829,20 +117100,11 @@ var ExportHapAddon = class extends BaseAddon {
116829
117100
  type: "text",
116830
117101
  key: "bridgeName",
116831
117102
  label: "Installation name",
116832
- description: "Legacy. Every exposed device is published STANDALONE, under its own camstack device name — HomeKit cameras cannot be bridged, so nothing is bridged. This string only seeds the identity generated on first boot and is not shown in iOS Home.",
117103
+ description: "The name of the shared bridge that carries every exposed device that is not a camera (switches, sensors, locks, alarm panels) — what iOS Home lists under Add Accessory. Cameras are never bridged: each one is published as its own accessory under its device name. Set it before you add the bridge in iOS Home.",
116833
117104
  default: DEFAULT_CONFIG.bridgeName,
116834
117105
  requiresRestart: true,
116835
117106
  placement: { tab: "advanced" }
116836
117107
  }),
116837
- this.field({
116838
- type: "number",
116839
- key: "port",
116840
- label: "HAP port",
116841
- description: "Local port for the HAP server. 0 = random ephemeral port (recommended).",
116842
- default: DEFAULT_CONFIG.port,
116843
- requiresRestart: true,
116844
- placement: { tab: "advanced" }
116845
- }),
116846
117108
  this.field({
116847
117109
  type: "text",
116848
117110
  key: "fixedPin",