@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.
@@ -38,7 +38,7 @@ var __copyProps = (to, from, except, desc) => {
38
38
  var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
39
39
  var __require = /* @__PURE__ */ createRequire(import.meta.url);
40
40
  //#endregion
41
- //#region ../types/dist/event-category-BGmz_oxW.mjs
41
+ //#region ../types/dist/event-category-B_0XEcLF.mjs
42
42
  var EventCategory = /* @__PURE__ */ function(EventCategory) {
43
43
  EventCategory["SystemBoot"] = "system.boot";
44
44
  EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -539,15 +539,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
539
539
  EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
540
540
  EventCategory["AgentBackupActivated"] = "agent.backup.activated";
541
541
  EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
542
- /**
543
- * Per-agent hwaccel preference changed (user override set, cleared, or
544
- * re-probed). Observability event — decoders pull the current pref at
545
- * `createSession`, so running sessions keep their current backend until
546
- * they rotate naturally (camera add/remove, stream restart). Future
547
- * work can wire a listener in stream-broker that force-rotates live
548
- * sessions; for now this event powers logs + admin-UI toast feedback.
549
- */
550
- EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
551
542
  EventCategory["MotionAnalysis"] = "detection.motion-analysis";
552
543
  /** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
553
544
  EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
@@ -5418,7 +5409,7 @@ var ZodIssueCode = {
5418
5409
  var ZodFirstPartyTypeKind;
5419
5410
  ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
5420
5411
  //#endregion
5421
- //#region ../types/dist/sleep-DXKLNFvA.mjs
5412
+ //#region ../types/dist/sleep-BNeXenvr.mjs
5422
5413
  /**
5423
5414
  * The audio chunk plane's byte format, and the ONE expansion from a coded
5424
5415
  * window to float samples (D455).
@@ -6784,32 +6775,12 @@ object({
6784
6775
  audioCodec: string().optional(),
6785
6776
  metadata: record(string(), unknown()).readonly().optional()
6786
6777
  });
6787
- var EncodedPacketSchema = object({
6788
- type: _enum(["video", "audio"]),
6789
- data: _instanceof(Uint8Array),
6790
- pts: number(),
6791
- dts: number(),
6792
- keyframe: boolean(),
6793
- codec: string()
6794
- });
6795
- var DecodedFrameSchema = object({
6796
- data: _instanceof(Uint8Array),
6797
- width: number(),
6798
- height: number(),
6799
- format: _enum([
6800
- "jpeg",
6801
- "rgb",
6802
- "bgr",
6803
- "yuv420",
6804
- "gray"
6805
- ]),
6806
- timestamp: number()
6807
- });
6808
6778
  /**
6809
6779
  * Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
6810
6780
  * frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
6811
- * interface in `interfaces/frame-handle.ts` field-for-field so a decoder cap
6812
- * method (`pullHandles`) can carry handles over tRPC / Moleculer.
6781
+ * interface in `interfaces/frame-handle.ts` field-for-field so a cap method
6782
+ * (the runner's native-crop and pipeline-executor inputs) can carry handles
6783
+ * over tRPC / Moleculer.
6813
6784
  *
6814
6785
  * The `satisfies` assertion below pins this schema to the interface: if a
6815
6786
  * field is added to / removed from `FrameHandle` without a matching schema
@@ -6835,50 +6806,6 @@ var FrameHandleSchema = object({
6835
6806
  slotCount: number().int().positive()
6836
6807
  });
6837
6808
  /**
6838
- * Pixel format a frame-handle subscriber can request from the broker
6839
- * (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
6840
- * `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
6841
- * `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
6842
- * payload, and no decoded-frame consumer requests it over the shm plane.
6843
- */
6844
- var FrameHandleFormatSchema = _enum([
6845
- "rgb",
6846
- "bgr",
6847
- "yuv420",
6848
- "gray"
6849
- ]);
6850
- /**
6851
- * Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
6852
- * broker for a `FrameHandle` stream of one `format`; the broker maintains one
6853
- * shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
6854
- * subscriber (motion) and an `rgb` subscriber (detection) each read the format
6855
- * they asked for with no broker-side conversion.
6856
- */
6857
- var SubscribeFramesInputSchema = object({
6858
- brokerId: string(),
6859
- format: FrameHandleFormatSchema,
6860
- /**
6861
- * Optional reader-side cadence hint in frames per second. The broker does
6862
- * NOT throttle — latest-wins ring reads drop frames implicitly for a slow
6863
- * consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
6864
- * the consumer can pace its own `pullFrameHandles` polling.
6865
- */
6866
- maxFps: number().positive().optional(),
6867
- /** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
6868
- tag: string().optional()
6869
- });
6870
- /**
6871
- * Result of `stream-broker.subscribeFrames`. The consumer then polls
6872
- * `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
6873
- * `FrameHandle` to a `FrameRingReader`.
6874
- */
6875
- var SubscribeFramesResultSchema = object({
6876
- /** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
6877
- subscriptionId: string(),
6878
- /** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
6879
- maxFps: number().nonnegative()
6880
- });
6881
- /**
6882
6809
  * Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
6883
6810
  * `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
6884
6811
  * sample bytes plus the track parameters a consumer needs to interpret them.
@@ -6886,8 +6813,8 @@ var SubscribeFramesResultSchema = object({
6886
6813
  * Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
6887
6814
  * Float32 PCM), so unlike video frames they ship their bytes INLINE over
6888
6815
  * tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
6889
- * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
6890
- * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
6816
+ * (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
6817
+ * it.
6891
6818
  */
6892
6819
  var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
6893
6820
  var DecodedAudioChunkSchema = object({
@@ -6905,11 +6832,10 @@ var DecodedAudioChunkSchema = object({
6905
6832
  format: AudioChunkFormatSchema.optional()
6906
6833
  });
6907
6834
  /**
6908
- * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
6909
- * handle-free, ship-bytes-inline analogue of `subscribeFrames`: a consumer
6910
- * asks the broker for the decoded audio-chunk stream of one broker; the
6911
- * broker keeps a per-subscription bounded FIFO queue the consumer drains via
6912
- * `pullAudioChunks`.
6835
+ * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
6836
+ * its bytes inline: a consumer asks the broker for the decoded audio-chunk
6837
+ * stream of one broker; the broker keeps a per-subscription bounded FIFO queue
6838
+ * the consumer drains via `pullAudioChunks`.
6913
6839
  */
6914
6840
  var SubscribeAudioChunksInputSchema = object({
6915
6841
  brokerId: string(),
@@ -6940,9 +6866,7 @@ var BrokerStatsSchema = object({
6940
6866
  "stopped"
6941
6867
  ]),
6942
6868
  inputFps: number(),
6943
- decodeFps: number(),
6944
6869
  encodedSubscribers: number(),
6945
- decodedSubscribers: number(),
6946
6870
  uptimeMs: number(),
6947
6871
  bitrateKbps: number(),
6948
6872
  idrIntervalMs: number(),
@@ -6955,14 +6879,6 @@ var BrokerStatsSchema = object({
6955
6879
  preBufferMs: number(),
6956
6880
  preBufferPackets: number(),
6957
6881
  /**
6958
- * Moleculer node id of the decoder provider currently servicing this
6959
- * stream's decoded subscribers. `null` until the deferred decoder is
6960
- * created (no decoded clients yet, or codec not detected). Surfaces the
6961
- * runtime decoder placement so the UI can show "Decoder: <agent>" without
6962
- * a separate cap call per broker.
6963
- */
6964
- decoderNodeId: string().nullable(),
6965
- /**
6966
6882
  * Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
6967
6883
  * when the stream has no audio track or the broker is in cold start.
6968
6884
  * `supported = false` means the codec was detected but the local
@@ -11084,70 +11000,6 @@ var StorageLocationDeclarationSchema = object({
11084
11000
  "backup"
11085
11001
  ]).optional()
11086
11002
  });
11087
- var DecoderStatsSchema = object({
11088
- inputFps: number(),
11089
- outputFps: number(),
11090
- avgDecodeTimeMs: number(),
11091
- droppedFrames: number(),
11092
- /**
11093
- * Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
11094
- * lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
11095
- * the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
11096
- * is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
11097
- */
11098
- lagMs: number().optional(),
11099
- effectiveFps: number().optional(),
11100
- adaptiveFps: number().optional()
11101
- });
11102
- var DecoderSessionConfigSchema = object({
11103
- codec: string(),
11104
- maxFps: number().default(0),
11105
- outputFormat: _enum([
11106
- "jpeg",
11107
- "rgb",
11108
- "bgr",
11109
- "yuv420",
11110
- "gray"
11111
- ]).default("jpeg"),
11112
- scale: number().default(1),
11113
- width: number().optional(),
11114
- height: number().optional(),
11115
- /**
11116
- * Identifier of the camera this decoder session serves. Optional
11117
- * because the cap is generic (any caller could request decode), but
11118
- * stream-broker passes it so decoder logs include `deviceId` for
11119
- * per-camera filtering when diagnosing failures (e.g. node-av
11120
- * sendPacket errors on a single hung camera).
11121
- */
11122
- deviceId: number().int().nonnegative().optional(),
11123
- /**
11124
- * Free-form tag for log scoping. Stream-broker uses
11125
- * `broker:<deviceId>/<profile>`. Decoder session logger surfaces it
11126
- * on every line so `grep tag=broker:5/high` filters one camera
11127
- * profile cleanly.
11128
- */
11129
- tag: string().optional(),
11130
- /**
11131
- * Where the session delivers decoded frames (Phase 5 / D9):
11132
- *
11133
- * - `'callback'` (default) — the legacy pixel path: decoded frames are
11134
- * buffered as `DecodedFrame`s and drained via `pullFrames`.
11135
- * - `'shm'` — the shared-memory frame plane: decoded frames are written
11136
- * into an OS shared-memory ring and drained as zero-pixel
11137
- * `FrameHandle`s via `pullHandles`. A session is one mode or the
11138
- * other — `pullFrames` returns nothing for an `'shm'` session and
11139
- * `pullHandles` returns nothing for a `'callback'` session.
11140
- */
11141
- frameSink: _enum(["callback", "shm"]).default("callback"),
11142
- /**
11143
- * Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
11144
- * a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
11145
- * real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
11146
- * stream-broker's `streamingDebug` gate — off by default so production logs
11147
- * stay quiet and the emit path pays zero per-frame cost when disabled.
11148
- */
11149
- debug: boolean().optional()
11150
- });
11151
11003
  /**
11152
11004
  * Per-component log CHANNELS — the gate a hot path consults, and the registry
11153
11005
  * an addon declares its channels in.
@@ -11386,7 +11238,18 @@ var LABEL_SUPPLY_STEP_IDS = [
11386
11238
  ];
11387
11239
  /** Steps whose box a root detection can BE. */
11388
11240
  var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
11389
- [...LABEL_SUPPLY_STEP_IDS, ...CROP_SUPPLY_STEP_IDS];
11241
+ /**
11242
+ * Steps whose per-detection MASK a root detection can carry (D737). The live
11243
+ * mask step is `segmentation` — a frame-plane refiner that runs its own model
11244
+ * once per detection crop. (`instance-segmentation` is a dormant step id that
11245
+ * no camera tree carries.)
11246
+ */
11247
+ var MASK_SUPPLY_STEP_IDS = ["segmentation"];
11248
+ [
11249
+ ...LABEL_SUPPLY_STEP_IDS,
11250
+ ...CROP_SUPPLY_STEP_IDS,
11251
+ ...MASK_SUPPLY_STEP_IDS
11252
+ ];
11390
11253
  var MODEL_FORMATS = [
11391
11254
  "onnx",
11392
11255
  "coreml",
@@ -11415,7 +11278,53 @@ var ModelFormatEntrySchema = object({
11415
11278
  /** Multi-file payload (directory members or sibling files). */
11416
11279
  files: array(string()).readonly().optional(),
11417
11280
  /** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
11418
- runtimes: array(_enum(["python"])).readonly().optional()
11281
+ runtimes: array(_enum(["python"])).readonly().optional(),
11282
+ /**
11283
+ * Content revision of the artefact, for one hosted OFF the CamStack mirror.
11284
+ * A format on the mirror leaves it unset: its revision (the sha256 of its
11285
+ * weight file) comes from the downloader's generated table, kept in step
11286
+ * with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
11287
+ * node records the revision it downloaded next to the file
11288
+ * (`<file>.revision`); a copy with no record or a different one is stale
11289
+ * unless its weight file hashes to the revision, and a stale copy is
11290
+ * downloaded again, the old one serving until the new one is complete. No
11291
+ * revision at all ⇒ a file on disk is current, whatever it holds (D743).
11292
+ */
11293
+ revision: string().min(1).optional()
11294
+ });
11295
+ /**
11296
+ * What a node holds for one (model, format) (D746). `current` is a complete
11297
+ * copy at its catalog revision — exactly what `downloaded: true` means.
11298
+ * `stale` is bytes on disk that are not (yet) proven current under D743/D744:
11299
+ * no or a different revision record, or a missing sibling. `missing` is no
11300
+ * copy. `downloaded` alone folds `stale` into "not downloaded", which hid
11301
+ * reclaimable bytes and a copy about to be replaced.
11302
+ */
11303
+ var ModelOnDiskStateSchema = _enum([
11304
+ "current",
11305
+ "stale",
11306
+ "missing"
11307
+ ]);
11308
+ /**
11309
+ * The numeric precision of one format's BUILD (D746) — reported only when the
11310
+ * build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
11311
+ * CamStack Core ML export). Absent means "not stated", never "fp32".
11312
+ */
11313
+ var ModelFormatPrecisionSchema = _enum([
11314
+ "fp32",
11315
+ "fp16",
11316
+ "int8"
11317
+ ]);
11318
+ /**
11319
+ * One format of one model as a node's `pipelineExecutor.getSchema` reports it.
11320
+ * `onDisk` / `precision` are optional for version skew: a runner that predates
11321
+ * them omits them, and a reader falls back to `downloaded`.
11322
+ */
11323
+ var PipelineModelFormatStatusSchema = object({
11324
+ downloaded: boolean(),
11325
+ sizeMB: number(),
11326
+ onDisk: ModelOnDiskStateSchema.optional(),
11327
+ precision: ModelFormatPrecisionSchema.optional()
11419
11328
  });
11420
11329
  /**
11421
11330
  * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
@@ -11529,25 +11438,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
11529
11438
  * - `crop`: the root draws the box the step would have found (`license_plate`
11530
11439
  * for plate-detection, `face` for face-detection). The box becomes a detail
11531
11440
  * child of the `parentMacro` detection that contains it — never a track.
11441
+ * - `mask`: the root's decode emits an instance mask with every detection (a
11442
+ * YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
11443
+ * detection in the shape that step produces. Derived from the model's
11444
+ * postprocessor on read, never stored by an import.
11532
11445
  */
11533
- var RootStepSupplySchema = discriminatedUnion("kind", [object({
11534
- kind: literal("label"),
11535
- stepId: _enum(LABEL_SUPPLY_STEP_IDS),
11536
- labelToEffect: record(string(), string()),
11537
- uncovered: array(string()).readonly()
11538
- }), object({
11539
- kind: literal("crop"),
11540
- stepId: _enum(CROP_SUPPLY_STEP_IDS),
11541
- rootLabels: array(string()).readonly(),
11542
- parentMacro: _enum(["vehicle", "person"]),
11543
- childClass: _enum(["plate", "face"]),
11544
- /**
11545
- * The root's smaller input side, stamped on read by `rootSuppliesOf` from
11546
- * the model entry — what a step's `minRootInputPx` gate judges. Never
11547
- * stored by an import.
11548
- */
11549
- rootInputPx: number().int().positive().optional()
11550
- })]);
11446
+ var RootStepSupplySchema = discriminatedUnion("kind", [
11447
+ object({
11448
+ kind: literal("label"),
11449
+ stepId: _enum(LABEL_SUPPLY_STEP_IDS),
11450
+ labelToEffect: record(string(), string()),
11451
+ uncovered: array(string()).readonly()
11452
+ }),
11453
+ object({
11454
+ kind: literal("crop"),
11455
+ stepId: _enum(CROP_SUPPLY_STEP_IDS),
11456
+ rootLabels: array(string()).readonly(),
11457
+ parentMacro: _enum(["vehicle", "person"]),
11458
+ childClass: _enum(["plate", "face"]),
11459
+ /**
11460
+ * The root's smaller input side, stamped on read by `rootSuppliesOf` from
11461
+ * the model entry — what a step's `minRootInputPx` gate judges. Never
11462
+ * stored by an import.
11463
+ */
11464
+ rootInputPx: number().int().positive().optional()
11465
+ }),
11466
+ object({
11467
+ kind: literal("mask"),
11468
+ stepId: _enum(MASK_SUPPLY_STEP_IDS)
11469
+ })
11470
+ ]);
11551
11471
  var ModelCatalogEntrySchema = object({
11552
11472
  id: string(),
11553
11473
  name: string(),
@@ -11613,6 +11533,35 @@ var ModelCatalogEntrySchema = object({
11613
11533
  */
11614
11534
  defaultConfidence: number().min(0).max(1).optional(),
11615
11535
  /**
11536
+ * Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
11537
+ * on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
11538
+ * absent here runs at the step slider's global default. The same row shape
11539
+ * the floor measurement produces (`model-floors.json`: modelId → floors), so
11540
+ * a measured table is copied in as-is. An operator override is bound to the
11541
+ * model it was made for and does not survive a model change (D738). A custom
11542
+ * / imported model may declare it; without it, the global defaults apply.
11543
+ */
11544
+ defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
11545
+ /**
11546
+ * The inference precision this model's OpenVINO IR needs on an Intel GPU.
11547
+ * Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
11548
+ * that produces invalid output at f16 — measured 2026-10-07 for YOLO26
11549
+ * base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
11550
+ * scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
11551
+ * `PoolModelConfig.gpuInferencePrecision`; the pool sets
11552
+ * INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
11553
+ */
11554
+ gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
11555
+ /**
11556
+ * ROOT detectors only: per supplied step (`animal-classifier`, …), the
11557
+ * minimum DETECTION score from which this root's own fine label (species,
11558
+ * vehicle type — D736 root supply) is taken (D741). Below it the detection
11559
+ * keeps its macro class without the fine label. `1` = never take it from
11560
+ * this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
11561
+ * `minConfidence` slider, bound to the ROOT model, overrides it.
11562
+ */
11563
+ suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
11564
+ /**
11616
11565
  * When true, the executor produces a landmark-aligned crop (similarity warp
11617
11566
  * onto the canonical template) before this step runs, instead of a plain
11618
11567
  * axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
@@ -13285,13 +13234,6 @@ var BrokerRtspClientSchema = object({
13285
13234
  lastRtpAt: number(),
13286
13235
  bytesSent: number()
13287
13236
  });
13288
- var BrokerDecodedClientSchema = object({
13289
- tag: string(),
13290
- subscribedAt: number(),
13291
- maxFps: number(),
13292
- framesDelivered: number(),
13293
- framesDropped: number()
13294
- });
13295
13237
  var BrokerAudioClientSchema = object({
13296
13238
  tag: string(),
13297
13239
  subscribedAt: number(),
@@ -13383,7 +13325,6 @@ var BrokerEncodedClientSchema = object({
13383
13325
  });
13384
13326
  var BrokerClientsSchema = object({
13385
13327
  rtsp: array(BrokerRtspClientSchema).readonly(),
13386
- decoded: array(BrokerDecodedClientSchema).readonly(),
13387
13328
  audio: array(BrokerAudioClientSchema).readonly(),
13388
13329
  encoded: array(BrokerEncodedClientSchema).readonly(),
13389
13330
  pipeClients: number(),
@@ -13752,11 +13693,7 @@ method(object({
13752
13693
  auth: "admin"
13753
13694
  }), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
13754
13695
  brokerId: string(),
13755
- channel: _enum([
13756
- "rtsp",
13757
- "decoded",
13758
- "audio"
13759
- ]),
13696
+ channel: _enum(["rtsp", "audio"]),
13760
13697
  handle: string()
13761
13698
  }), object({ killed: boolean() }), {
13762
13699
  kind: "mutation",
@@ -13791,10 +13728,7 @@ method(object({
13791
13728
  }), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
13792
13729
  subscriptionId: string(),
13793
13730
  maxCount: number().int().positive().default(8)
13794
- }), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(SubscribeFramesInputSchema, SubscribeFramesResultSchema, { kind: "mutation" }), method(object({
13795
- subscriptionId: string(),
13796
- maxCount: number().int().positive().default(4)
13797
- }), array(FrameHandleSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
13731
+ }), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
13798
13732
  brokerId: string(),
13799
13733
  seconds: number().min(0).max(30)
13800
13734
  }), _void(), {
@@ -15007,54 +14941,12 @@ var HWACCEL_OPTIONS = [
15007
14941
  label: "DRM (Linux generic)"
15008
14942
  }
15009
14943
  ];
15010
- /**
15011
- * shm ring usage stats for a `frameSink: 'shm'` decoder session —
15012
- * exposed via `decoder.getShmStats` so downstream consumers can
15013
- * observe ring pressure (slot count, byte budget, hit/miss ratio).
15014
- */
15015
- var ShmRingStatsSchema = object({
15016
- sessionId: string(),
15017
- slotCount: number().int(),
15018
- slotByteLength: number().int(),
15019
- segmentBytes: number().int(),
15020
- budgetMb: number().int(),
15021
- framesWritten: number().int(),
15022
- getFrameHits: number().int(),
15023
- getFrameMisses: number().int()
15024
- });
15025
- method(object({ codec: string() }), boolean()), method(_void(), object({
14944
+ method(_void(), object({
15026
14945
  id: string(),
15027
14946
  name: string(),
15028
- isPullMode: boolean().optional(),
15029
- priority: number().optional(),
15030
14947
  hwaccel: string().optional(),
15031
14948
  probedBestHwaccel: string().optional()
15032
- })), method(DecoderSessionConfigSchema, object({
15033
- sessionId: string(),
15034
- nodeId: string()
15035
- })), method(object({ sessionId: string() }), _void()), method(object({
15036
- sessionId: string(),
15037
- packet: EncodedPacketSchema
15038
- }), _void()), method(object({
15039
- sessionId: string(),
15040
- url: string()
15041
- }), _void()), method(object({
15042
- sessionId: string(),
15043
- maxCount: number().default(1),
15044
- waitMs: number().optional()
15045
- }), array(DecodedFrameSchema)), method(object({
15046
- sessionId: string(),
15047
- maxCount: number().default(1),
15048
- waitMs: number().optional()
15049
- }), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
15050
- sessionId: string(),
15051
- config: DecoderSessionConfigSchema.partial()
15052
- }), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
15053
- sessionId: string(),
15054
- codec: string(),
15055
- outputFormat: string(),
15056
- createdAtMs: number()
15057
- })).readonly()), method(_void(), object({ backend: string() }), {
14949
+ })), method(_void(), object({ backend: string() }), {
15058
14950
  kind: "mutation",
15059
14951
  auth: "admin"
15060
14952
  });
@@ -16923,6 +16815,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
16923
16815
  kind: "mutation",
16924
16816
  auth: "admin"
16925
16817
  });
16818
+ var HUB_ADDRESS_ROLES = [
16819
+ "appConnections",
16820
+ "notificationTaps",
16821
+ "internal",
16822
+ "publicEndpoint"
16823
+ ];
16926
16824
  /**
16927
16825
  * Transport bounds for AI capability methods.
16928
16826
  *
@@ -21094,7 +20992,13 @@ var NcAlarmModeDelaysListSchema = array(object({
21094
20992
  * Absent = false (logged, not sent). Even when true it is not sent when that same sensor
21095
20993
  * is the one that starts the entry delay — the entry-delay notification already names it.
21096
20994
  */
21097
- notifySensorRewatched: boolean().optional()
20995
+ notifySensorRewatched: boolean().optional(),
20996
+ /**
20997
+ * D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
20998
+ * change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
20999
+ * re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
21000
+ */
21001
+ notifySensorIgnored: boolean().optional()
21098
21002
  })).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
21099
21003
  var NcAlarmModeDelaysEditListSchema = array(object({
21100
21004
  mode: AlarmArmModeSchema,
@@ -21107,7 +21011,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
21107
21011
  /** D706: set the switch, or `null` to clear it (back to the default, false). */
21108
21012
  notifyDuringEntryDelay: boolean().nullable().optional(),
21109
21013
  /** D706: set the switch, or `null` to clear it (back to the default, false). */
21110
- notifySensorRewatched: boolean().nullable().optional()
21014
+ notifySensorRewatched: boolean().nullable().optional(),
21015
+ /** D735: set the switch, or `null` to clear it (back to the default, false). */
21016
+ notifySensorIgnored: boolean().nullable().optional()
21111
21017
  })).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
21112
21018
  /** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
21113
21019
  var NcAlarmNonBlockingEditSchema = object({
@@ -22085,8 +21991,8 @@ Object.freeze(Object.fromEntries([{
22085
21991
  var CLUSTER_STEP_SETTING_FIELDS = [{
22086
21992
  stepId: "face-embedding",
22087
21993
  key: "minLandmarkFaceSize",
22088
- label: "Min face size for recognition (detection px)",
22089
- 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.",
21994
+ label: "Min face size to embed (detection-frame px)",
21995
+ 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.",
22090
21996
  type: "slider",
22091
21997
  min: 0,
22092
21998
  max: 64,
@@ -24081,7 +23987,7 @@ var FrameRefSchema = object({
24081
23987
  timestamp: number(),
24082
23988
  capturedAt: number().optional()
24083
23989
  });
24084
- var ModelFormatSchema$1 = _enum([
23990
+ var ModelFormatSchema$2 = _enum([
24085
23991
  "onnx",
24086
23992
  "coreml",
24087
23993
  "openvino",
@@ -24099,7 +24005,7 @@ var PipelineSlotSchema = _enum([
24099
24005
  var PipelineEngineChoiceSchema = object({
24100
24006
  runtime: literal("python"),
24101
24007
  backend: string(),
24102
- format: ModelFormatSchema$1,
24008
+ format: ModelFormatSchema$2,
24103
24009
  device: string().optional()
24104
24010
  });
24105
24011
  /**
@@ -24138,28 +24044,10 @@ var PipelineDefaultStepSchema = lazy(() => object({
24138
24044
  group: string().optional(),
24139
24045
  settings: record(string(), unknown()).optional()
24140
24046
  }));
24141
- var PipelineTemplateStepSchema = lazy(() => object({
24142
- addonId: string(),
24143
- enabled: boolean(),
24144
- modelId: string(),
24145
- children: array(PipelineTemplateStepSchema).readonly(),
24146
- settings: record(string(), unknown()).optional()
24147
- }));
24148
- var PipelineTemplateSchema$1 = object({
24149
- id: string(),
24150
- name: string(),
24151
- createdAt: string(),
24152
- updatedAt: string(),
24153
- engine: PipelineEngineChoiceSchema,
24154
- steps: array(PipelineTemplateStepSchema).readonly()
24155
- });
24156
24047
  var PipelineModelOptionSchema = object({
24157
24048
  id: string(),
24158
24049
  name: string(),
24159
- formats: record(string(), object({
24160
- downloaded: boolean(),
24161
- sizeMB: number()
24162
- })),
24050
+ formats: record(string(), PipelineModelFormatStatusSchema),
24163
24051
  group: ModelVariantGroupSchema.optional(),
24164
24052
  legacy: boolean().optional(),
24165
24053
  provider: ModelProviderIdSchema.optional(),
@@ -24326,6 +24214,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24326
24214
  }), {
24327
24215
  kind: "mutation",
24328
24216
  auth: "admin"
24217
+ }), method(object({
24218
+ nodeId: string(),
24219
+ deviceIds: array(number()).readonly().optional(),
24220
+ dryRun: boolean()
24221
+ }), object({
24222
+ entries: array(object({
24223
+ deviceId: number(),
24224
+ keys: array(string()).readonly()
24225
+ })).readonly(),
24226
+ refused: array(object({
24227
+ deviceId: number(),
24228
+ reason: string()
24229
+ })).readonly()
24230
+ }), {
24231
+ kind: "mutation",
24232
+ auth: "admin"
24329
24233
  }), method(object({ nodeId: string() }), object({ unhealthy: array(object({
24330
24234
  /** `<backend>:<device>`, e.g. `openvino:gpu`. */
24331
24235
  deviceKey: string(),
@@ -24351,22 +24255,14 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24351
24255
  }), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
24352
24256
  steps: array(PipelineStepInputSchema),
24353
24257
  deviceKey: string().optional()
24354
- }), PipelineValidationResultSchema), method(_void(), array(PipelineTemplateSchema$1).readonly()), method(object({
24355
- name: string(),
24356
- steps: array(PipelineTemplateStepSchema).readonly(),
24357
- engine: PipelineEngineChoiceSchema
24358
- }), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
24359
- id: string(),
24360
- name: string().optional(),
24361
- steps: array(PipelineTemplateStepSchema).readonly().optional()
24362
- }), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
24258
+ }), PipelineValidationResultSchema), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
24363
24259
  addonId: string(),
24364
24260
  modelId: string(),
24365
- format: ModelFormatSchema$1
24261
+ format: ModelFormatSchema$2
24366
24262
  }), DownloadModelResultSchema, { kind: "mutation" }), method(object({
24367
24263
  addonId: string(),
24368
24264
  modelId: string(),
24369
- format: ModelFormatSchema$1
24265
+ format: ModelFormatSchema$2
24370
24266
  }), object({ success: literal(true) }), { kind: "mutation" }), method(object({
24371
24267
  steps: array(PipelineStepInputSchema).min(1),
24372
24268
  frame: FrameInputSchema.optional(),
@@ -24523,6 +24419,375 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
24523
24419
  filename: string().optional(),
24524
24420
  settings: record(string(), unknown()).optional()
24525
24421
  }), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
24422
+ /**
24423
+ * The wire shapes of the Auto tune plan and apply (D745), used by the
24424
+ * `pipeline-orchestrator` cap. The recommender's own types
24425
+ * (`recommend.ts`) are the TS face of the same data; these
24426
+ * schemas are what crosses the cap boundary.
24427
+ */
24428
+ var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
24429
+ /** The operator's range for it. */
24430
+ var MIN_SESSIONS_PER_DEVICE_RANGE = {
24431
+ min: 1,
24432
+ max: 8
24433
+ };
24434
+ var HardwareClassIdSchema = _enum([
24435
+ "intel-core-ultra",
24436
+ "intel-n-series",
24437
+ "apple-m-base",
24438
+ "apple-m-pro",
24439
+ "unknown"
24440
+ ]);
24441
+ var AcceleratorKindSchema = _enum([
24442
+ "intel-npu",
24443
+ "intel-igpu",
24444
+ "x86-cpu",
24445
+ "arm-cpu",
24446
+ "apple-ane",
24447
+ "coral"
24448
+ ]);
24449
+ var RecommendationReasonSchema = discriminatedUnion("kind", [
24450
+ object({
24451
+ kind: literal("capacity"),
24452
+ sessions: number(),
24453
+ minSessions: number()
24454
+ }),
24455
+ object({
24456
+ kind: literal("tie-faster"),
24457
+ over: string(),
24458
+ recallDelta: number()
24459
+ }),
24460
+ object({
24461
+ kind: literal("stepped-down"),
24462
+ from: string(),
24463
+ to: string(),
24464
+ limitedBy: string()
24465
+ }),
24466
+ object({
24467
+ kind: literal("no-fit-lightest"),
24468
+ sessions: number(),
24469
+ minSessions: number()
24470
+ }),
24471
+ object({
24472
+ kind: literal("derived-latency"),
24473
+ modelId: string()
24474
+ }),
24475
+ object({ kind: literal("cpu-device") }),
24476
+ object({ kind: literal("coral-untouched") }),
24477
+ object({ kind: literal("device-disabled") }),
24478
+ object({ kind: literal("device-unavailable") }),
24479
+ object({ kind: literal("node-offline") }),
24480
+ object({ kind: literal("no-hardware-facts") }),
24481
+ object({
24482
+ kind: literal("no-measured-data"),
24483
+ hardwareClass: HardwareClassIdSchema
24484
+ }),
24485
+ object({
24486
+ kind: literal("no-family-build"),
24487
+ format: ModelFormatSchema$1
24488
+ })
24489
+ ]);
24490
+ var DeviceModelChoiceSchema = object({
24491
+ modelId: string(),
24492
+ p50Ms: number(),
24493
+ fps: number(),
24494
+ measured: boolean(),
24495
+ /** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
24496
+ capacitySessions: number(),
24497
+ personRecall: number()
24498
+ });
24499
+ var DeviceRecommendationSchema = object({
24500
+ deviceKey: string(),
24501
+ accelerator: AcceleratorKindSchema.nullable(),
24502
+ enabled: boolean(),
24503
+ available: boolean(),
24504
+ chosen: DeviceModelChoiceSchema.nullable(),
24505
+ reasons: array(RecommendationReasonSchema).readonly()
24506
+ });
24507
+ var NodeRecommendationSchema = object({
24508
+ nodeId: string(),
24509
+ reachable: boolean(),
24510
+ hardwareClass: HardwareClassIdSchema.nullable(),
24511
+ cpuModel: string().nullable(),
24512
+ skipped: boolean(),
24513
+ acceleratorModelId: string().nullable(),
24514
+ devices: array(DeviceRecommendationSchema).readonly(),
24515
+ reasons: array(RecommendationReasonSchema).readonly()
24516
+ });
24517
+ var ModelPinChangeSchema = object({
24518
+ stepId: string(),
24519
+ before: string().nullable(),
24520
+ after: string().nullable()
24521
+ });
24522
+ var NodeDeviceChangeSchema = object({
24523
+ nodeId: string(),
24524
+ deviceKey: string(),
24525
+ madeExplicit: boolean(),
24526
+ modelPins: array(ModelPinChangeSchema).readonly(),
24527
+ thresholds: array(object({
24528
+ stepId: string(),
24529
+ keys: array(string()).readonly()
24530
+ })).readonly()
24531
+ });
24532
+ var CameraOverrideClearSchema = object({
24533
+ deviceId: number(),
24534
+ source: _enum(["step-override", "wholesale"]),
24535
+ nodeId: string(),
24536
+ deviceKey: string().nullable(),
24537
+ stepId: string(),
24538
+ modelIdBefore: string().nullable(),
24539
+ keys: array(string()).readonly()
24540
+ });
24541
+ var DetectorStoreClearSchema = object({
24542
+ deviceId: number(),
24543
+ keys: array(string()).readonly()
24544
+ });
24545
+ var AutoTuneWarningSchema = discriminatedUnion("kind", [
24546
+ object({
24547
+ kind: literal("detector-store-cluster-wide"),
24548
+ skippedNodes: array(string()).readonly()
24549
+ }),
24550
+ object({
24551
+ kind: literal("detector-store-unreadable"),
24552
+ error: string()
24553
+ }),
24554
+ object({
24555
+ kind: literal("coral-enabled"),
24556
+ nodeId: string(),
24557
+ deviceKey: string()
24558
+ })
24559
+ ]);
24560
+ var AutoTuneOptionsSchema = object({
24561
+ /** Share of each accelerator's throughput kept free (0.3–0.5). */
24562
+ headroom: number().min(.3).max(.5).default(.4),
24563
+ /**
24564
+ * The least number of parallel sessions every device must sustain at the
24565
+ * camera rate with the headroom kept free (D755). The most accurate model
24566
+ * that reaches it wins.
24567
+ */
24568
+ minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
24569
+ });
24570
+ var AutoTunePlanSchema = object({
24571
+ /** Hash of everything the apply will write — the apply refuses a different one. */
24572
+ planHash: string(),
24573
+ family: literal("yolov9"),
24574
+ headroom: number(),
24575
+ minSessionsPerDevice: number(),
24576
+ /** The detection rate a session is counted at (the fastest camera running the pipeline root). */
24577
+ cameraFps: number(),
24578
+ generatedAt: number(),
24579
+ nodes: array(NodeRecommendationSchema).readonly(),
24580
+ nodeChanges: array(NodeDeviceChangeSchema).readonly(),
24581
+ cameraClears: array(CameraOverrideClearSchema).readonly(),
24582
+ detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
24583
+ warnings: array(AutoTuneWarningSchema).readonly()
24584
+ });
24585
+ var AutoTuneApplyInputSchema = object({
24586
+ planHash: string(),
24587
+ headroom: number().min(.3).max(.5).default(.4),
24588
+ minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
24589
+ });
24590
+ var AutoTunePhaseResultSchema = object({
24591
+ phase: _enum([
24592
+ "download",
24593
+ "camera-overrides",
24594
+ "detector-thresholds",
24595
+ "node-models",
24596
+ "redispatch"
24597
+ ]),
24598
+ ok: boolean(),
24599
+ detail: string()
24600
+ });
24601
+ var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
24602
+ object({
24603
+ kind: literal("applied"),
24604
+ planHash: string(),
24605
+ phases: array(AutoTunePhaseResultSchema).readonly()
24606
+ }),
24607
+ object({
24608
+ kind: literal("aborted"),
24609
+ phases: array(AutoTunePhaseResultSchema).readonly()
24610
+ }),
24611
+ object({
24612
+ kind: literal("stale"),
24613
+ plan: AutoTunePlanSchema
24614
+ }),
24615
+ object({
24616
+ kind: literal("refused"),
24617
+ reason: _enum(["apply-in-progress"])
24618
+ })
24619
+ ]);
24620
+ /**
24621
+ * Wire shapes of the Load balancing surface (D748): the session placement
24622
+ * policy, the atomic share write, the observed placement statistics, the
24623
+ * hardware share suggestion and the stale device pins.
24624
+ */
24625
+ /**
24626
+ * How a new detection session picks its node and device.
24627
+ * - `least-loaded` — the historical rule: lowest `attached / weight`, a
24628
+ * constant node order at a tie (D37). An idle node always ties at 0, so a
24629
+ * weight only bites once a node already holds a session.
24630
+ * - `share` — the share of PARALLEL sessions is held to the weights, and a
24631
+ * full or drowning node yields to a free one (D748).
24632
+ */
24633
+ var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
24634
+ var LoadBalancingSharesInputSchema = object({
24635
+ /** nodeId → share (> 0). A node left out keeps its weight. */
24636
+ nodes: record(string(), number().positive()).default({}),
24637
+ /** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
24638
+ devices: record(string(), record(string(), number().positive())).default({})
24639
+ });
24640
+ var PlacementStatsInputSchema = object({
24641
+ /** Window the observed shares are averaged over (default 1 h, max 24 h). */
24642
+ windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
24643
+ var PlacementDeviceStatsSchema = object({
24644
+ deviceKey: string(),
24645
+ /** Sessions running on this device now. */
24646
+ sessionsNow: number(),
24647
+ /** Sessions started on this device inside the window. */
24648
+ sessionsStarted: number(),
24649
+ /** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
24650
+ observedShare: number().nullable()
24651
+ });
24652
+ var PlacementNodeStatsSchema = object({
24653
+ nodeId: string(),
24654
+ sessionsNow: number(),
24655
+ sessionsStarted: number(),
24656
+ /** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
24657
+ observedShare: number().nullable(),
24658
+ /** Most sessions this node ran at once inside the window. */
24659
+ peakSessions: number(),
24660
+ /** Sessions a share election handed elsewhere because this node was full or drowning. */
24661
+ yieldsAway: number(),
24662
+ devices: array(PlacementDeviceStatsSchema).readonly()
24663
+ });
24664
+ /** A camera's device pin that the session path cannot honour. */
24665
+ var StaleDevicePinSchema = object({
24666
+ deviceId: number(),
24667
+ deviceKey: string(),
24668
+ /** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
24669
+ reason: _enum(["disabled", "absent"])
24670
+ });
24671
+ var PlacementStatsSchema = object({
24672
+ policy: SessionPlacementPolicySchema,
24673
+ windowMs: number(),
24674
+ /** How much of the window was actually observed (the hub keeps it in memory). */
24675
+ observedForMs: number(),
24676
+ sessionsNow: number(),
24677
+ /** Most parallel sessions across the cluster inside the window. */
24678
+ clusterPeakSessions: number(),
24679
+ nodes: array(PlacementNodeStatsSchema).readonly(),
24680
+ stalePins: array(StaleDevicePinSchema).readonly()
24681
+ });
24682
+ /**
24683
+ * Where an automatic share's capacity comes from (D755).
24684
+ * - `hardware` — the static capacity of each device at its Auto tune model:
24685
+ * the measured latency table for the node's hardware class.
24686
+ * - `benchmark` — the node's own measured capacity (node benchmark results).
24687
+ * A node with no results falls back to `hardware`, and says so.
24688
+ */
24689
+ var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
24690
+ /** Why a node under the `benchmark` source was sized from hardware instead. */
24691
+ var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
24692
+ var SuggestSharesInputSchema = object({
24693
+ headroom: number().min(.3).max(.5).default(.4),
24694
+ /** Default `hardware`. */
24695
+ source: CapacitySourceSchema.default("hardware")
24696
+ });
24697
+ var SuggestedDeviceShareSchema = object({
24698
+ deviceKey: string(),
24699
+ /** Share of the node (0–100, rounded). */
24700
+ share: number(),
24701
+ modelId: string().nullable(),
24702
+ /** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
24703
+ fps: number().nullable(),
24704
+ /** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
24705
+ measured: boolean(),
24706
+ /**
24707
+ * Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
24708
+ * or the benchmark's measured max sessions. Never enforced.
24709
+ */
24710
+ suggestedMaxSessions: number().nullable()
24711
+ });
24712
+ var SuggestedNodeShareSchema = object({
24713
+ nodeId: string(),
24714
+ /** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
24715
+ share: number().nullable(),
24716
+ /** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
24717
+ capacitySessions: number(),
24718
+ devices: array(SuggestedDeviceShareSchema).readonly(),
24719
+ skippedReason: string().nullable(),
24720
+ /** What this node's capacity was read from; null when the node is skipped. */
24721
+ capacitySource: CapacitySourceSchema.nullable(),
24722
+ /** Set when the `benchmark` source was asked for and this node used `hardware`. */
24723
+ capacityFallback: CapacityFallbackSchema.nullable()
24724
+ });
24725
+ var SuggestSharesResultSchema = object({
24726
+ headroom: number(),
24727
+ /** The source asked for; each node says what it actually used. */
24728
+ source: CapacitySourceSchema,
24729
+ /** Camera detection rate the capacity is counted in (the fastest camera's fps). */
24730
+ cameraFps: number(),
24731
+ /** The Auto tune capacity floor the models were picked at. */
24732
+ minSessionsPerDevice: number(),
24733
+ nodes: array(SuggestedNodeShareSchema).readonly()
24734
+ });
24735
+ /**
24736
+ * Where the node and device shares come from (D750, D755).
24737
+ * - `hardware` (default) — computed by the system from each node's static
24738
+ * capacity (its accelerators at their Auto tune models, from the measured
24739
+ * latency table), recomputed whenever a node or device joins, leaves, is
24740
+ * switched on or off, or changes model. No load input.
24741
+ * - `benchmark` — the same, from each node's measured capacity (node
24742
+ * benchmark results); a node without results falls back to `hardware`.
24743
+ * - `manual` — the operator's stored sliders.
24744
+ * Either way a node or device that cannot take sessions gives its share to
24745
+ * the others in proportion; the stored values are never rewritten for that.
24746
+ */
24747
+ var ShareSourceSchema = _enum([
24748
+ "hardware",
24749
+ "benchmark",
24750
+ "manual"
24751
+ ]);
24752
+ var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
24753
+ object({
24754
+ nodes: record(string(), number()),
24755
+ devices: record(string(), record(string(), number()))
24756
+ });
24757
+ var EffectiveDeviceShareSchema = object({
24758
+ deviceKey: string(),
24759
+ /** Can take sessions now (enabled, available, can run the root). */
24760
+ eligible: boolean(),
24761
+ /** The share the source assigns, as a percentage of the node's devices. */
24762
+ configuredPct: number(),
24763
+ /** The share actually used, after an ineligible device's share went to the others. */
24764
+ effectivePct: number()
24765
+ });
24766
+ var EffectiveNodeShareSchema = object({
24767
+ nodeId: string(),
24768
+ eligible: boolean(),
24769
+ configuredPct: number(),
24770
+ effectivePct: number(),
24771
+ /** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
24772
+ capacitySource: CapacitySourceSchema.nullable(),
24773
+ /** Automatic `benchmark`: why this node used `hardware` instead. */
24774
+ capacityFallback: CapacityFallbackSchema.nullable(),
24775
+ devices: array(EffectiveDeviceShareSchema).readonly()
24776
+ });
24777
+ var EffectiveSharesSchema = object({
24778
+ source: ShareSourceSchema,
24779
+ policy: SessionPlacementPolicySchema,
24780
+ /** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
24781
+ autoPending: boolean(),
24782
+ /** When the automatic shares were last computed (ms epoch); null = never. */
24783
+ computedAt: number().nullable(),
24784
+ /** What made the system recompute them last. */
24785
+ trigger: string().nullable(),
24786
+ nodes: array(EffectiveNodeShareSchema).readonly(),
24787
+ /** The relative weights the election reads (before eligibility). */
24788
+ nodeWeights: record(string(), number()),
24789
+ deviceWeights: record(string(), record(string(), number()))
24790
+ });
24526
24791
  object({
24527
24792
  activeCameras: number(),
24528
24793
  throttledCameras: number(),
@@ -25400,14 +25665,15 @@ var RunnerLocalLoadSchema = object({
25400
25665
  * Per-inference-device live load (multi-device C4). One entry per deviceKey
25401
25666
  * this runner currently has attached cameras on, so the orchestrator's second
25402
25667
  * `balance()` pass (over a node's devices) weights on real per-pool session
25403
- * counts. Empty on single-device / pre-multi-device runners. `queueDepthTotal`
25404
- * per device is 0 until the pool backlog gets a public accessor (follow-up).
25668
+ * counts. Empty on single-device / pre-multi-device runners. There is no
25669
+ * per-device queue depth: the inference pool's backlog has no accessor, and
25670
+ * a field that always read 0 was removed rather than shown as a measurement
25671
+ * (D762).
25405
25672
  */
25406
25673
  devices: array(object({
25407
25674
  deviceKey: string(),
25408
25675
  backend: string(),
25409
- attachedCameras: number(),
25410
- queueDepthTotal: number()
25676
+ attachedCameras: number()
25411
25677
  })).default([]),
25412
25678
  /** Hardware capability flags reported by this node. */
25413
25679
  hardware: object({
@@ -25621,14 +25887,6 @@ var CameraPipelineConfigSchema = object({
25621
25887
  settings: record(string(), unknown()).readonly().optional()
25622
25888
  }).nullable().optional()
25623
25889
  });
25624
- var PipelineTemplateSchema = object({
25625
- id: string(),
25626
- name: string(),
25627
- description: string().optional(),
25628
- config: CameraPipelineConfigSchema,
25629
- createdAt: string(),
25630
- updatedAt: string()
25631
- });
25632
25890
  var DeviceStepConfigSchema = object({
25633
25891
  modelId: string().optional(),
25634
25892
  settings: record(string(), unknown()).optional(),
@@ -25702,9 +25960,10 @@ var CameraStepOverridePatchSchema = object({
25702
25960
  modelId: string().optional(),
25703
25961
  settings: record(string(), unknown()).readonly().optional()
25704
25962
  });
25963
+ var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
25705
25964
  var CameraPipelineSettingsSchema = object({
25706
- pinnedAgentNodeId: string().optional(),
25707
25965
  stepToggles: record(string(), boolean()).optional(),
25966
+ stepSettings: CameraStepSettingsSchema.optional(),
25708
25967
  stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
25709
25968
  pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
25710
25969
  });
@@ -25737,7 +25996,10 @@ var PipelineAssignmentSchema = object({
25737
25996
  });
25738
25997
  /**
25739
25998
  * Per-agent load summary surfaced to the load balancer + dashboards.
25740
- * Aggregated from each runner's `getLocalLoad` cap call.
25999
+ * Aggregated from each runner's `getLocalLoad` cap call. In the
26000
+ * `getAgentLoad` report, a single-device node's default-pool sessions (no
26001
+ * `deviceKey`) are credited to its one eligible device in `load.devices` —
26002
+ * the default pool IS that device (D745); the balancer's census stays raw.
25741
26003
  */
25742
26004
  var AgentLoadSummarySchema = object({
25743
26005
  nodeId: string(),
@@ -25826,26 +26088,27 @@ var CameraBrokerStatusSchema = object({
25826
26088
  width: number(),
25827
26089
  height: number(),
25828
26090
  subscribers: number(),
25829
- inFps: number(),
25830
- outFps: number()
26091
+ /**
26092
+ * Encoded packets/s the broker receives from the camera. null when the
26093
+ * broker's stats read failed — unknown, never 0 (a 0 here reads as a stall).
26094
+ * There is no output rate: decoding runs in the session decode workers, not
26095
+ * in the broker, so the broker's own decoded-frame rate is 0 on every live
26096
+ * camera and is not served (D758).
26097
+ */
26098
+ inFps: number().nullable()
25831
26099
  })).readonly(),
25832
26100
  webrtcSessions: number(),
25833
26101
  rtspRestream: boolean()
25834
26102
  });
25835
- /** Shared-memory ring statistics within the decoder block. */
25836
- var CameraDecoderShmSchema = object({
25837
- framesWritten: number(),
25838
- getFrameHits: number(),
25839
- getFrameMisses: number(),
25840
- budgetMb: number()
25841
- });
25842
- /** Decoder block — null when the decoder stage is unreachable or inactive. */
25843
- var CameraDecoderStatusSchema = object({
25844
- nodeId: string(),
25845
- formats: array(string()).readonly(),
25846
- sessionCount: number(),
25847
- shm: CameraDecoderShmSchema
25848
- });
26103
+ /**
26104
+ * Decoder block — WHERE decode runs (co-located with the detection node by
26105
+ * construction); null when the camera has no detection node. It carries no
26106
+ * frame counter: the shared-memory plane whose counters it used to serve is
26107
+ * gone, and those fields read 0 forever. Whether frames actually flow is read
26108
+ * from `detection.actualFps` (frames delivered to and processed by the
26109
+ * detector), never from a counter nothing feeds.
26110
+ */
26111
+ var CameraDecoderStatusSchema = object({ nodeId: string() });
25849
26112
  /** Motion block — null when motion detection is not active for this device. */
25850
26113
  var CameraMotionStatusSchema = object({
25851
26114
  enabled: boolean(),
@@ -26202,12 +26465,6 @@ method(object({
26202
26465
  }), object({ success: literal(true) }), {
26203
26466
  kind: "mutation",
26204
26467
  auth: "admin"
26205
- }), method(object({
26206
- agentNodeId: string(),
26207
- detectWeight: number().positive().nullable()
26208
- }), object({ success: literal(true) }), {
26209
- kind: "mutation",
26210
- auth: "admin"
26211
26468
  }), method(object({
26212
26469
  agentNodeId: string(),
26213
26470
  detect: boolean().nullable().optional(),
@@ -26249,6 +26506,15 @@ method(object({
26249
26506
  }), {
26250
26507
  kind: "mutation",
26251
26508
  auth: "admin"
26509
+ }), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
26510
+ kind: "mutation",
26511
+ auth: "admin"
26512
+ }), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
26513
+ kind: "mutation",
26514
+ auth: "admin"
26515
+ }), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
26516
+ kind: "mutation",
26517
+ auth: "admin"
26252
26518
  }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
26253
26519
  deviceId: number(),
26254
26520
  addonId: string(),
@@ -26265,6 +26531,13 @@ method(object({
26265
26531
  }), object({ success: literal(true) }), {
26266
26532
  kind: "mutation",
26267
26533
  auth: "admin"
26534
+ }), method(object({
26535
+ deviceId: number(),
26536
+ addonId: string(),
26537
+ settings: record(string(), unknown()).nullable()
26538
+ }), object({ success: literal(true) }), {
26539
+ kind: "mutation",
26540
+ auth: "admin"
26268
26541
  }), method(object({
26269
26542
  deviceId: number(),
26270
26543
  agentNodeId: string(),
@@ -26288,25 +26561,7 @@ method(object({
26288
26561
  }), method(_void(), DiskReconcileJobSchema, {
26289
26562
  kind: "mutation",
26290
26563
  auth: "admin"
26291
- }), method(_void(), DiskReconcileJobSchema, { auth: "admin" }), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
26292
- name: string(),
26293
- description: string().optional(),
26294
- config: CameraPipelineConfigSchema
26295
- }), PipelineTemplateSchema, {
26296
- kind: "mutation",
26297
- auth: "admin"
26298
- }), method(object({
26299
- id: string(),
26300
- name: string().optional(),
26301
- description: string().optional(),
26302
- config: CameraPipelineConfigSchema.optional()
26303
- }), PipelineTemplateSchema, {
26304
- kind: "mutation",
26305
- auth: "admin"
26306
- }), method(object({ id: string() }), object({ success: literal(true) }), {
26307
- kind: "mutation",
26308
- auth: "admin"
26309
- });
26564
+ }), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
26310
26565
  /**
26311
26566
  * Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
26312
26567
  * `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
@@ -28719,8 +28974,6 @@ var WebrtcStreamChoiceSchema = object({
28719
28974
  ]).nullable(),
28720
28975
  /** Input FPS from the camera (null for adaptive). */
28721
28976
  inputFps: number().nullable(),
28722
- /** Decoded FPS (null for adaptive). */
28723
- decodeFps: number().nullable(),
28724
28977
  /** Bitrate in kbps (null for adaptive). */
28725
28978
  bitrateKbps: number().nullable()
28726
28979
  });
@@ -29052,6 +29305,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
29052
29305
  */
29053
29306
  alive: boolean()
29054
29307
  })), method(object({
29308
+ deviceId: number().int().nonnegative(),
29309
+ sessionId: string(),
29310
+ downlinkMbps: number().nonnegative()
29311
+ }), object({
29312
+ outcome: _enum(["switching", "held"]),
29313
+ tier: CamProfileSchema.nullable(),
29314
+ reason: string()
29315
+ }), { kind: "mutation" }), method(object({
29055
29316
  deviceId: number().int().nonnegative(),
29056
29317
  sessionId: string()
29057
29318
  }), WebrtcSessionDebugSchema, { kind: "query" });
@@ -31763,7 +32024,8 @@ var ConnectionEndpointSchema = object({
31763
32024
  "lan-ipv6",
31764
32025
  "public",
31765
32026
  "loopback",
31766
- "app-link"
32027
+ "app-link",
32028
+ "custom"
31767
32029
  ]),
31768
32030
  /**
31769
32031
  * Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
@@ -31832,7 +32094,7 @@ var GetConnectionEndpointsResultSchema = object({
31832
32094
  localPort: AdvertisedLocalPortSchema
31833
32095
  });
31834
32096
  /**
31835
- * The address flagged for notification links. `baseUrl: null` = AUTO, which
32097
+ * The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
31836
32098
  * since D709 is the CamStack app link; `resolved` reports the effective value,
31837
32099
  * so the UI can show it either way.
31838
32100
  */
@@ -31866,13 +32128,12 @@ var ViewerEndpointsSchema = object({
31866
32128
  resolved: array(string()).readonly()
31867
32129
  });
31868
32130
  /**
31869
- * One audience's hub address (see `hub-address.ts`): the operator's stored
31870
- * override, the address in use, and where it came from.
32131
+ * DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
32132
+ * for addons built against it): `cluster` is the `internal` role, `browser`
32133
+ * the `publicEndpoint` role; `override` is the flagged address.
31871
32134
  */
31872
32135
  var HubAddressSnapshotSchema = object({
31873
- /** The operator's override, or null for automatic. */
31874
32136
  override: string().nullable(),
31875
- /** The address in use, or null when nothing qualifies (never loopback). */
31876
32137
  resolved: string().nullable(),
31877
32138
  source: _enum([
31878
32139
  "override",
@@ -31881,11 +32142,57 @@ var HubAddressSnapshotSchema = object({
31881
32142
  ])
31882
32143
  });
31883
32144
  var HubAddressesSchema = object({
31884
- /** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
31885
32145
  cluster: HubAddressSnapshotSchema,
31886
- /** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
31887
32146
  browser: HubAddressSnapshotSchema
31888
32147
  });
32148
+ /**
32149
+ * What an address is used for (`hub-address.ts`, D734). `appConnections` is
32150
+ * many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
32151
+ * by at most one address.
32152
+ */
32153
+ var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
32154
+ var RoleSourceSchema = _enum([
32155
+ "flagged",
32156
+ "auto",
32157
+ "none"
32158
+ ]);
32159
+ /** One single-valued role: the flagged address, the one in use, and why. */
32160
+ var HubAddressRoleResolutionSchema = object({
32161
+ /** The address carrying the flag, or null = automatic. */
32162
+ flagged: string().nullable(),
32163
+ /** The address in use, or null when nothing qualifies (never loopback). */
32164
+ resolved: string().nullable(),
32165
+ source: RoleSourceSchema
32166
+ });
32167
+ var HubAppConnectionsResolutionSchema = object({
32168
+ /** The addresses flagged `appConnections`, or empty = automatic. */
32169
+ flagged: array(string()).readonly(),
32170
+ /** What the apps race right now. */
32171
+ resolved: array(string()).readonly(),
32172
+ source: RoleSourceSchema
32173
+ });
32174
+ var HubAddressBookSchema = object({
32175
+ rows: array(ConnectionEndpointSchema.extend({
32176
+ /** In the hub's detected palette right now. */
32177
+ detected: boolean(),
32178
+ /** Entered by the operator (removable). */
32179
+ custom: boolean(),
32180
+ /** The roles explicitly flagged on this address. */
32181
+ flags: array(HubAddressRoleSchema).readonly(),
32182
+ /** The roles this address serves right now — flagged or automatic. */
32183
+ inUse: array(HubAddressRoleSchema).readonly(),
32184
+ /** The roles this address may be flagged with. */
32185
+ eligible: array(HubAddressRoleSchema).readonly()
32186
+ })).readonly(),
32187
+ roles: object({
32188
+ appConnections: HubAppConnectionsResolutionSchema,
32189
+ notificationTaps: HubAddressRoleResolutionSchema,
32190
+ internal: HubAddressRoleResolutionSchema,
32191
+ publicEndpoint: HubAddressRoleResolutionSchema
32192
+ }),
32193
+ /** The `hub=` an app link carries (D709), or null. */
32194
+ appLinkHub: string().nullable()
32195
+ });
31889
32196
  var AllowedAddressesSchema = object({
31890
32197
  /**
31891
32198
  * Allowlist of interface addresses operators have explicitly opted
@@ -31929,16 +32236,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
31929
32236
  * tunnel always emits `https://` regardless. */
31930
32237
  scheme: _enum(["http", "https"]).optional(),
31931
32238
  /** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
31932
- * an address notification links can be flagged with, not a hub
32239
+ * an address notification taps can be flagged with, not a hub
31933
32240
  * route. Default `false`: racers and rankers never see it. */
31934
32241
  includeAppLink: boolean().optional()
31935
- }), 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({
31936
- audience: _enum(["cluster", "browser"]),
31937
- baseUrl: string().nullable()
31938
- }), HubAddressesSchema, {
32242
+ }), 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({
32243
+ baseUrl: string(),
32244
+ label: string().max(80)
32245
+ }), HubAddressBookSchema, {
31939
32246
  kind: "mutation",
31940
32247
  auth: "admin"
31941
- }), 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, {
32248
+ }), method(object({ baseUrl: string() }), HubAddressBookSchema, {
32249
+ kind: "mutation",
32250
+ auth: "admin"
32251
+ }), method(object({
32252
+ role: HubAddressRoleSchema,
32253
+ baseUrl: string().nullable(),
32254
+ enabled: boolean(),
32255
+ acceptInsecureHttp: boolean().optional()
32256
+ }), HubAddressBookSchema, {
32257
+ kind: "mutation",
32258
+ auth: "admin"
32259
+ }), 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, {
31942
32260
  kind: "mutation",
31943
32261
  auth: "admin"
31944
32262
  }), method(object({
@@ -37485,6 +37803,16 @@ DeviceType.Camera, method(object({
37485
37803
  package: array(ZoneRuleSchema).readonly()
37486
37804
  });
37487
37805
  SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
37806
+ Object.freeze({
37807
+ person: .5,
37808
+ vehicle: .5,
37809
+ animal: .5
37810
+ });
37811
+ Object.freeze({
37812
+ person: .65,
37813
+ vehicle: .65,
37814
+ animal: .65
37815
+ });
37488
37816
  /**
37489
37817
  * Accessory device helpers — shared across drivers.
37490
37818
  *
@@ -38841,90 +39169,18 @@ Object.freeze({
38841
39169
  addonId: null,
38842
39170
  access: "create"
38843
39171
  },
38844
- "decoder.createSession": {
38845
- capName: "decoder",
38846
- capScope: "system",
38847
- addonId: null,
38848
- access: "view"
38849
- },
38850
- "decoder.destroySession": {
38851
- capName: "decoder",
38852
- capScope: "system",
38853
- addonId: null,
38854
- access: "delete"
38855
- },
38856
- "decoder.getFrame": {
38857
- capName: "decoder",
38858
- capScope: "system",
38859
- addonId: null,
38860
- access: "view"
38861
- },
38862
39172
  "decoder.getInfo": {
38863
39173
  capName: "decoder",
38864
39174
  capScope: "system",
38865
39175
  addonId: null,
38866
39176
  access: "view"
38867
39177
  },
38868
- "decoder.getShmStats": {
38869
- capName: "decoder",
38870
- capScope: "system",
38871
- addonId: null,
38872
- access: "view"
38873
- },
38874
- "decoder.getStats": {
38875
- capName: "decoder",
38876
- capScope: "system",
38877
- addonId: null,
38878
- access: "view"
38879
- },
38880
- "decoder.listActiveSessions": {
38881
- capName: "decoder",
38882
- capScope: "system",
38883
- addonId: null,
38884
- access: "view"
38885
- },
38886
- "decoder.openStream": {
38887
- capName: "decoder",
38888
- capScope: "system",
38889
- addonId: null,
38890
- access: "view"
38891
- },
38892
- "decoder.pullFrames": {
38893
- capName: "decoder",
38894
- capScope: "system",
38895
- addonId: null,
38896
- access: "view"
38897
- },
38898
- "decoder.pullHandles": {
38899
- capName: "decoder",
38900
- capScope: "system",
38901
- addonId: null,
38902
- access: "view"
38903
- },
38904
- "decoder.pushPacket": {
38905
- capName: "decoder",
38906
- capScope: "system",
38907
- addonId: null,
38908
- access: "view"
38909
- },
38910
39178
  "decoder.reprobeHwaccel": {
38911
39179
  capName: "decoder",
38912
39180
  capScope: "system",
38913
39181
  addonId: null,
38914
39182
  access: "create"
38915
39183
  },
38916
- "decoder.supportsCodec": {
38917
- capName: "decoder",
38918
- capScope: "system",
38919
- addonId: null,
38920
- access: "view"
38921
- },
38922
- "decoder.updateConfig": {
38923
- capName: "decoder",
38924
- capScope: "system",
38925
- addonId: null,
38926
- access: "view"
38927
- },
38928
39184
  "detectionPipeline.applyDeviceSettingsPatch": {
38929
39185
  capName: "detection-pipeline",
38930
39186
  capScope: "device",
@@ -40413,12 +40669,24 @@ Object.freeze({
40413
40669
  addonId: null,
40414
40670
  access: "view"
40415
40671
  },
40672
+ "localNetwork.addCustomAddress": {
40673
+ capName: "local-network",
40674
+ capScope: "system",
40675
+ addonId: null,
40676
+ access: "create"
40677
+ },
40416
40678
  "localNetwork.downloadCa": {
40417
40679
  capName: "local-network",
40418
40680
  capScope: "system",
40419
40681
  addonId: null,
40420
40682
  access: "view"
40421
40683
  },
40684
+ "localNetwork.getAddresses": {
40685
+ capName: "local-network",
40686
+ capScope: "system",
40687
+ addonId: null,
40688
+ access: "view"
40689
+ },
40422
40690
  "localNetwork.getAllowedAddresses": {
40423
40691
  capName: "local-network",
40424
40692
  capScope: "system",
@@ -40473,6 +40741,12 @@ Object.freeze({
40473
40741
  addonId: null,
40474
40742
  access: "create"
40475
40743
  },
40744
+ "localNetwork.removeCustomAddress": {
40745
+ capName: "local-network",
40746
+ capScope: "system",
40747
+ addonId: null,
40748
+ access: "delete"
40749
+ },
40476
40750
  "localNetwork.resetAllowlistToBestMatch": {
40477
40751
  capName: "local-network",
40478
40752
  capScope: "system",
@@ -40485,13 +40759,13 @@ Object.freeze({
40485
40759
  addonId: null,
40486
40760
  access: "create"
40487
40761
  },
40488
- "localNetwork.setAllowedAddresses": {
40762
+ "localNetwork.setAddressRole": {
40489
40763
  capName: "local-network",
40490
40764
  capScope: "system",
40491
40765
  addonId: null,
40492
40766
  access: "create"
40493
40767
  },
40494
- "localNetwork.setHubAddress": {
40768
+ "localNetwork.setAllowedAddresses": {
40495
40769
  capName: "local-network",
40496
40770
  capScope: "system",
40497
40771
  addonId: null,
@@ -41985,13 +42259,13 @@ Object.freeze({
41985
42259
  addonId: null,
41986
42260
  access: "delete"
41987
42261
  },
41988
- "pipelineExecutor.deleteModel": {
42262
+ "pipelineExecutor.clearModelBoundDeviceOverrides": {
41989
42263
  capName: "pipeline-executor",
41990
42264
  capScope: "system",
41991
42265
  addonId: null,
41992
42266
  access: "delete"
41993
42267
  },
41994
- "pipelineExecutor.deleteTemplate": {
42268
+ "pipelineExecutor.deleteModel": {
41995
42269
  capName: "pipeline-executor",
41996
42270
  capScope: "system",
41997
42271
  addonId: null,
@@ -42135,12 +42409,6 @@ Object.freeze({
42135
42409
  addonId: null,
42136
42410
  access: "view"
42137
42411
  },
42138
- "pipelineExecutor.listTemplates": {
42139
- capName: "pipeline-executor",
42140
- capScope: "system",
42141
- addonId: null,
42142
- access: "view"
42143
- },
42144
42412
  "pipelineExecutor.rearmInferenceDevice": {
42145
42413
  capName: "pipeline-executor",
42146
42414
  capScope: "system",
@@ -42165,12 +42433,6 @@ Object.freeze({
42165
42433
  addonId: null,
42166
42434
  access: "create"
42167
42435
  },
42168
- "pipelineExecutor.saveTemplate": {
42169
- capName: "pipeline-executor",
42170
- capScope: "system",
42171
- addonId: null,
42172
- access: "create"
42173
- },
42174
42436
  "pipelineExecutor.setVideoPipelineSteps": {
42175
42437
  capName: "pipeline-executor",
42176
42438
  capScope: "system",
@@ -42189,41 +42451,35 @@ Object.freeze({
42189
42451
  addonId: null,
42190
42452
  access: "create"
42191
42453
  },
42192
- "pipelineExecutor.updateTemplate": {
42193
- capName: "pipeline-executor",
42194
- capScope: "system",
42195
- addonId: null,
42196
- access: "create"
42197
- },
42198
42454
  "pipelineExecutor.validatePipeline": {
42199
42455
  capName: "pipeline-executor",
42200
42456
  capScope: "system",
42201
42457
  addonId: null,
42202
42458
  access: "view"
42203
42459
  },
42204
- "pipelineOrchestrator.applyDeviceSettingsPatch": {
42460
+ "pipelineOrchestrator.applyAutoTune": {
42205
42461
  capName: "pipeline-orchestrator",
42206
42462
  capScope: "system",
42207
42463
  addonId: null,
42208
42464
  access: "create"
42209
42465
  },
42210
- "pipelineOrchestrator.assignAudio": {
42466
+ "pipelineOrchestrator.applyDeviceSettingsPatch": {
42211
42467
  capName: "pipeline-orchestrator",
42212
42468
  capScope: "system",
42213
42469
  addonId: null,
42214
42470
  access: "create"
42215
42471
  },
42216
- "pipelineOrchestrator.assignPipeline": {
42472
+ "pipelineOrchestrator.assignAudio": {
42217
42473
  capName: "pipeline-orchestrator",
42218
42474
  capScope: "system",
42219
42475
  addonId: null,
42220
42476
  access: "create"
42221
42477
  },
42222
- "pipelineOrchestrator.deleteTemplate": {
42478
+ "pipelineOrchestrator.assignPipeline": {
42223
42479
  capName: "pipeline-orchestrator",
42224
42480
  capScope: "system",
42225
42481
  addonId: null,
42226
- access: "delete"
42482
+ access: "create"
42227
42483
  },
42228
42484
  "pipelineOrchestrator.getAgentLoad": {
42229
42485
  capName: "pipeline-orchestrator",
@@ -42315,6 +42571,12 @@ Object.freeze({
42315
42571
  addonId: null,
42316
42572
  access: "view"
42317
42573
  },
42574
+ "pipelineOrchestrator.getEffectiveShares": {
42575
+ capName: "pipeline-orchestrator",
42576
+ capScope: "system",
42577
+ addonId: null,
42578
+ access: "view"
42579
+ },
42318
42580
  "pipelineOrchestrator.getGlobalMetrics": {
42319
42581
  capName: "pipeline-orchestrator",
42320
42582
  capScope: "system",
@@ -42351,19 +42613,19 @@ Object.freeze({
42351
42613
  addonId: null,
42352
42614
  access: "view"
42353
42615
  },
42354
- "pipelineOrchestrator.getReconcileFromDiskStatus": {
42616
+ "pipelineOrchestrator.getPlacementStats": {
42355
42617
  capName: "pipeline-orchestrator",
42356
42618
  capScope: "system",
42357
42619
  addonId: null,
42358
42620
  access: "view"
42359
42621
  },
42360
- "pipelineOrchestrator.listAgentSettings": {
42622
+ "pipelineOrchestrator.getReconcileFromDiskStatus": {
42361
42623
  capName: "pipeline-orchestrator",
42362
42624
  capScope: "system",
42363
42625
  addonId: null,
42364
42626
  access: "view"
42365
42627
  },
42366
- "pipelineOrchestrator.listTemplates": {
42628
+ "pipelineOrchestrator.listAgentSettings": {
42367
42629
  capName: "pipeline-orchestrator",
42368
42630
  capScope: "system",
42369
42631
  addonId: null,
@@ -42375,6 +42637,12 @@ Object.freeze({
42375
42637
  addonId: null,
42376
42638
  access: "create"
42377
42639
  },
42640
+ "pipelineOrchestrator.planAutoTune": {
42641
+ capName: "pipeline-orchestrator",
42642
+ capScope: "system",
42643
+ addonId: null,
42644
+ access: "view"
42645
+ },
42378
42646
  "pipelineOrchestrator.rebalance": {
42379
42647
  capName: "pipeline-orchestrator",
42380
42648
  capScope: "system",
@@ -42417,12 +42685,6 @@ Object.freeze({
42417
42685
  addonId: null,
42418
42686
  access: "create"
42419
42687
  },
42420
- "pipelineOrchestrator.saveTemplate": {
42421
- capName: "pipeline-orchestrator",
42422
- capScope: "system",
42423
- addonId: null,
42424
- access: "create"
42425
- },
42426
42688
  "pipelineOrchestrator.setAgentCapabilities": {
42427
42689
  capName: "pipeline-orchestrator",
42428
42690
  capScope: "system",
@@ -42435,12 +42697,6 @@ Object.freeze({
42435
42697
  addonId: null,
42436
42698
  access: "create"
42437
42699
  },
42438
- "pipelineOrchestrator.setAgentDetectWeight": {
42439
- capName: "pipeline-orchestrator",
42440
- capScope: "system",
42441
- addonId: null,
42442
- access: "create"
42443
- },
42444
42700
  "pipelineOrchestrator.setAgentInferenceDevices": {
42445
42701
  capName: "pipeline-orchestrator",
42446
42702
  capScope: "system",
@@ -42477,6 +42733,12 @@ Object.freeze({
42477
42733
  addonId: null,
42478
42734
  access: "create"
42479
42735
  },
42736
+ "pipelineOrchestrator.setCameraStepSettings": {
42737
+ capName: "pipeline-orchestrator",
42738
+ capScope: "system",
42739
+ addonId: null,
42740
+ access: "create"
42741
+ },
42480
42742
  "pipelineOrchestrator.setCameraStepToggle": {
42481
42743
  capName: "pipeline-orchestrator",
42482
42744
  capScope: "system",
@@ -42495,25 +42757,37 @@ Object.freeze({
42495
42757
  addonId: null,
42496
42758
  access: "create"
42497
42759
  },
42760
+ "pipelineOrchestrator.setLoadBalancingShares": {
42761
+ capName: "pipeline-orchestrator",
42762
+ capScope: "system",
42763
+ addonId: null,
42764
+ access: "create"
42765
+ },
42498
42766
  "pipelineOrchestrator.setPipelineDevicePin": {
42499
42767
  capName: "pipeline-orchestrator",
42500
42768
  capScope: "system",
42501
42769
  addonId: null,
42502
42770
  access: "create"
42503
42771
  },
42504
- "pipelineOrchestrator.unassignAudio": {
42772
+ "pipelineOrchestrator.setShareSource": {
42505
42773
  capName: "pipeline-orchestrator",
42506
42774
  capScope: "system",
42507
42775
  addonId: null,
42508
42776
  access: "create"
42509
42777
  },
42510
- "pipelineOrchestrator.unassignPipeline": {
42778
+ "pipelineOrchestrator.suggestShares": {
42779
+ capName: "pipeline-orchestrator",
42780
+ capScope: "system",
42781
+ addonId: null,
42782
+ access: "view"
42783
+ },
42784
+ "pipelineOrchestrator.unassignAudio": {
42511
42785
  capName: "pipeline-orchestrator",
42512
42786
  capScope: "system",
42513
42787
  addonId: null,
42514
42788
  access: "create"
42515
42789
  },
42516
- "pipelineOrchestrator.updateTemplate": {
42790
+ "pipelineOrchestrator.unassignPipeline": {
42517
42791
  capName: "pipeline-orchestrator",
42518
42792
  capScope: "system",
42519
42793
  addonId: null,
@@ -43953,12 +44227,6 @@ Object.freeze({
43953
44227
  addonId: null,
43954
44228
  access: "view"
43955
44229
  },
43956
- "streamBroker.pullFrameHandles": {
43957
- capName: "stream-broker",
43958
- capScope: "system",
43959
- addonId: null,
43960
- access: "view"
43961
- },
43962
44230
  "streamBroker.regenerateRtspToken": {
43963
44231
  capName: "stream-broker",
43964
44232
  capScope: "system",
@@ -44025,12 +44293,6 @@ Object.freeze({
44025
44293
  addonId: null,
44026
44294
  access: "create"
44027
44295
  },
44028
- "streamBroker.subscribeFrames": {
44029
- capName: "stream-broker",
44030
- capScope: "system",
44031
- addonId: null,
44032
- access: "create"
44033
- },
44034
44296
  "streamBroker.unassignProfile": {
44035
44297
  capName: "stream-broker",
44036
44298
  capScope: "system",
@@ -44043,12 +44305,6 @@ Object.freeze({
44043
44305
  addonId: null,
44044
44306
  access: "create"
44045
44307
  },
44046
- "streamBroker.unsubscribeFrames": {
44047
- capName: "stream-broker",
44048
- capScope: "system",
44049
- addonId: null,
44050
- access: "create"
44051
- },
44052
44308
  "streamCatalog.getCatalog": {
44053
44309
  capName: "stream-catalog",
44054
44310
  capScope: "device",
@@ -44745,6 +45001,12 @@ Object.freeze({
44745
45001
  addonId: null,
44746
45002
  access: "create"
44747
45003
  },
45004
+ "webrtcSession.applyDownlinkProbe": {
45005
+ capName: "webrtc-session",
45006
+ capScope: "device",
45007
+ addonId: null,
45008
+ access: "create"
45009
+ },
44748
45010
  "webrtcSession.closeSession": {
44749
45011
  capName: "webrtc-session",
44750
45012
  capScope: "device",
@@ -46556,11 +46818,6 @@ Object.freeze({
46556
46818
  form: "single",
46557
46819
  optional: false
46558
46820
  }],
46559
- "decoder.createSession": [{
46560
- name: "deviceId",
46561
- form: "single",
46562
- optional: true
46563
- }],
46564
46821
  "detectionPipeline.applyDeviceSettingsPatch": [{
46565
46822
  name: "deviceId",
46566
46823
  form: "single",
@@ -47791,6 +48048,11 @@ Object.freeze({
47791
48048
  form: "single",
47792
48049
  optional: false
47793
48050
  }],
48051
+ "pipelineExecutor.clearModelBoundDeviceOverrides": [{
48052
+ name: "deviceIds",
48053
+ form: "array",
48054
+ optional: true
48055
+ }],
47794
48056
  "pipelineExecutor.runPipeline": [{
47795
48057
  name: "deviceId",
47796
48058
  form: "single",
@@ -47896,6 +48158,11 @@ Object.freeze({
47896
48158
  form: "single",
47897
48159
  optional: false
47898
48160
  }],
48161
+ "pipelineOrchestrator.setCameraStepSettings": [{
48162
+ name: "deviceId",
48163
+ form: "single",
48164
+ optional: false
48165
+ }],
47899
48166
  "pipelineOrchestrator.setCameraStepToggle": [{
47900
48167
  name: "deviceId",
47901
48168
  form: "single",
@@ -48667,6 +48934,11 @@ Object.freeze({
48667
48934
  form: "single",
48668
48935
  optional: false
48669
48936
  }],
48937
+ "webrtcSession.applyDownlinkProbe": [{
48938
+ name: "deviceId",
48939
+ form: "single",
48940
+ optional: false
48941
+ }],
48670
48942
  "webrtcSession.closeSession": [{
48671
48943
  name: "deviceId",
48672
48944
  form: "single",
@@ -116142,7 +116414,6 @@ var HAP_STREAM_PREFERENCE_OPTIONS = [
116142
116414
  ];
116143
116415
  var DEFAULT_CONFIG = {
116144
116416
  bridgeName: "CamStack Bridge",
116145
- port: 0,
116146
116417
  fixedPin: "",
116147
116418
  interfaceName: "",
116148
116419
  ptzPulseMs: 400,
@@ -116819,20 +117090,11 @@ var ExportHapAddon = class extends BaseAddon {
116819
117090
  type: "text",
116820
117091
  key: "bridgeName",
116821
117092
  label: "Installation name",
116822
- 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.",
117093
+ 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.",
116823
117094
  default: DEFAULT_CONFIG.bridgeName,
116824
117095
  requiresRestart: true,
116825
117096
  placement: { tab: "advanced" }
116826
117097
  }),
116827
- this.field({
116828
- type: "number",
116829
- key: "port",
116830
- label: "HAP port",
116831
- description: "Local port for the HAP server. 0 = random ephemeral port (recommended).",
116832
- default: DEFAULT_CONFIG.port,
116833
- requiresRestart: true,
116834
- placement: { tab: "advanced" }
116835
- }),
116836
117098
  this.field({
116837
117099
  type: "text",
116838
117100
  key: "fixedPin",