@camstack/addon-export-google 0.1.87 → 0.1.88

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.
@@ -73,7 +73,7 @@ function createApiDeviceGateway(deps) {
73
73
  };
74
74
  }
75
75
  //#endregion
76
- //#region ../types/dist/event-category-BGmz_oxW.mjs
76
+ //#region ../types/dist/event-category-B_0XEcLF.mjs
77
77
  var EventCategory = /* @__PURE__ */ function(EventCategory) {
78
78
  EventCategory["SystemBoot"] = "system.boot";
79
79
  EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -574,15 +574,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
574
574
  EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
575
575
  EventCategory["AgentBackupActivated"] = "agent.backup.activated";
576
576
  EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
577
- /**
578
- * Per-agent hwaccel preference changed (user override set, cleared, or
579
- * re-probed). Observability event — decoders pull the current pref at
580
- * `createSession`, so running sessions keep their current backend until
581
- * they rotate naturally (camera add/remove, stream restart). Future
582
- * work can wire a listener in stream-broker that force-rotates live
583
- * sessions; for now this event powers logs + admin-UI toast feedback.
584
- */
585
- EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
586
577
  EventCategory["MotionAnalysis"] = "detection.motion-analysis";
587
578
  /** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
588
579
  EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
@@ -5453,7 +5444,7 @@ var ZodIssueCode = {
5453
5444
  var ZodFirstPartyTypeKind;
5454
5445
  ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
5455
5446
  //#endregion
5456
- //#region ../types/dist/sleep-C16NCZR2.mjs
5447
+ //#region ../types/dist/sleep-B0JG7-_F.mjs
5457
5448
  /**
5458
5449
  * The audio chunk plane's byte format, and the ONE expansion from a coded
5459
5450
  * window to float samples (D455).
@@ -6819,32 +6810,12 @@ object({
6819
6810
  audioCodec: string().optional(),
6820
6811
  metadata: record(string(), unknown()).readonly().optional()
6821
6812
  });
6822
- var EncodedPacketSchema = object({
6823
- type: _enum(["video", "audio"]),
6824
- data: _instanceof(Uint8Array),
6825
- pts: number(),
6826
- dts: number(),
6827
- keyframe: boolean(),
6828
- codec: string()
6829
- });
6830
- var DecodedFrameSchema = object({
6831
- data: _instanceof(Uint8Array),
6832
- width: number(),
6833
- height: number(),
6834
- format: _enum([
6835
- "jpeg",
6836
- "rgb",
6837
- "bgr",
6838
- "yuv420",
6839
- "gray"
6840
- ]),
6841
- timestamp: number()
6842
- });
6843
6813
  /**
6844
6814
  * Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
6845
6815
  * frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
6846
- * interface in `interfaces/frame-handle.ts` field-for-field so a decoder cap
6847
- * method (`pullHandles`) can carry handles over tRPC / Moleculer.
6816
+ * interface in `interfaces/frame-handle.ts` field-for-field so a cap method
6817
+ * (the runner's native-crop and pipeline-executor inputs) can carry handles
6818
+ * over tRPC / Moleculer.
6848
6819
  *
6849
6820
  * The `satisfies` assertion below pins this schema to the interface: if a
6850
6821
  * field is added to / removed from `FrameHandle` without a matching schema
@@ -6870,50 +6841,6 @@ var FrameHandleSchema = object({
6870
6841
  slotCount: number().int().positive()
6871
6842
  });
6872
6843
  /**
6873
- * Pixel format a frame-handle subscriber can request from the broker
6874
- * (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
6875
- * `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
6876
- * `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
6877
- * payload, and no decoded-frame consumer requests it over the shm plane.
6878
- */
6879
- var FrameHandleFormatSchema = _enum([
6880
- "rgb",
6881
- "bgr",
6882
- "yuv420",
6883
- "gray"
6884
- ]);
6885
- /**
6886
- * Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
6887
- * broker for a `FrameHandle` stream of one `format`; the broker maintains one
6888
- * shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
6889
- * subscriber (motion) and an `rgb` subscriber (detection) each read the format
6890
- * they asked for with no broker-side conversion.
6891
- */
6892
- var SubscribeFramesInputSchema = object({
6893
- brokerId: string(),
6894
- format: FrameHandleFormatSchema,
6895
- /**
6896
- * Optional reader-side cadence hint in frames per second. The broker does
6897
- * NOT throttle — latest-wins ring reads drop frames implicitly for a slow
6898
- * consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
6899
- * the consumer can pace its own `pullFrameHandles` polling.
6900
- */
6901
- maxFps: number().positive().optional(),
6902
- /** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
6903
- tag: string().optional()
6904
- });
6905
- /**
6906
- * Result of `stream-broker.subscribeFrames`. The consumer then polls
6907
- * `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
6908
- * `FrameHandle` to a `FrameRingReader`.
6909
- */
6910
- var SubscribeFramesResultSchema = object({
6911
- /** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
6912
- subscriptionId: string(),
6913
- /** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
6914
- maxFps: number().nonnegative()
6915
- });
6916
- /**
6917
6844
  * Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
6918
6845
  * `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
6919
6846
  * sample bytes plus the track parameters a consumer needs to interpret them.
@@ -6921,8 +6848,8 @@ var SubscribeFramesResultSchema = object({
6921
6848
  * Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
6922
6849
  * Float32 PCM), so unlike video frames they ship their bytes INLINE over
6923
6850
  * tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
6924
- * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
6925
- * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
6851
+ * (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
6852
+ * it.
6926
6853
  */
6927
6854
  var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
6928
6855
  var DecodedAudioChunkSchema = object({
@@ -6940,11 +6867,10 @@ var DecodedAudioChunkSchema = object({
6940
6867
  format: AudioChunkFormatSchema.optional()
6941
6868
  });
6942
6869
  /**
6943
- * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
6944
- * handle-free, ship-bytes-inline analogue of `subscribeFrames`: a consumer
6945
- * asks the broker for the decoded audio-chunk stream of one broker; the
6946
- * broker keeps a per-subscription bounded FIFO queue the consumer drains via
6947
- * `pullAudioChunks`.
6870
+ * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
6871
+ * its bytes inline: a consumer asks the broker for the decoded audio-chunk
6872
+ * stream of one broker; the broker keeps a per-subscription bounded FIFO queue
6873
+ * the consumer drains via `pullAudioChunks`.
6948
6874
  */
6949
6875
  var SubscribeAudioChunksInputSchema = object({
6950
6876
  brokerId: string(),
@@ -6975,9 +6901,7 @@ var BrokerStatsSchema = object({
6975
6901
  "stopped"
6976
6902
  ]),
6977
6903
  inputFps: number(),
6978
- decodeFps: number(),
6979
6904
  encodedSubscribers: number(),
6980
- decodedSubscribers: number(),
6981
6905
  uptimeMs: number(),
6982
6906
  bitrateKbps: number(),
6983
6907
  idrIntervalMs: number(),
@@ -6990,14 +6914,6 @@ var BrokerStatsSchema = object({
6990
6914
  preBufferMs: number(),
6991
6915
  preBufferPackets: number(),
6992
6916
  /**
6993
- * Moleculer node id of the decoder provider currently servicing this
6994
- * stream's decoded subscribers. `null` until the deferred decoder is
6995
- * created (no decoded clients yet, or codec not detected). Surfaces the
6996
- * runtime decoder placement so the UI can show "Decoder: <agent>" without
6997
- * a separate cap call per broker.
6998
- */
6999
- decoderNodeId: string().nullable(),
7000
- /**
7001
6917
  * Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
7002
6918
  * when the stream has no audio track or the broker is in cold start.
7003
6919
  * `supported = false` means the codec was detected but the local
@@ -8485,8 +8401,8 @@ function buildAddonRouteProvider(id, routes) {
8485
8401
  const reply = buildCapturingReply(envelope);
8486
8402
  const request = {
8487
8403
  params: {
8488
- ...input.params,
8489
- ...match.params
8404
+ ...match.params,
8405
+ ...input.params
8490
8406
  },
8491
8407
  query: input.query,
8492
8408
  body: input.body,
@@ -10468,70 +10384,6 @@ var StorageLocationDeclarationSchema = object({
10468
10384
  "backup"
10469
10385
  ]).optional()
10470
10386
  });
10471
- var DecoderStatsSchema = object({
10472
- inputFps: number(),
10473
- outputFps: number(),
10474
- avgDecodeTimeMs: number(),
10475
- droppedFrames: number(),
10476
- /**
10477
- * Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
10478
- * lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
10479
- * the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
10480
- * is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
10481
- */
10482
- lagMs: number().optional(),
10483
- effectiveFps: number().optional(),
10484
- adaptiveFps: number().optional()
10485
- });
10486
- var DecoderSessionConfigSchema = object({
10487
- codec: string(),
10488
- maxFps: number().default(0),
10489
- outputFormat: _enum([
10490
- "jpeg",
10491
- "rgb",
10492
- "bgr",
10493
- "yuv420",
10494
- "gray"
10495
- ]).default("jpeg"),
10496
- scale: number().default(1),
10497
- width: number().optional(),
10498
- height: number().optional(),
10499
- /**
10500
- * Identifier of the camera this decoder session serves. Optional
10501
- * because the cap is generic (any caller could request decode), but
10502
- * stream-broker passes it so decoder logs include `deviceId` for
10503
- * per-camera filtering when diagnosing failures (e.g. node-av
10504
- * sendPacket errors on a single hung camera).
10505
- */
10506
- deviceId: number().int().nonnegative().optional(),
10507
- /**
10508
- * Free-form tag for log scoping. Stream-broker uses
10509
- * `broker:<deviceId>/<profile>`. Decoder session logger surfaces it
10510
- * on every line so `grep tag=broker:5/high` filters one camera
10511
- * profile cleanly.
10512
- */
10513
- tag: string().optional(),
10514
- /**
10515
- * Where the session delivers decoded frames (Phase 5 / D9):
10516
- *
10517
- * - `'callback'` (default) — the legacy pixel path: decoded frames are
10518
- * buffered as `DecodedFrame`s and drained via `pullFrames`.
10519
- * - `'shm'` — the shared-memory frame plane: decoded frames are written
10520
- * into an OS shared-memory ring and drained as zero-pixel
10521
- * `FrameHandle`s via `pullHandles`. A session is one mode or the
10522
- * other — `pullFrames` returns nothing for an `'shm'` session and
10523
- * `pullHandles` returns nothing for a `'callback'` session.
10524
- */
10525
- frameSink: _enum(["callback", "shm"]).default("callback"),
10526
- /**
10527
- * Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
10528
- * a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
10529
- * real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
10530
- * stream-broker's `streamingDebug` gate — off by default so production logs
10531
- * stay quiet and the emit path pays zero per-frame cost when disabled.
10532
- */
10533
- debug: boolean().optional()
10534
- });
10535
10387
  /**
10536
10388
  * Per-component log CHANNELS — the gate a hot path consults, and the registry
10537
10389
  * an addon declares its channels in.
@@ -10682,7 +10534,18 @@ var LABEL_SUPPLY_STEP_IDS = [
10682
10534
  ];
10683
10535
  /** Steps whose box a root detection can BE. */
10684
10536
  var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
10685
- [...LABEL_SUPPLY_STEP_IDS, ...CROP_SUPPLY_STEP_IDS];
10537
+ /**
10538
+ * Steps whose per-detection MASK a root detection can carry (D737). The live
10539
+ * mask step is `segmentation` — a frame-plane refiner that runs its own model
10540
+ * once per detection crop. (`instance-segmentation` is a dormant step id that
10541
+ * no camera tree carries.)
10542
+ */
10543
+ var MASK_SUPPLY_STEP_IDS = ["segmentation"];
10544
+ [
10545
+ ...LABEL_SUPPLY_STEP_IDS,
10546
+ ...CROP_SUPPLY_STEP_IDS,
10547
+ ...MASK_SUPPLY_STEP_IDS
10548
+ ];
10686
10549
  var MODEL_FORMATS = [
10687
10550
  "onnx",
10688
10551
  "coreml",
@@ -10711,7 +10574,53 @@ var ModelFormatEntrySchema = object({
10711
10574
  /** Multi-file payload (directory members or sibling files). */
10712
10575
  files: array(string()).readonly().optional(),
10713
10576
  /** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
10714
- runtimes: array(_enum(["python"])).readonly().optional()
10577
+ runtimes: array(_enum(["python"])).readonly().optional(),
10578
+ /**
10579
+ * Content revision of the artefact, for one hosted OFF the CamStack mirror.
10580
+ * A format on the mirror leaves it unset: its revision (the sha256 of its
10581
+ * weight file) comes from the downloader's generated table, kept in step
10582
+ * with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
10583
+ * node records the revision it downloaded next to the file
10584
+ * (`<file>.revision`); a copy with no record or a different one is stale
10585
+ * unless its weight file hashes to the revision, and a stale copy is
10586
+ * downloaded again, the old one serving until the new one is complete. No
10587
+ * revision at all ⇒ a file on disk is current, whatever it holds (D743).
10588
+ */
10589
+ revision: string().min(1).optional()
10590
+ });
10591
+ /**
10592
+ * What a node holds for one (model, format) (D746). `current` is a complete
10593
+ * copy at its catalog revision — exactly what `downloaded: true` means.
10594
+ * `stale` is bytes on disk that are not (yet) proven current under D743/D744:
10595
+ * no or a different revision record, or a missing sibling. `missing` is no
10596
+ * copy. `downloaded` alone folds `stale` into "not downloaded", which hid
10597
+ * reclaimable bytes and a copy about to be replaced.
10598
+ */
10599
+ var ModelOnDiskStateSchema = _enum([
10600
+ "current",
10601
+ "stale",
10602
+ "missing"
10603
+ ]);
10604
+ /**
10605
+ * The numeric precision of one format's BUILD (D746) — reported only when the
10606
+ * build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
10607
+ * CamStack Core ML export). Absent means "not stated", never "fp32".
10608
+ */
10609
+ var ModelFormatPrecisionSchema = _enum([
10610
+ "fp32",
10611
+ "fp16",
10612
+ "int8"
10613
+ ]);
10614
+ /**
10615
+ * One format of one model as a node's `pipelineExecutor.getSchema` reports it.
10616
+ * `onDisk` / `precision` are optional for version skew: a runner that predates
10617
+ * them omits them, and a reader falls back to `downloaded`.
10618
+ */
10619
+ var PipelineModelFormatStatusSchema = object({
10620
+ downloaded: boolean(),
10621
+ sizeMB: number(),
10622
+ onDisk: ModelOnDiskStateSchema.optional(),
10623
+ precision: ModelFormatPrecisionSchema.optional()
10715
10624
  });
10716
10625
  /**
10717
10626
  * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
@@ -10825,25 +10734,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
10825
10734
  * - `crop`: the root draws the box the step would have found (`license_plate`
10826
10735
  * for plate-detection, `face` for face-detection). The box becomes a detail
10827
10736
  * child of the `parentMacro` detection that contains it — never a track.
10737
+ * - `mask`: the root's decode emits an instance mask with every detection (a
10738
+ * YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
10739
+ * detection in the shape that step produces. Derived from the model's
10740
+ * postprocessor on read, never stored by an import.
10828
10741
  */
10829
- var RootStepSupplySchema = discriminatedUnion("kind", [object({
10830
- kind: literal("label"),
10831
- stepId: _enum(LABEL_SUPPLY_STEP_IDS),
10832
- labelToEffect: record(string(), string()),
10833
- uncovered: array(string()).readonly()
10834
- }), object({
10835
- kind: literal("crop"),
10836
- stepId: _enum(CROP_SUPPLY_STEP_IDS),
10837
- rootLabels: array(string()).readonly(),
10838
- parentMacro: _enum(["vehicle", "person"]),
10839
- childClass: _enum(["plate", "face"]),
10840
- /**
10841
- * The root's smaller input side, stamped on read by `rootSuppliesOf` from
10842
- * the model entry — what a step's `minRootInputPx` gate judges. Never
10843
- * stored by an import.
10844
- */
10845
- rootInputPx: number().int().positive().optional()
10846
- })]);
10742
+ var RootStepSupplySchema = discriminatedUnion("kind", [
10743
+ object({
10744
+ kind: literal("label"),
10745
+ stepId: _enum(LABEL_SUPPLY_STEP_IDS),
10746
+ labelToEffect: record(string(), string()),
10747
+ uncovered: array(string()).readonly()
10748
+ }),
10749
+ object({
10750
+ kind: literal("crop"),
10751
+ stepId: _enum(CROP_SUPPLY_STEP_IDS),
10752
+ rootLabels: array(string()).readonly(),
10753
+ parentMacro: _enum(["vehicle", "person"]),
10754
+ childClass: _enum(["plate", "face"]),
10755
+ /**
10756
+ * The root's smaller input side, stamped on read by `rootSuppliesOf` from
10757
+ * the model entry — what a step's `minRootInputPx` gate judges. Never
10758
+ * stored by an import.
10759
+ */
10760
+ rootInputPx: number().int().positive().optional()
10761
+ }),
10762
+ object({
10763
+ kind: literal("mask"),
10764
+ stepId: _enum(MASK_SUPPLY_STEP_IDS)
10765
+ })
10766
+ ]);
10847
10767
  var ModelCatalogEntrySchema = object({
10848
10768
  id: string(),
10849
10769
  name: string(),
@@ -10909,6 +10829,35 @@ var ModelCatalogEntrySchema = object({
10909
10829
  */
10910
10830
  defaultConfidence: number().min(0).max(1).optional(),
10911
10831
  /**
10832
+ * Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
10833
+ * on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
10834
+ * absent here runs at the step slider's global default. The same row shape
10835
+ * the floor measurement produces (`model-floors.json`: modelId → floors), so
10836
+ * a measured table is copied in as-is. An operator override is bound to the
10837
+ * model it was made for and does not survive a model change (D738). A custom
10838
+ * / imported model may declare it; without it, the global defaults apply.
10839
+ */
10840
+ defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
10841
+ /**
10842
+ * The inference precision this model's OpenVINO IR needs on an Intel GPU.
10843
+ * Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
10844
+ * that produces invalid output at f16 — measured 2026-10-07 for YOLO26
10845
+ * base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
10846
+ * scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
10847
+ * `PoolModelConfig.gpuInferencePrecision`; the pool sets
10848
+ * INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
10849
+ */
10850
+ gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
10851
+ /**
10852
+ * ROOT detectors only: per supplied step (`animal-classifier`, …), the
10853
+ * minimum DETECTION score from which this root's own fine label (species,
10854
+ * vehicle type — D736 root supply) is taken (D741). Below it the detection
10855
+ * keeps its macro class without the fine label. `1` = never take it from
10856
+ * this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
10857
+ * `minConfidence` slider, bound to the ROOT model, overrides it.
10858
+ */
10859
+ suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
10860
+ /**
10912
10861
  * When true, the executor produces a landmark-aligned crop (similarity warp
10913
10862
  * onto the canonical template) before this step runs, instead of a plain
10914
10863
  * axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
@@ -12607,13 +12556,6 @@ var BrokerRtspClientSchema = object({
12607
12556
  lastRtpAt: number(),
12608
12557
  bytesSent: number()
12609
12558
  });
12610
- var BrokerDecodedClientSchema = object({
12611
- tag: string(),
12612
- subscribedAt: number(),
12613
- maxFps: number(),
12614
- framesDelivered: number(),
12615
- framesDropped: number()
12616
- });
12617
12559
  var BrokerAudioClientSchema = object({
12618
12560
  tag: string(),
12619
12561
  subscribedAt: number(),
@@ -12705,7 +12647,6 @@ var BrokerEncodedClientSchema = object({
12705
12647
  });
12706
12648
  var BrokerClientsSchema = object({
12707
12649
  rtsp: array(BrokerRtspClientSchema).readonly(),
12708
- decoded: array(BrokerDecodedClientSchema).readonly(),
12709
12650
  audio: array(BrokerAudioClientSchema).readonly(),
12710
12651
  encoded: array(BrokerEncodedClientSchema).readonly(),
12711
12652
  pipeClients: number(),
@@ -13074,11 +13015,7 @@ method(object({
13074
13015
  auth: "admin"
13075
13016
  }), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
13076
13017
  brokerId: string(),
13077
- channel: _enum([
13078
- "rtsp",
13079
- "decoded",
13080
- "audio"
13081
- ]),
13018
+ channel: _enum(["rtsp", "audio"]),
13082
13019
  handle: string()
13083
13020
  }), object({ killed: boolean() }), {
13084
13021
  kind: "mutation",
@@ -13113,10 +13050,7 @@ method(object({
13113
13050
  }), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
13114
13051
  subscriptionId: string(),
13115
13052
  maxCount: number().int().positive().default(8)
13116
- }), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(SubscribeFramesInputSchema, SubscribeFramesResultSchema, { kind: "mutation" }), method(object({
13117
- subscriptionId: string(),
13118
- maxCount: number().int().positive().default(4)
13119
- }), array(FrameHandleSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
13053
+ }), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
13120
13054
  brokerId: string(),
13121
13055
  seconds: number().min(0).max(30)
13122
13056
  }), _void(), {
@@ -14273,54 +14207,12 @@ id: union([string(), number()]) }), {
14273
14207
  kind: "mutation",
14274
14208
  auth: "admin"
14275
14209
  });
14276
- /**
14277
- * shm ring usage stats for a `frameSink: 'shm'` decoder session —
14278
- * exposed via `decoder.getShmStats` so downstream consumers can
14279
- * observe ring pressure (slot count, byte budget, hit/miss ratio).
14280
- */
14281
- var ShmRingStatsSchema = object({
14282
- sessionId: string(),
14283
- slotCount: number().int(),
14284
- slotByteLength: number().int(),
14285
- segmentBytes: number().int(),
14286
- budgetMb: number().int(),
14287
- framesWritten: number().int(),
14288
- getFrameHits: number().int(),
14289
- getFrameMisses: number().int()
14290
- });
14291
- method(object({ codec: string() }), boolean()), method(_void(), object({
14210
+ method(_void(), object({
14292
14211
  id: string(),
14293
14212
  name: string(),
14294
- isPullMode: boolean().optional(),
14295
- priority: number().optional(),
14296
14213
  hwaccel: string().optional(),
14297
14214
  probedBestHwaccel: string().optional()
14298
- })), method(DecoderSessionConfigSchema, object({
14299
- sessionId: string(),
14300
- nodeId: string()
14301
- })), method(object({ sessionId: string() }), _void()), method(object({
14302
- sessionId: string(),
14303
- packet: EncodedPacketSchema
14304
- }), _void()), method(object({
14305
- sessionId: string(),
14306
- url: string()
14307
- }), _void()), method(object({
14308
- sessionId: string(),
14309
- maxCount: number().default(1),
14310
- waitMs: number().optional()
14311
- }), array(DecodedFrameSchema)), method(object({
14312
- sessionId: string(),
14313
- maxCount: number().default(1),
14314
- waitMs: number().optional()
14315
- }), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
14316
- sessionId: string(),
14317
- config: DecoderSessionConfigSchema.partial()
14318
- }), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
14319
- sessionId: string(),
14320
- codec: string(),
14321
- outputFormat: string(),
14322
- createdAtMs: number()
14323
- })).readonly()), method(_void(), object({ backend: string() }), {
14215
+ })), method(_void(), object({ backend: string() }), {
14324
14216
  kind: "mutation",
14325
14217
  auth: "admin"
14326
14218
  });
@@ -15157,6 +15049,10 @@ var DeviceInfoSchema = object({
15157
15049
  isCamera: boolean(),
15158
15050
  /** Current config values — serializable snapshot */
15159
15051
  config: record(string(), unknown()),
15052
+ /** Paths inside `config` the device's schema declares secret (D783) —
15053
+ * what the non-admin redaction withholds. Paths, never values. Absent
15054
+ * when the owning runner has not reported them. */
15055
+ secretConfigPaths: array(string()).optional(),
15160
15056
  /** Hardware + identity blob (manufacturer / model / firmware / sn /
15161
15057
  * uid / mac / …). Populated by drivers; editable via setMetadata. */
15162
15058
  metadata: record(string(), unknown()).nullable().optional(),
@@ -15362,7 +15258,13 @@ var DeviceRegisterPayloadSchema = object({
15362
15258
  * call (workers re-register on init), so probe-driven updates
15363
15259
  * (e.g. PTZ flag flipping after the abilities probe) propagate. */
15364
15260
  features: array(string()).optional(),
15365
- config: record(string(), unknown())
15261
+ config: record(string(), unknown()),
15262
+ /** Config paths the device's own schema DECLARES secret
15263
+ * (`.meta({ secret: true })` — dotted, `[]` for array items, e.g.
15264
+ * `connection.password`). Re-published on every register; the non-admin
15265
+ * redaction withholds them at any depth (D783). Optional: an older runner
15266
+ * omits it and the keyword backstop applies. */
15267
+ secretConfigPaths: array(string()).optional()
15366
15268
  });
15367
15269
  var DeviceRemovePayloadSchema = object({ deviceId: number() });
15368
15270
  var DevicePersistConfigPayloadSchema = object({
@@ -16189,6 +16091,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
16189
16091
  kind: "mutation",
16190
16092
  auth: "admin"
16191
16093
  });
16094
+ var HUB_ADDRESS_ROLES = [
16095
+ "appConnections",
16096
+ "notificationTaps",
16097
+ "internal",
16098
+ "publicEndpoint"
16099
+ ];
16192
16100
  /**
16193
16101
  * Transport bounds for AI capability methods.
16194
16102
  *
@@ -17015,7 +16923,14 @@ var LoginMethodContributionSchema = discriminatedUnion("kind", [
17015
16923
  icon: string().optional(),
17016
16924
  /** Addon-owned HTTP route the button navigates to (GET). */
17017
16925
  startUrl: string(),
17018
- stage: LoginStageEnum
16926
+ stage: LoginStageEnum,
16927
+ /**
16928
+ * The provider names an external identity a signed-in user can link to
16929
+ * their own account (D782): `auth.listLinkableProviders` /
16930
+ * `beginExternalLink` offer exactly the redirect methods that set this,
16931
+ * whatever their id. Absent / false — a login button only (magic-link).
16932
+ */
16933
+ linkable: boolean().optional()
17019
16934
  }),
17020
16935
  object({
17021
16936
  kind: literal("widget"),
@@ -20360,7 +20275,13 @@ var NcAlarmModeDelaysListSchema = array(object({
20360
20275
  * Absent = false (logged, not sent). Even when true it is not sent when that same sensor
20361
20276
  * is the one that starts the entry delay — the entry-delay notification already names it.
20362
20277
  */
20363
- notifySensorRewatched: boolean().optional()
20278
+ notifySensorRewatched: boolean().optional(),
20279
+ /**
20280
+ * D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
20281
+ * change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
20282
+ * re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
20283
+ */
20284
+ notifySensorIgnored: boolean().optional()
20364
20285
  })).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
20365
20286
  var NcAlarmModeDelaysEditListSchema = array(object({
20366
20287
  mode: AlarmArmModeSchema,
@@ -20373,7 +20294,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
20373
20294
  /** D706: set the switch, or `null` to clear it (back to the default, false). */
20374
20295
  notifyDuringEntryDelay: boolean().nullable().optional(),
20375
20296
  /** D706: set the switch, or `null` to clear it (back to the default, false). */
20376
- notifySensorRewatched: boolean().nullable().optional()
20297
+ notifySensorRewatched: boolean().nullable().optional(),
20298
+ /** D735: set the switch, or `null` to clear it (back to the default, false). */
20299
+ notifySensorIgnored: boolean().nullable().optional()
20377
20300
  })).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
20378
20301
  /** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
20379
20302
  var NcAlarmNonBlockingEditSchema = object({
@@ -21367,8 +21290,8 @@ Object.freeze(Object.fromEntries([{
21367
21290
  var CLUSTER_STEP_SETTING_FIELDS = [{
21368
21291
  stepId: "face-embedding",
21369
21292
  key: "minLandmarkFaceSize",
21370
- label: "Min face size for recognition (detection px)",
21371
- 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.",
21293
+ label: "Min face size to embed (detection-frame px)",
21294
+ 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.",
21372
21295
  type: "slider",
21373
21296
  min: 0,
21374
21297
  max: 64,
@@ -22420,7 +22343,13 @@ var RetrainFrameSchema = object({
22420
22343
  sizeBytes: number().int(),
22421
22344
  width: number().int(),
22422
22345
  height: number().int(),
22423
- copiedAt: number()
22346
+ copiedAt: number(),
22347
+ /** When the CAMERA captured the frame. Absent on a copy taken before D785. */
22348
+ capturedAt: number().optional(),
22349
+ /** The operator's "every subject in this frame is boxed". Detector
22350
+ * evaluation keeps only complete frames: an unboxed subject would count as
22351
+ * a false positive. */
22352
+ complete: boolean()
22424
22353
  });
22425
22354
  /** Why a copy-on-select could not be honoured — named, never a silent skip. */
22426
22355
  var RetrainCopyRefusalSchema = _enum([
@@ -22441,6 +22370,51 @@ var RetrainFrameListSchema = object({
22441
22370
  /** What the page pre-selects — the native key frame when one survives. */
22442
22371
  autoPickMediaId: number().int().optional()
22443
22372
  });
22373
+ /**
22374
+ * Which frames an annotated export carries. Every field narrows; an empty
22375
+ * filter is every annotated copy. A dataset VERSION is a frozen `frameIds`
22376
+ * list owned by whoever trains (the training orchestrator), so `frameIds` is
22377
+ * the primitive a version export uses; `batchId` re-selects what an earlier
22378
+ * export carried (`exportedInBatch`).
22379
+ */
22380
+ var RetrainExportFilterSchema = object({
22381
+ deviceIds: array(number()).optional(),
22382
+ frameIds: array(string()).max(2e4).optional(),
22383
+ batchId: string().optional(),
22384
+ /** Only frames the operator marked complete (all subjects boxed). */
22385
+ completeOnly: boolean().optional()
22386
+ });
22387
+ /**
22388
+ * `frames`: the full frame copies, boxes in `annotations.json`.
22389
+ * `crops`: additionally one JPEG per subject, cut with the runtime detail-crop
22390
+ * convention — the classifier layout.
22391
+ */
22392
+ var RetrainExportLayoutSchema = _enum(["frames", "crops"]);
22393
+ /**
22394
+ * Where `writeRetrainArchive` streams the tar: one HTTP request whose body is
22395
+ * the archive, sent chunk by chunk. Covers a presigned PUT and a provider
22396
+ * addon's data-plane upload route alike. Headers are sent verbatim and never
22397
+ * logged.
22398
+ */
22399
+ var RetrainArchiveTargetSchema = object({
22400
+ kind: literal("http"),
22401
+ method: _enum(["PUT", "POST"]),
22402
+ url: string().url(),
22403
+ headers: record(string(), string()).optional()
22404
+ });
22405
+ var RetrainArchiveResultSchema = object({
22406
+ batchId: string(),
22407
+ frames: number().int(),
22408
+ crops: number().int(),
22409
+ annotations: number().int(),
22410
+ /** Frames planned but not shipped (unreadable copy, path too long). */
22411
+ missing: number().int(),
22412
+ bytes: number().int(),
22413
+ /** sha256 of the exact bytes sent. */
22414
+ sha256: string(),
22415
+ /** The target's HTTP status. */
22416
+ status: number().int()
22417
+ });
22444
22418
  /** What the operator asked the assist to look for. */
22445
22419
  var RetrainAssistSubjectSchema = discriminatedUnion("kind", [object({
22446
22420
  kind: literal("package"),
@@ -23235,9 +23209,25 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
23235
23209
  }), RetrainTransitionResultSchema, {
23236
23210
  kind: "mutation",
23237
23211
  auth: "admin"
23238
- }), method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
23212
+ }), method(RetrainExportFilterSchema.extend({ layout: RetrainExportLayoutSchema.optional() }), object({ url: string() }), {
23239
23213
  kind: "query",
23240
23214
  auth: "admin"
23215
+ }), method(object({
23216
+ deviceId: number(),
23217
+ trackId: string(),
23218
+ frameId: string(),
23219
+ complete: boolean()
23220
+ }), RetrainFrameSchema, {
23221
+ kind: "mutation",
23222
+ auth: "admin"
23223
+ }), method(object({
23224
+ filter: RetrainExportFilterSchema,
23225
+ layout: RetrainExportLayoutSchema,
23226
+ target: RetrainArchiveTargetSchema
23227
+ }), RetrainArchiveResultSchema, {
23228
+ kind: "mutation",
23229
+ auth: "admin",
23230
+ timeoutMs: 60 * 6e4
23241
23231
  }), method(object({
23242
23232
  /** Which of the three event tables owns the row. */
23243
23233
  ownerType: EventOwnerTypeSchema,
@@ -23363,7 +23353,7 @@ var FrameRefSchema = object({
23363
23353
  timestamp: number(),
23364
23354
  capturedAt: number().optional()
23365
23355
  });
23366
- var ModelFormatSchema$1 = _enum([
23356
+ var ModelFormatSchema$2 = _enum([
23367
23357
  "onnx",
23368
23358
  "coreml",
23369
23359
  "openvino",
@@ -23381,7 +23371,7 @@ var PipelineSlotSchema = _enum([
23381
23371
  var PipelineEngineChoiceSchema = object({
23382
23372
  runtime: literal("python"),
23383
23373
  backend: string(),
23384
- format: ModelFormatSchema$1,
23374
+ format: ModelFormatSchema$2,
23385
23375
  device: string().optional()
23386
23376
  });
23387
23377
  /**
@@ -23420,28 +23410,10 @@ var PipelineDefaultStepSchema = lazy(() => object({
23420
23410
  group: string().optional(),
23421
23411
  settings: record(string(), unknown()).optional()
23422
23412
  }));
23423
- var PipelineTemplateStepSchema = lazy(() => object({
23424
- addonId: string(),
23425
- enabled: boolean(),
23426
- modelId: string(),
23427
- children: array(PipelineTemplateStepSchema).readonly(),
23428
- settings: record(string(), unknown()).optional()
23429
- }));
23430
- var PipelineTemplateSchema$1 = object({
23431
- id: string(),
23432
- name: string(),
23433
- createdAt: string(),
23434
- updatedAt: string(),
23435
- engine: PipelineEngineChoiceSchema,
23436
- steps: array(PipelineTemplateStepSchema).readonly()
23437
- });
23438
23413
  var PipelineModelOptionSchema = object({
23439
23414
  id: string(),
23440
23415
  name: string(),
23441
- formats: record(string(), object({
23442
- downloaded: boolean(),
23443
- sizeMB: number()
23444
- })),
23416
+ formats: record(string(), PipelineModelFormatStatusSchema),
23445
23417
  group: ModelVariantGroupSchema.optional(),
23446
23418
  legacy: boolean().optional(),
23447
23419
  provider: ModelProviderIdSchema.optional(),
@@ -23608,6 +23580,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
23608
23580
  }), {
23609
23581
  kind: "mutation",
23610
23582
  auth: "admin"
23583
+ }), method(object({
23584
+ nodeId: string(),
23585
+ deviceIds: array(number()).readonly().optional(),
23586
+ dryRun: boolean()
23587
+ }), object({
23588
+ entries: array(object({
23589
+ deviceId: number(),
23590
+ keys: array(string()).readonly()
23591
+ })).readonly(),
23592
+ refused: array(object({
23593
+ deviceId: number(),
23594
+ reason: string()
23595
+ })).readonly()
23596
+ }), {
23597
+ kind: "mutation",
23598
+ auth: "admin"
23611
23599
  }), method(object({ nodeId: string() }), object({ unhealthy: array(object({
23612
23600
  /** `<backend>:<device>`, e.g. `openvino:gpu`. */
23613
23601
  deviceKey: string(),
@@ -23633,22 +23621,14 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
23633
23621
  }), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
23634
23622
  steps: array(PipelineStepInputSchema),
23635
23623
  deviceKey: string().optional()
23636
- }), PipelineValidationResultSchema), method(_void(), array(PipelineTemplateSchema$1).readonly()), method(object({
23637
- name: string(),
23638
- steps: array(PipelineTemplateStepSchema).readonly(),
23639
- engine: PipelineEngineChoiceSchema
23640
- }), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
23641
- id: string(),
23642
- name: string().optional(),
23643
- steps: array(PipelineTemplateStepSchema).readonly().optional()
23644
- }), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
23624
+ }), PipelineValidationResultSchema), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
23645
23625
  addonId: string(),
23646
23626
  modelId: string(),
23647
- format: ModelFormatSchema$1
23627
+ format: ModelFormatSchema$2
23648
23628
  }), DownloadModelResultSchema, { kind: "mutation" }), method(object({
23649
23629
  addonId: string(),
23650
23630
  modelId: string(),
23651
- format: ModelFormatSchema$1
23631
+ format: ModelFormatSchema$2
23652
23632
  }), object({ success: literal(true) }), { kind: "mutation" }), method(object({
23653
23633
  steps: array(PipelineStepInputSchema).min(1),
23654
23634
  frame: FrameInputSchema.optional(),
@@ -23805,6 +23785,375 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
23805
23785
  filename: string().optional(),
23806
23786
  settings: record(string(), unknown()).optional()
23807
23787
  }), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
23788
+ /**
23789
+ * The wire shapes of the Auto tune plan and apply (D745), used by the
23790
+ * `pipeline-orchestrator` cap. The recommender's own types
23791
+ * (`recommend.ts`) are the TS face of the same data; these
23792
+ * schemas are what crosses the cap boundary.
23793
+ */
23794
+ var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
23795
+ /** The operator's range for it. */
23796
+ var MIN_SESSIONS_PER_DEVICE_RANGE = {
23797
+ min: 1,
23798
+ max: 8
23799
+ };
23800
+ var HardwareClassIdSchema = _enum([
23801
+ "intel-core-ultra",
23802
+ "intel-n-series",
23803
+ "apple-m-base",
23804
+ "apple-m-pro",
23805
+ "unknown"
23806
+ ]);
23807
+ var AcceleratorKindSchema = _enum([
23808
+ "intel-npu",
23809
+ "intel-igpu",
23810
+ "x86-cpu",
23811
+ "arm-cpu",
23812
+ "apple-ane",
23813
+ "coral"
23814
+ ]);
23815
+ var RecommendationReasonSchema = discriminatedUnion("kind", [
23816
+ object({
23817
+ kind: literal("capacity"),
23818
+ sessions: number(),
23819
+ minSessions: number()
23820
+ }),
23821
+ object({
23822
+ kind: literal("tie-faster"),
23823
+ over: string(),
23824
+ recallDelta: number()
23825
+ }),
23826
+ object({
23827
+ kind: literal("stepped-down"),
23828
+ from: string(),
23829
+ to: string(),
23830
+ limitedBy: string()
23831
+ }),
23832
+ object({
23833
+ kind: literal("no-fit-lightest"),
23834
+ sessions: number(),
23835
+ minSessions: number()
23836
+ }),
23837
+ object({
23838
+ kind: literal("derived-latency"),
23839
+ modelId: string()
23840
+ }),
23841
+ object({ kind: literal("cpu-device") }),
23842
+ object({ kind: literal("coral-untouched") }),
23843
+ object({ kind: literal("device-disabled") }),
23844
+ object({ kind: literal("device-unavailable") }),
23845
+ object({ kind: literal("node-offline") }),
23846
+ object({ kind: literal("no-hardware-facts") }),
23847
+ object({
23848
+ kind: literal("no-measured-data"),
23849
+ hardwareClass: HardwareClassIdSchema
23850
+ }),
23851
+ object({
23852
+ kind: literal("no-family-build"),
23853
+ format: ModelFormatSchema$1
23854
+ })
23855
+ ]);
23856
+ var DeviceModelChoiceSchema = object({
23857
+ modelId: string(),
23858
+ p50Ms: number(),
23859
+ fps: number(),
23860
+ measured: boolean(),
23861
+ /** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
23862
+ capacitySessions: number(),
23863
+ personRecall: number()
23864
+ });
23865
+ var DeviceRecommendationSchema = object({
23866
+ deviceKey: string(),
23867
+ accelerator: AcceleratorKindSchema.nullable(),
23868
+ enabled: boolean(),
23869
+ available: boolean(),
23870
+ chosen: DeviceModelChoiceSchema.nullable(),
23871
+ reasons: array(RecommendationReasonSchema).readonly()
23872
+ });
23873
+ var NodeRecommendationSchema = object({
23874
+ nodeId: string(),
23875
+ reachable: boolean(),
23876
+ hardwareClass: HardwareClassIdSchema.nullable(),
23877
+ cpuModel: string().nullable(),
23878
+ skipped: boolean(),
23879
+ acceleratorModelId: string().nullable(),
23880
+ devices: array(DeviceRecommendationSchema).readonly(),
23881
+ reasons: array(RecommendationReasonSchema).readonly()
23882
+ });
23883
+ var ModelPinChangeSchema = object({
23884
+ stepId: string(),
23885
+ before: string().nullable(),
23886
+ after: string().nullable()
23887
+ });
23888
+ var NodeDeviceChangeSchema = object({
23889
+ nodeId: string(),
23890
+ deviceKey: string(),
23891
+ madeExplicit: boolean(),
23892
+ modelPins: array(ModelPinChangeSchema).readonly(),
23893
+ thresholds: array(object({
23894
+ stepId: string(),
23895
+ keys: array(string()).readonly()
23896
+ })).readonly()
23897
+ });
23898
+ var CameraOverrideClearSchema = object({
23899
+ deviceId: number(),
23900
+ source: _enum(["step-override", "wholesale"]),
23901
+ nodeId: string(),
23902
+ deviceKey: string().nullable(),
23903
+ stepId: string(),
23904
+ modelIdBefore: string().nullable(),
23905
+ keys: array(string()).readonly()
23906
+ });
23907
+ var DetectorStoreClearSchema = object({
23908
+ deviceId: number(),
23909
+ keys: array(string()).readonly()
23910
+ });
23911
+ var AutoTuneWarningSchema = discriminatedUnion("kind", [
23912
+ object({
23913
+ kind: literal("detector-store-cluster-wide"),
23914
+ skippedNodes: array(string()).readonly()
23915
+ }),
23916
+ object({
23917
+ kind: literal("detector-store-unreadable"),
23918
+ error: string()
23919
+ }),
23920
+ object({
23921
+ kind: literal("coral-enabled"),
23922
+ nodeId: string(),
23923
+ deviceKey: string()
23924
+ })
23925
+ ]);
23926
+ var AutoTuneOptionsSchema = object({
23927
+ /** Share of each accelerator's throughput kept free (0.3–0.5). */
23928
+ headroom: number().min(.3).max(.5).default(.4),
23929
+ /**
23930
+ * The least number of parallel sessions every device must sustain at the
23931
+ * camera rate with the headroom kept free (D755). The most accurate model
23932
+ * that reaches it wins.
23933
+ */
23934
+ minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
23935
+ });
23936
+ var AutoTunePlanSchema = object({
23937
+ /** Hash of everything the apply will write — the apply refuses a different one. */
23938
+ planHash: string(),
23939
+ family: literal("yolov9"),
23940
+ headroom: number(),
23941
+ minSessionsPerDevice: number(),
23942
+ /** The detection rate a session is counted at (the fastest camera running the pipeline root). */
23943
+ cameraFps: number(),
23944
+ generatedAt: number(),
23945
+ nodes: array(NodeRecommendationSchema).readonly(),
23946
+ nodeChanges: array(NodeDeviceChangeSchema).readonly(),
23947
+ cameraClears: array(CameraOverrideClearSchema).readonly(),
23948
+ detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
23949
+ warnings: array(AutoTuneWarningSchema).readonly()
23950
+ });
23951
+ var AutoTuneApplyInputSchema = object({
23952
+ planHash: string(),
23953
+ headroom: number().min(.3).max(.5).default(.4),
23954
+ minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
23955
+ });
23956
+ var AutoTunePhaseResultSchema = object({
23957
+ phase: _enum([
23958
+ "download",
23959
+ "camera-overrides",
23960
+ "detector-thresholds",
23961
+ "node-models",
23962
+ "redispatch"
23963
+ ]),
23964
+ ok: boolean(),
23965
+ detail: string()
23966
+ });
23967
+ var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
23968
+ object({
23969
+ kind: literal("applied"),
23970
+ planHash: string(),
23971
+ phases: array(AutoTunePhaseResultSchema).readonly()
23972
+ }),
23973
+ object({
23974
+ kind: literal("aborted"),
23975
+ phases: array(AutoTunePhaseResultSchema).readonly()
23976
+ }),
23977
+ object({
23978
+ kind: literal("stale"),
23979
+ plan: AutoTunePlanSchema
23980
+ }),
23981
+ object({
23982
+ kind: literal("refused"),
23983
+ reason: _enum(["apply-in-progress"])
23984
+ })
23985
+ ]);
23986
+ /**
23987
+ * Wire shapes of the Load balancing surface (D748): the session placement
23988
+ * policy, the atomic share write, the observed placement statistics, the
23989
+ * hardware share suggestion and the stale device pins.
23990
+ */
23991
+ /**
23992
+ * How a new detection session picks its node and device.
23993
+ * - `least-loaded` — the historical rule: lowest `attached / weight`, a
23994
+ * constant node order at a tie (D37). An idle node always ties at 0, so a
23995
+ * weight only bites once a node already holds a session.
23996
+ * - `share` — the share of PARALLEL sessions is held to the weights, and a
23997
+ * full or drowning node yields to a free one (D748).
23998
+ */
23999
+ var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
24000
+ var LoadBalancingSharesInputSchema = object({
24001
+ /** nodeId → share (> 0). A node left out keeps its weight. */
24002
+ nodes: record(string(), number().positive()).default({}),
24003
+ /** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
24004
+ devices: record(string(), record(string(), number().positive())).default({})
24005
+ });
24006
+ var PlacementStatsInputSchema = object({
24007
+ /** Window the observed shares are averaged over (default 1 h, max 24 h). */
24008
+ windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
24009
+ var PlacementDeviceStatsSchema = object({
24010
+ deviceKey: string(),
24011
+ /** Sessions running on this device now. */
24012
+ sessionsNow: number(),
24013
+ /** Sessions started on this device inside the window. */
24014
+ sessionsStarted: number(),
24015
+ /** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
24016
+ observedShare: number().nullable()
24017
+ });
24018
+ var PlacementNodeStatsSchema = object({
24019
+ nodeId: string(),
24020
+ sessionsNow: number(),
24021
+ sessionsStarted: number(),
24022
+ /** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
24023
+ observedShare: number().nullable(),
24024
+ /** Most sessions this node ran at once inside the window. */
24025
+ peakSessions: number(),
24026
+ /** Sessions a share election handed elsewhere because this node was full or drowning. */
24027
+ yieldsAway: number(),
24028
+ devices: array(PlacementDeviceStatsSchema).readonly()
24029
+ });
24030
+ /** A camera's device pin that the session path cannot honour. */
24031
+ var StaleDevicePinSchema = object({
24032
+ deviceId: number(),
24033
+ deviceKey: string(),
24034
+ /** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
24035
+ reason: _enum(["disabled", "absent"])
24036
+ });
24037
+ var PlacementStatsSchema = object({
24038
+ policy: SessionPlacementPolicySchema,
24039
+ windowMs: number(),
24040
+ /** How much of the window was actually observed (the hub keeps it in memory). */
24041
+ observedForMs: number(),
24042
+ sessionsNow: number(),
24043
+ /** Most parallel sessions across the cluster inside the window. */
24044
+ clusterPeakSessions: number(),
24045
+ nodes: array(PlacementNodeStatsSchema).readonly(),
24046
+ stalePins: array(StaleDevicePinSchema).readonly()
24047
+ });
24048
+ /**
24049
+ * Where an automatic share's capacity comes from (D755).
24050
+ * - `hardware` — the static capacity of each device at its Auto tune model:
24051
+ * the measured latency table for the node's hardware class.
24052
+ * - `benchmark` — the node's own measured capacity (node benchmark results).
24053
+ * A node with no results falls back to `hardware`, and says so.
24054
+ */
24055
+ var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
24056
+ /** Why a node under the `benchmark` source was sized from hardware instead. */
24057
+ var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
24058
+ var SuggestSharesInputSchema = object({
24059
+ headroom: number().min(.3).max(.5).default(.4),
24060
+ /** Default `hardware`. */
24061
+ source: CapacitySourceSchema.default("hardware")
24062
+ });
24063
+ var SuggestedDeviceShareSchema = object({
24064
+ deviceKey: string(),
24065
+ /** Share of the node (0–100, rounded). */
24066
+ share: number(),
24067
+ modelId: string().nullable(),
24068
+ /** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
24069
+ fps: number().nullable(),
24070
+ /** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
24071
+ measured: boolean(),
24072
+ /**
24073
+ * Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
24074
+ * or the benchmark's measured max sessions. Never enforced.
24075
+ */
24076
+ suggestedMaxSessions: number().nullable()
24077
+ });
24078
+ var SuggestedNodeShareSchema = object({
24079
+ nodeId: string(),
24080
+ /** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
24081
+ share: number().nullable(),
24082
+ /** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
24083
+ capacitySessions: number(),
24084
+ devices: array(SuggestedDeviceShareSchema).readonly(),
24085
+ skippedReason: string().nullable(),
24086
+ /** What this node's capacity was read from; null when the node is skipped. */
24087
+ capacitySource: CapacitySourceSchema.nullable(),
24088
+ /** Set when the `benchmark` source was asked for and this node used `hardware`. */
24089
+ capacityFallback: CapacityFallbackSchema.nullable()
24090
+ });
24091
+ var SuggestSharesResultSchema = object({
24092
+ headroom: number(),
24093
+ /** The source asked for; each node says what it actually used. */
24094
+ source: CapacitySourceSchema,
24095
+ /** Camera detection rate the capacity is counted in (the fastest camera's fps). */
24096
+ cameraFps: number(),
24097
+ /** The Auto tune capacity floor the models were picked at. */
24098
+ minSessionsPerDevice: number(),
24099
+ nodes: array(SuggestedNodeShareSchema).readonly()
24100
+ });
24101
+ /**
24102
+ * Where the node and device shares come from (D750, D755).
24103
+ * - `hardware` (default) — computed by the system from each node's static
24104
+ * capacity (its accelerators at their Auto tune models, from the measured
24105
+ * latency table), recomputed whenever a node or device joins, leaves, is
24106
+ * switched on or off, or changes model. No load input.
24107
+ * - `benchmark` — the same, from each node's measured capacity (node
24108
+ * benchmark results); a node without results falls back to `hardware`.
24109
+ * - `manual` — the operator's stored sliders.
24110
+ * Either way a node or device that cannot take sessions gives its share to
24111
+ * the others in proportion; the stored values are never rewritten for that.
24112
+ */
24113
+ var ShareSourceSchema = _enum([
24114
+ "hardware",
24115
+ "benchmark",
24116
+ "manual"
24117
+ ]);
24118
+ var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
24119
+ object({
24120
+ nodes: record(string(), number()),
24121
+ devices: record(string(), record(string(), number()))
24122
+ });
24123
+ var EffectiveDeviceShareSchema = object({
24124
+ deviceKey: string(),
24125
+ /** Can take sessions now (enabled, available, can run the root). */
24126
+ eligible: boolean(),
24127
+ /** The share the source assigns, as a percentage of the node's devices. */
24128
+ configuredPct: number(),
24129
+ /** The share actually used, after an ineligible device's share went to the others. */
24130
+ effectivePct: number()
24131
+ });
24132
+ var EffectiveNodeShareSchema = object({
24133
+ nodeId: string(),
24134
+ eligible: boolean(),
24135
+ configuredPct: number(),
24136
+ effectivePct: number(),
24137
+ /** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
24138
+ capacitySource: CapacitySourceSchema.nullable(),
24139
+ /** Automatic `benchmark`: why this node used `hardware` instead. */
24140
+ capacityFallback: CapacityFallbackSchema.nullable(),
24141
+ devices: array(EffectiveDeviceShareSchema).readonly()
24142
+ });
24143
+ var EffectiveSharesSchema = object({
24144
+ source: ShareSourceSchema,
24145
+ policy: SessionPlacementPolicySchema,
24146
+ /** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
24147
+ autoPending: boolean(),
24148
+ /** When the automatic shares were last computed (ms epoch); null = never. */
24149
+ computedAt: number().nullable(),
24150
+ /** What made the system recompute them last. */
24151
+ trigger: string().nullable(),
24152
+ nodes: array(EffectiveNodeShareSchema).readonly(),
24153
+ /** The relative weights the election reads (before eligibility). */
24154
+ nodeWeights: record(string(), number()),
24155
+ deviceWeights: record(string(), record(string(), number()))
24156
+ });
23808
24157
  object({
23809
24158
  activeCameras: number(),
23810
24159
  throttledCameras: number(),
@@ -24682,14 +25031,15 @@ var RunnerLocalLoadSchema = object({
24682
25031
  * Per-inference-device live load (multi-device C4). One entry per deviceKey
24683
25032
  * this runner currently has attached cameras on, so the orchestrator's second
24684
25033
  * `balance()` pass (over a node's devices) weights on real per-pool session
24685
- * counts. Empty on single-device / pre-multi-device runners. `queueDepthTotal`
24686
- * per device is 0 until the pool backlog gets a public accessor (follow-up).
25034
+ * counts. Empty on single-device / pre-multi-device runners. There is no
25035
+ * per-device queue depth: the inference pool's backlog has no accessor, and
25036
+ * a field that always read 0 was removed rather than shown as a measurement
25037
+ * (D762).
24687
25038
  */
24688
25039
  devices: array(object({
24689
25040
  deviceKey: string(),
24690
25041
  backend: string(),
24691
- attachedCameras: number(),
24692
- queueDepthTotal: number()
25042
+ attachedCameras: number()
24693
25043
  })).default([]),
24694
25044
  /** Hardware capability flags reported by this node. */
24695
25045
  hardware: object({
@@ -24903,14 +25253,6 @@ var CameraPipelineConfigSchema = object({
24903
25253
  settings: record(string(), unknown()).readonly().optional()
24904
25254
  }).nullable().optional()
24905
25255
  });
24906
- var PipelineTemplateSchema = object({
24907
- id: string(),
24908
- name: string(),
24909
- description: string().optional(),
24910
- config: CameraPipelineConfigSchema,
24911
- createdAt: string(),
24912
- updatedAt: string()
24913
- });
24914
25256
  var DeviceStepConfigSchema = object({
24915
25257
  modelId: string().optional(),
24916
25258
  settings: record(string(), unknown()).optional(),
@@ -24984,9 +25326,10 @@ var CameraStepOverridePatchSchema = object({
24984
25326
  modelId: string().optional(),
24985
25327
  settings: record(string(), unknown()).readonly().optional()
24986
25328
  });
25329
+ var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
24987
25330
  var CameraPipelineSettingsSchema = object({
24988
- pinnedAgentNodeId: string().optional(),
24989
25331
  stepToggles: record(string(), boolean()).optional(),
25332
+ stepSettings: CameraStepSettingsSchema.optional(),
24990
25333
  stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
24991
25334
  pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
24992
25335
  });
@@ -25019,7 +25362,10 @@ var PipelineAssignmentSchema = object({
25019
25362
  });
25020
25363
  /**
25021
25364
  * Per-agent load summary surfaced to the load balancer + dashboards.
25022
- * Aggregated from each runner's `getLocalLoad` cap call.
25365
+ * Aggregated from each runner's `getLocalLoad` cap call. In the
25366
+ * `getAgentLoad` report, a single-device node's default-pool sessions (no
25367
+ * `deviceKey`) are credited to its one eligible device in `load.devices` —
25368
+ * the default pool IS that device (D745); the balancer's census stays raw.
25023
25369
  */
25024
25370
  var AgentLoadSummarySchema = object({
25025
25371
  nodeId: string(),
@@ -25108,26 +25454,27 @@ var CameraBrokerStatusSchema = object({
25108
25454
  width: number(),
25109
25455
  height: number(),
25110
25456
  subscribers: number(),
25111
- inFps: number(),
25112
- outFps: number()
25457
+ /**
25458
+ * Encoded packets/s the broker receives from the camera. null when the
25459
+ * broker's stats read failed — unknown, never 0 (a 0 here reads as a stall).
25460
+ * There is no output rate: decoding runs in the session decode workers, not
25461
+ * in the broker, so the broker's own decoded-frame rate is 0 on every live
25462
+ * camera and is not served (D758).
25463
+ */
25464
+ inFps: number().nullable()
25113
25465
  })).readonly(),
25114
25466
  webrtcSessions: number(),
25115
25467
  rtspRestream: boolean()
25116
25468
  });
25117
- /** Shared-memory ring statistics within the decoder block. */
25118
- var CameraDecoderShmSchema = object({
25119
- framesWritten: number(),
25120
- getFrameHits: number(),
25121
- getFrameMisses: number(),
25122
- budgetMb: number()
25123
- });
25124
- /** Decoder block — null when the decoder stage is unreachable or inactive. */
25125
- var CameraDecoderStatusSchema = object({
25126
- nodeId: string(),
25127
- formats: array(string()).readonly(),
25128
- sessionCount: number(),
25129
- shm: CameraDecoderShmSchema
25130
- });
25469
+ /**
25470
+ * Decoder block — WHERE decode runs (co-located with the detection node by
25471
+ * construction); null when the camera has no detection node. It carries no
25472
+ * frame counter: the shared-memory plane whose counters it used to serve is
25473
+ * gone, and those fields read 0 forever. Whether frames actually flow is read
25474
+ * from `detection.actualFps` (frames delivered to and processed by the
25475
+ * detector), never from a counter nothing feeds.
25476
+ */
25477
+ var CameraDecoderStatusSchema = object({ nodeId: string() });
25131
25478
  /** Motion block — null when motion detection is not active for this device. */
25132
25479
  var CameraMotionStatusSchema = object({
25133
25480
  enabled: boolean(),
@@ -25484,12 +25831,6 @@ method(object({
25484
25831
  }), object({ success: literal(true) }), {
25485
25832
  kind: "mutation",
25486
25833
  auth: "admin"
25487
- }), method(object({
25488
- agentNodeId: string(),
25489
- detectWeight: number().positive().nullable()
25490
- }), object({ success: literal(true) }), {
25491
- kind: "mutation",
25492
- auth: "admin"
25493
25834
  }), method(object({
25494
25835
  agentNodeId: string(),
25495
25836
  detect: boolean().nullable().optional(),
@@ -25531,6 +25872,15 @@ method(object({
25531
25872
  }), {
25532
25873
  kind: "mutation",
25533
25874
  auth: "admin"
25875
+ }), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
25876
+ kind: "mutation",
25877
+ auth: "admin"
25878
+ }), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
25879
+ kind: "mutation",
25880
+ auth: "admin"
25881
+ }), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
25882
+ kind: "mutation",
25883
+ auth: "admin"
25534
25884
  }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
25535
25885
  deviceId: number(),
25536
25886
  addonId: string(),
@@ -25547,6 +25897,13 @@ method(object({
25547
25897
  }), object({ success: literal(true) }), {
25548
25898
  kind: "mutation",
25549
25899
  auth: "admin"
25900
+ }), method(object({
25901
+ deviceId: number(),
25902
+ addonId: string(),
25903
+ settings: record(string(), unknown()).nullable()
25904
+ }), object({ success: literal(true) }), {
25905
+ kind: "mutation",
25906
+ auth: "admin"
25550
25907
  }), method(object({
25551
25908
  deviceId: number(),
25552
25909
  agentNodeId: string(),
@@ -25570,25 +25927,7 @@ method(object({
25570
25927
  }), method(_void(), DiskReconcileJobSchema, {
25571
25928
  kind: "mutation",
25572
25929
  auth: "admin"
25573
- }), method(_void(), DiskReconcileJobSchema, { auth: "admin" }), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
25574
- name: string(),
25575
- description: string().optional(),
25576
- config: CameraPipelineConfigSchema
25577
- }), PipelineTemplateSchema, {
25578
- kind: "mutation",
25579
- auth: "admin"
25580
- }), method(object({
25581
- id: string(),
25582
- name: string().optional(),
25583
- description: string().optional(),
25584
- config: CameraPipelineConfigSchema.optional()
25585
- }), PipelineTemplateSchema, {
25586
- kind: "mutation",
25587
- auth: "admin"
25588
- }), method(object({ id: string() }), object({ success: literal(true) }), {
25589
- kind: "mutation",
25590
- auth: "admin"
25591
- });
25930
+ }), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
25592
25931
  /**
25593
25932
  * Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
25594
25933
  * `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
@@ -26178,7 +26517,19 @@ var SsoBridgeClaimsSchema = object({
26178
26517
  * editing a descriptor must not retroactively extend or shorten a link the
26179
26518
  * operator already consented to.
26180
26519
  */
26181
- refreshTtl: union([number().int().positive(), literal("never")]).optional()
26520
+ refreshTtl: union([number().int().positive(), literal("never")]).optional(),
26521
+ /**
26522
+ * Opaque handle of a hub-side LINK intent (D782). Set by an OIDC callback
26523
+ * that was started from a signed-in user's "Link" button: the finish then
26524
+ * links this identity to the intent's user instead of signing anyone in.
26525
+ * The handle carries no user id — the hub resolves it, single-use.
26526
+ */
26527
+ linkIntent: string().optional(),
26528
+ /**
26529
+ * Verified `iss` of the id_token behind an OIDC login bridge (D782). A
26530
+ * subject is unique only per issuer, so a link is bound to it.
26531
+ */
26532
+ issuer: string().optional()
26182
26533
  });
26183
26534
  method(object({
26184
26535
  claims: SsoBridgeClaimsSchema,
@@ -27808,8 +28159,6 @@ var WebrtcStreamChoiceSchema = object({
27808
28159
  ]).nullable(),
27809
28160
  /** Input FPS from the camera (null for adaptive). */
27810
28161
  inputFps: number().nullable(),
27811
- /** Decoded FPS (null for adaptive). */
27812
- decodeFps: number().nullable(),
27813
28162
  /** Bitrate in kbps (null for adaptive). */
27814
28163
  bitrateKbps: number().nullable()
27815
28164
  });
@@ -28086,7 +28435,22 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
28086
28435
  * field their hints were silently stripped by the schema and the
28087
28436
  * adaptive ladder started blind on the client's display size.
28088
28437
  */
28089
- hints: webrtcClientHintsSchema.optional()
28438
+ hints: webrtcClientHintsSchema.optional(),
28439
+ /**
28440
+ * Talk-back (D771): relay the PEER's audio to the device's speaker
28441
+ * through the `intercom` cap's push-talk triple. When `true` and the
28442
+ * offer lets the peer send audio, the answer's audio is `sendrecv`
28443
+ * and every inbound frame goes to `intercom.pushTalkAudio` for this
28444
+ * `deviceId`; absent/false answers `sendonly`, as for every viewer.
28445
+ *
28446
+ * TRUSTED-CALLER ONLY. Set by the Alexa export for an Echo on a camera
28447
+ * with `intercom`, when the linked user may control that camera. The
28448
+ * hub STRIPS it from every request-bound call (a browser), exactly as
28449
+ * it overwrites `relayOnly` — a viewer's talk permission is the
28450
+ * intercom cap's own surface (share tokens gate it there), and this
28451
+ * flag must not become a second door to the camera's speaker.
28452
+ */
28453
+ talkback: boolean().optional()
28090
28454
  }), object({
28091
28455
  sessionId: string(),
28092
28456
  sdpAnswer: string()
@@ -28388,6 +28752,59 @@ var AddonAutoUpdateSchema = ChannelWithInheritSchema;
28388
28752
  var RestartAddonResultSchema = unknown();
28389
28753
  var InstallPackageResultSchema = unknown();
28390
28754
  var ReloadPackagesResultSchema = unknown();
28755
+ /**
28756
+ * What an uninstall did on ONE node.
28757
+ * - `uninstalled` — removed: runner(s) stopped, caps gone, code deleted.
28758
+ * - `not-installed` — the node did not have it (nothing to do).
28759
+ * - `refused` — protected / bootstrap package; nothing touched.
28760
+ * - `failed` — attempted and did not complete; `error` says why.
28761
+ * - `pending-reconnect` — the node is OFFLINE: its record was pruned so the
28762
+ * back-fill never returns the package, and the stale-addon sweep removes the
28763
+ * copy when the node registers again (only once the hub no longer has it).
28764
+ */
28765
+ var UninstallNodeOutcomeSchema = _enum([
28766
+ "uninstalled",
28767
+ "not-installed",
28768
+ "refused",
28769
+ "failed",
28770
+ "pending-reconnect"
28771
+ ]);
28772
+ var UninstallNodeResultSchema = object({
28773
+ nodeId: string(),
28774
+ outcome: UninstallNodeOutcomeSchema,
28775
+ error: string().optional(),
28776
+ addonIds: array(string()).readonly(),
28777
+ runnersStopped: array(string()).readonly(),
28778
+ warnings: array(string()).readonly()
28779
+ });
28780
+ var UninstallPackageResultSchema = object({
28781
+ /** Every targeted node ended `uninstalled`, `not-installed` or `pending-reconnect`. */
28782
+ success: boolean(),
28783
+ packageName: string(),
28784
+ results: array(UninstallNodeResultSchema).readonly()
28785
+ });
28786
+ /**
28787
+ * `unreachable` lists online agents whose status read FAILED — absence from
28788
+ * `installations` is only "not installed" for a node that answered (D315).
28789
+ */
28790
+ var PackageInstallationsSchema = object({
28791
+ installations: array(object({
28792
+ packageName: string(),
28793
+ nodeId: string(),
28794
+ nodeName: string(),
28795
+ isHub: boolean(),
28796
+ isOnline: boolean(),
28797
+ version: string().nullable(),
28798
+ addonIds: array(string()).readonly(),
28799
+ source: _enum(["live", "recorded"]),
28800
+ /** The hub installs this package too. `false` on an agent row = an orphan. */
28801
+ onHub: boolean()
28802
+ })).readonly(),
28803
+ unreachable: array(object({
28804
+ nodeId: string(),
28805
+ error: string()
28806
+ })).readonly()
28807
+ });
28391
28808
  var BulkUpdateItemStatusSchema = _enum([
28392
28809
  "queued",
28393
28810
  "updating",
@@ -28470,10 +28887,14 @@ method(_void(), array(AddonListItemSchema).readonly()), method(object({
28470
28887
  }), method(object({ packageName: string() }), InstallPackageResultSchema, {
28471
28888
  kind: "mutation",
28472
28889
  auth: "admin"
28473
- }), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({ packageName: string() }), unknown(), {
28890
+ }), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({
28891
+ packageName: string().min(1),
28892
+ nodeId: string().optional(),
28893
+ everywhere: boolean().optional()
28894
+ }), UninstallPackageResultSchema, {
28474
28895
  kind: "mutation",
28475
28896
  auth: "admin"
28476
- }), method(_void(), ReloadPackagesResultSchema, {
28897
+ }), method(object({ packageName: string().optional() }), PackageInstallationsSchema, { auth: "admin" }), method(_void(), ReloadPackagesResultSchema, {
28477
28898
  kind: "mutation",
28478
28899
  auth: "admin"
28479
28900
  }), method(object({ query: string().optional() }), array(SearchResultSchema)), method(object({ nodeId: string().optional() }), array(PackageUpdateSchema).readonly(), { auth: "admin" }), method(object({
@@ -30906,7 +31327,7 @@ var GetConnectionEndpointsResultSchema = object({
30906
31327
  localPort: AdvertisedLocalPortSchema
30907
31328
  });
30908
31329
  /**
30909
- * The address flagged for notification links. `baseUrl: null` = AUTO, which
31330
+ * The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
30910
31331
  * since D709 is the CamStack app link; `resolved` reports the effective value,
30911
31332
  * so the UI can show it either way.
30912
31333
  */
@@ -30941,8 +31362,8 @@ var ViewerEndpointsSchema = object({
30941
31362
  });
30942
31363
  /**
30943
31364
  * DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
30944
- * one release for addons built against it): `cluster` is the `agents` role,
30945
- * `browser` the `signIn` role; `override` is the flagged address.
31365
+ * for addons built against it): `cluster` is the `internal` role, `browser`
31366
+ * the `publicEndpoint` role; `override` is the flagged address.
30946
31367
  */
30947
31368
  var HubAddressSnapshotSchema = object({
30948
31369
  override: string().nullable(),
@@ -30958,15 +31379,11 @@ var HubAddressesSchema = object({
30958
31379
  browser: HubAddressSnapshotSchema
30959
31380
  });
30960
31381
  /**
30961
- * What an address is used for (`hub-address.ts`). `viewer` is many-valued;
30962
- * `notifications`, `agents` and `signIn` are carried by at most one address.
31382
+ * What an address is used for (`hub-address.ts`, D734). `appConnections` is
31383
+ * many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
31384
+ * by at most one address.
30963
31385
  */
30964
- var HubAddressRoleSchema = _enum([
30965
- "viewer",
30966
- "notifications",
30967
- "agents",
30968
- "signIn"
30969
- ]);
31386
+ var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
30970
31387
  var RoleSourceSchema = _enum([
30971
31388
  "flagged",
30972
31389
  "auto",
@@ -30980,8 +31397,8 @@ var HubAddressRoleResolutionSchema = object({
30980
31397
  resolved: string().nullable(),
30981
31398
  source: RoleSourceSchema
30982
31399
  });
30983
- var HubViewerResolutionSchema = object({
30984
- /** The addresses flagged `viewer`, or empty = automatic. */
31400
+ var HubAppConnectionsResolutionSchema = object({
31401
+ /** The addresses flagged `appConnections`, or empty = automatic. */
30985
31402
  flagged: array(string()).readonly(),
30986
31403
  /** What the apps race right now. */
30987
31404
  resolved: array(string()).readonly(),
@@ -31001,10 +31418,10 @@ var HubAddressBookSchema = object({
31001
31418
  eligible: array(HubAddressRoleSchema).readonly()
31002
31419
  })).readonly(),
31003
31420
  roles: object({
31004
- viewer: HubViewerResolutionSchema,
31005
- notifications: HubAddressRoleResolutionSchema,
31006
- agents: HubAddressRoleResolutionSchema,
31007
- signIn: HubAddressRoleResolutionSchema
31421
+ appConnections: HubAppConnectionsResolutionSchema,
31422
+ notificationTaps: HubAddressRoleResolutionSchema,
31423
+ internal: HubAddressRoleResolutionSchema,
31424
+ publicEndpoint: HubAddressRoleResolutionSchema
31008
31425
  }),
31009
31426
  /** The `hub=` an app link carries (D709), or null. */
31010
31427
  appLinkHub: string().nullable()
@@ -31052,7 +31469,7 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
31052
31469
  * tunnel always emits `https://` regardless. */
31053
31470
  scheme: _enum(["http", "https"]).optional(),
31054
31471
  /** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
31055
- * an address notification links can be flagged with, not a hub
31472
+ * an address notification taps can be flagged with, not a hub
31056
31473
  * route. Default `false`: racers and rankers never see it. */
31057
31474
  includeAppLink: boolean().optional()
31058
31475
  }), 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({
@@ -36096,6 +36513,32 @@ var TotpStatusSchema = object({
36096
36513
  /** Null when no row exists OR the row is still pending confirmation. */
36097
36514
  confirmedAt: number().nullable()
36098
36515
  });
36516
+ /**
36517
+ * user-management — singleton capability for user accounts, API keys,
36518
+ * and scoped tokens.
36519
+ *
36520
+ * v2 model: every method gated by `auth: 'admin'`. Admin-only delegation
36521
+ * — the subset check on `setUserScopes` / `createScopedToken` is moot
36522
+ * because non-admins never reach these. If/when we open non-admin
36523
+ * delegation, structural caller-scope subset check goes inside the
36524
+ * provider.
36525
+ */
36526
+ var ExternalIdentitySchema = object({
36527
+ /** Login-method id of the provider instance, e.g. `auth-oidc/authentik`. */
36528
+ provider: string(),
36529
+ /** The IdP's stable subject (`sub`) for this account. */
36530
+ subject: string(),
36531
+ /** The verified `iss` of the IdP the identity was linked under — `sub` is unique only per issuer. */
36532
+ issuer: string(),
36533
+ userId: string(),
36534
+ /** What the IdP called the account at link time (username / email) — display only. */
36535
+ label: string().optional(),
36536
+ linkedAt: number()
36537
+ });
36538
+ var ExternalIdentityKeySchema = object({
36539
+ provider: string().min(1),
36540
+ subject: string().min(1)
36541
+ });
36099
36542
  method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserInputSchema, UserSummarySchema, {
36100
36543
  kind: "mutation",
36101
36544
  auth: "admin",
@@ -36209,7 +36652,22 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserI
36209
36652
  userId: string(),
36210
36653
  username: string(),
36211
36654
  scopes: array(TokenScopeSchema)
36212
- }).nullable(), { access: "view" }), method(_void(), array(OauthSessionSummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: boolean() }), {
36655
+ }).nullable(), { access: "view" }), method(object({ userId: string() }), array(ExternalIdentitySchema), { auth: "admin" }), method(ExternalIdentityKeySchema, object({
36656
+ userId: string(),
36657
+ issuer: string()
36658
+ }).nullable(), { auth: "admin" }), method(ExternalIdentityKeySchema.extend({
36659
+ userId: string(),
36660
+ issuer: string().min(1),
36661
+ label: string().optional()
36662
+ }), object({ success: literal(true) }), {
36663
+ kind: "mutation",
36664
+ auth: "admin",
36665
+ access: "create"
36666
+ }), method(ExternalIdentityKeySchema.extend({ userId: string() }), object({ success: boolean() }), {
36667
+ kind: "mutation",
36668
+ auth: "admin",
36669
+ access: "delete"
36670
+ }), method(_void(), array(OauthSessionSummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: boolean() }), {
36213
36671
  kind: "mutation",
36214
36672
  auth: "admin",
36215
36673
  access: "delete"
@@ -36601,6 +37059,16 @@ DeviceType.Camera, method(object({
36601
37059
  package: array(ZoneRuleSchema).readonly()
36602
37060
  });
36603
37061
  SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
37062
+ Object.freeze({
37063
+ person: .5,
37064
+ vehicle: .5,
37065
+ animal: .5
37066
+ });
37067
+ Object.freeze({
37068
+ person: .65,
37069
+ vehicle: .65,
37070
+ animal: .65
37071
+ });
36604
37072
  /**
36605
37073
  * Accessory device helpers — shared across drivers.
36606
37074
  *
@@ -36775,6 +37243,12 @@ Object.freeze({
36775
37243
  addonId: null,
36776
37244
  access: "view"
36777
37245
  },
37246
+ "addons.listInstallations": {
37247
+ capName: "addons",
37248
+ capScope: "system",
37249
+ addonId: null,
37250
+ access: "view"
37251
+ },
36778
37252
  "addons.listJobs": {
36779
37253
  capName: "addons",
36780
37254
  capScope: "system",
@@ -37957,90 +38431,18 @@ Object.freeze({
37957
38431
  addonId: null,
37958
38432
  access: "create"
37959
38433
  },
37960
- "decoder.createSession": {
37961
- capName: "decoder",
37962
- capScope: "system",
37963
- addonId: null,
37964
- access: "view"
37965
- },
37966
- "decoder.destroySession": {
37967
- capName: "decoder",
37968
- capScope: "system",
37969
- addonId: null,
37970
- access: "delete"
37971
- },
37972
- "decoder.getFrame": {
37973
- capName: "decoder",
37974
- capScope: "system",
37975
- addonId: null,
37976
- access: "view"
37977
- },
37978
38434
  "decoder.getInfo": {
37979
38435
  capName: "decoder",
37980
38436
  capScope: "system",
37981
38437
  addonId: null,
37982
38438
  access: "view"
37983
38439
  },
37984
- "decoder.getShmStats": {
37985
- capName: "decoder",
37986
- capScope: "system",
37987
- addonId: null,
37988
- access: "view"
37989
- },
37990
- "decoder.getStats": {
37991
- capName: "decoder",
37992
- capScope: "system",
37993
- addonId: null,
37994
- access: "view"
37995
- },
37996
- "decoder.listActiveSessions": {
37997
- capName: "decoder",
37998
- capScope: "system",
37999
- addonId: null,
38000
- access: "view"
38001
- },
38002
- "decoder.openStream": {
38003
- capName: "decoder",
38004
- capScope: "system",
38005
- addonId: null,
38006
- access: "view"
38007
- },
38008
- "decoder.pullFrames": {
38009
- capName: "decoder",
38010
- capScope: "system",
38011
- addonId: null,
38012
- access: "view"
38013
- },
38014
- "decoder.pullHandles": {
38015
- capName: "decoder",
38016
- capScope: "system",
38017
- addonId: null,
38018
- access: "view"
38019
- },
38020
- "decoder.pushPacket": {
38021
- capName: "decoder",
38022
- capScope: "system",
38023
- addonId: null,
38024
- access: "view"
38025
- },
38026
38440
  "decoder.reprobeHwaccel": {
38027
38441
  capName: "decoder",
38028
38442
  capScope: "system",
38029
38443
  addonId: null,
38030
38444
  access: "create"
38031
38445
  },
38032
- "decoder.supportsCodec": {
38033
- capName: "decoder",
38034
- capScope: "system",
38035
- addonId: null,
38036
- access: "view"
38037
- },
38038
- "decoder.updateConfig": {
38039
- capName: "decoder",
38040
- capScope: "system",
38041
- addonId: null,
38042
- access: "view"
38043
- },
38044
38446
  "detectionPipeline.applyDeviceSettingsPatch": {
38045
38447
  capName: "detection-pipeline",
38046
38448
  capScope: "device",
@@ -41071,6 +41473,12 @@ Object.freeze({
41071
41473
  addonId: null,
41072
41474
  access: "create"
41073
41475
  },
41476
+ "pipelineAnalytics.setRetrainFrameComplete": {
41477
+ capName: "pipeline-analytics",
41478
+ capScope: "device",
41479
+ addonId: null,
41480
+ access: "create"
41481
+ },
41074
41482
  "pipelineAnalytics.setTrackFlags": {
41075
41483
  capName: "pipeline-analytics",
41076
41484
  capScope: "device",
@@ -41107,6 +41515,12 @@ Object.freeze({
41107
41515
  addonId: null,
41108
41516
  access: "delete"
41109
41517
  },
41518
+ "pipelineAnalytics.writeRetrainArchive": {
41519
+ capName: "pipeline-analytics",
41520
+ capScope: "device",
41521
+ addonId: null,
41522
+ access: "create"
41523
+ },
41110
41524
  "pipelineExecutor.cacheFrameInPool": {
41111
41525
  capName: "pipeline-executor",
41112
41526
  capScope: "system",
@@ -41119,13 +41533,13 @@ Object.freeze({
41119
41533
  addonId: null,
41120
41534
  access: "delete"
41121
41535
  },
41122
- "pipelineExecutor.deleteModel": {
41536
+ "pipelineExecutor.clearModelBoundDeviceOverrides": {
41123
41537
  capName: "pipeline-executor",
41124
41538
  capScope: "system",
41125
41539
  addonId: null,
41126
41540
  access: "delete"
41127
41541
  },
41128
- "pipelineExecutor.deleteTemplate": {
41542
+ "pipelineExecutor.deleteModel": {
41129
41543
  capName: "pipeline-executor",
41130
41544
  capScope: "system",
41131
41545
  addonId: null,
@@ -41269,12 +41683,6 @@ Object.freeze({
41269
41683
  addonId: null,
41270
41684
  access: "view"
41271
41685
  },
41272
- "pipelineExecutor.listTemplates": {
41273
- capName: "pipeline-executor",
41274
- capScope: "system",
41275
- addonId: null,
41276
- access: "view"
41277
- },
41278
41686
  "pipelineExecutor.rearmInferenceDevice": {
41279
41687
  capName: "pipeline-executor",
41280
41688
  capScope: "system",
@@ -41299,12 +41707,6 @@ Object.freeze({
41299
41707
  addonId: null,
41300
41708
  access: "create"
41301
41709
  },
41302
- "pipelineExecutor.saveTemplate": {
41303
- capName: "pipeline-executor",
41304
- capScope: "system",
41305
- addonId: null,
41306
- access: "create"
41307
- },
41308
41710
  "pipelineExecutor.setVideoPipelineSteps": {
41309
41711
  capName: "pipeline-executor",
41310
41712
  capScope: "system",
@@ -41323,41 +41725,35 @@ Object.freeze({
41323
41725
  addonId: null,
41324
41726
  access: "create"
41325
41727
  },
41326
- "pipelineExecutor.updateTemplate": {
41327
- capName: "pipeline-executor",
41328
- capScope: "system",
41329
- addonId: null,
41330
- access: "create"
41331
- },
41332
41728
  "pipelineExecutor.validatePipeline": {
41333
41729
  capName: "pipeline-executor",
41334
41730
  capScope: "system",
41335
41731
  addonId: null,
41336
41732
  access: "view"
41337
41733
  },
41338
- "pipelineOrchestrator.applyDeviceSettingsPatch": {
41734
+ "pipelineOrchestrator.applyAutoTune": {
41339
41735
  capName: "pipeline-orchestrator",
41340
41736
  capScope: "system",
41341
41737
  addonId: null,
41342
41738
  access: "create"
41343
41739
  },
41344
- "pipelineOrchestrator.assignAudio": {
41740
+ "pipelineOrchestrator.applyDeviceSettingsPatch": {
41345
41741
  capName: "pipeline-orchestrator",
41346
41742
  capScope: "system",
41347
41743
  addonId: null,
41348
41744
  access: "create"
41349
41745
  },
41350
- "pipelineOrchestrator.assignPipeline": {
41746
+ "pipelineOrchestrator.assignAudio": {
41351
41747
  capName: "pipeline-orchestrator",
41352
41748
  capScope: "system",
41353
41749
  addonId: null,
41354
41750
  access: "create"
41355
41751
  },
41356
- "pipelineOrchestrator.deleteTemplate": {
41752
+ "pipelineOrchestrator.assignPipeline": {
41357
41753
  capName: "pipeline-orchestrator",
41358
41754
  capScope: "system",
41359
41755
  addonId: null,
41360
- access: "delete"
41756
+ access: "create"
41361
41757
  },
41362
41758
  "pipelineOrchestrator.getAgentLoad": {
41363
41759
  capName: "pipeline-orchestrator",
@@ -41449,6 +41845,12 @@ Object.freeze({
41449
41845
  addonId: null,
41450
41846
  access: "view"
41451
41847
  },
41848
+ "pipelineOrchestrator.getEffectiveShares": {
41849
+ capName: "pipeline-orchestrator",
41850
+ capScope: "system",
41851
+ addonId: null,
41852
+ access: "view"
41853
+ },
41452
41854
  "pipelineOrchestrator.getGlobalMetrics": {
41453
41855
  capName: "pipeline-orchestrator",
41454
41856
  capScope: "system",
@@ -41485,19 +41887,19 @@ Object.freeze({
41485
41887
  addonId: null,
41486
41888
  access: "view"
41487
41889
  },
41488
- "pipelineOrchestrator.getReconcileFromDiskStatus": {
41890
+ "pipelineOrchestrator.getPlacementStats": {
41489
41891
  capName: "pipeline-orchestrator",
41490
41892
  capScope: "system",
41491
41893
  addonId: null,
41492
41894
  access: "view"
41493
41895
  },
41494
- "pipelineOrchestrator.listAgentSettings": {
41896
+ "pipelineOrchestrator.getReconcileFromDiskStatus": {
41495
41897
  capName: "pipeline-orchestrator",
41496
41898
  capScope: "system",
41497
41899
  addonId: null,
41498
41900
  access: "view"
41499
41901
  },
41500
- "pipelineOrchestrator.listTemplates": {
41902
+ "pipelineOrchestrator.listAgentSettings": {
41501
41903
  capName: "pipeline-orchestrator",
41502
41904
  capScope: "system",
41503
41905
  addonId: null,
@@ -41509,6 +41911,12 @@ Object.freeze({
41509
41911
  addonId: null,
41510
41912
  access: "create"
41511
41913
  },
41914
+ "pipelineOrchestrator.planAutoTune": {
41915
+ capName: "pipeline-orchestrator",
41916
+ capScope: "system",
41917
+ addonId: null,
41918
+ access: "view"
41919
+ },
41512
41920
  "pipelineOrchestrator.rebalance": {
41513
41921
  capName: "pipeline-orchestrator",
41514
41922
  capScope: "system",
@@ -41551,12 +41959,6 @@ Object.freeze({
41551
41959
  addonId: null,
41552
41960
  access: "create"
41553
41961
  },
41554
- "pipelineOrchestrator.saveTemplate": {
41555
- capName: "pipeline-orchestrator",
41556
- capScope: "system",
41557
- addonId: null,
41558
- access: "create"
41559
- },
41560
41962
  "pipelineOrchestrator.setAgentCapabilities": {
41561
41963
  capName: "pipeline-orchestrator",
41562
41964
  capScope: "system",
@@ -41569,12 +41971,6 @@ Object.freeze({
41569
41971
  addonId: null,
41570
41972
  access: "create"
41571
41973
  },
41572
- "pipelineOrchestrator.setAgentDetectWeight": {
41573
- capName: "pipeline-orchestrator",
41574
- capScope: "system",
41575
- addonId: null,
41576
- access: "create"
41577
- },
41578
41974
  "pipelineOrchestrator.setAgentInferenceDevices": {
41579
41975
  capName: "pipeline-orchestrator",
41580
41976
  capScope: "system",
@@ -41611,6 +42007,12 @@ Object.freeze({
41611
42007
  addonId: null,
41612
42008
  access: "create"
41613
42009
  },
42010
+ "pipelineOrchestrator.setCameraStepSettings": {
42011
+ capName: "pipeline-orchestrator",
42012
+ capScope: "system",
42013
+ addonId: null,
42014
+ access: "create"
42015
+ },
41614
42016
  "pipelineOrchestrator.setCameraStepToggle": {
41615
42017
  capName: "pipeline-orchestrator",
41616
42018
  capScope: "system",
@@ -41629,25 +42031,37 @@ Object.freeze({
41629
42031
  addonId: null,
41630
42032
  access: "create"
41631
42033
  },
42034
+ "pipelineOrchestrator.setLoadBalancingShares": {
42035
+ capName: "pipeline-orchestrator",
42036
+ capScope: "system",
42037
+ addonId: null,
42038
+ access: "create"
42039
+ },
41632
42040
  "pipelineOrchestrator.setPipelineDevicePin": {
41633
42041
  capName: "pipeline-orchestrator",
41634
42042
  capScope: "system",
41635
42043
  addonId: null,
41636
42044
  access: "create"
41637
42045
  },
41638
- "pipelineOrchestrator.unassignAudio": {
42046
+ "pipelineOrchestrator.setShareSource": {
41639
42047
  capName: "pipeline-orchestrator",
41640
42048
  capScope: "system",
41641
42049
  addonId: null,
41642
42050
  access: "create"
41643
42051
  },
41644
- "pipelineOrchestrator.unassignPipeline": {
42052
+ "pipelineOrchestrator.suggestShares": {
42053
+ capName: "pipeline-orchestrator",
42054
+ capScope: "system",
42055
+ addonId: null,
42056
+ access: "view"
42057
+ },
42058
+ "pipelineOrchestrator.unassignAudio": {
41645
42059
  capName: "pipeline-orchestrator",
41646
42060
  capScope: "system",
41647
42061
  addonId: null,
41648
42062
  access: "create"
41649
42063
  },
41650
- "pipelineOrchestrator.updateTemplate": {
42064
+ "pipelineOrchestrator.unassignPipeline": {
41651
42065
  capName: "pipeline-orchestrator",
41652
42066
  capScope: "system",
41653
42067
  addonId: null,
@@ -43087,12 +43501,6 @@ Object.freeze({
43087
43501
  addonId: null,
43088
43502
  access: "view"
43089
43503
  },
43090
- "streamBroker.pullFrameHandles": {
43091
- capName: "stream-broker",
43092
- capScope: "system",
43093
- addonId: null,
43094
- access: "view"
43095
- },
43096
43504
  "streamBroker.regenerateRtspToken": {
43097
43505
  capName: "stream-broker",
43098
43506
  capScope: "system",
@@ -43159,12 +43567,6 @@ Object.freeze({
43159
43567
  addonId: null,
43160
43568
  access: "create"
43161
43569
  },
43162
- "streamBroker.subscribeFrames": {
43163
- capName: "stream-broker",
43164
- capScope: "system",
43165
- addonId: null,
43166
- access: "create"
43167
- },
43168
43570
  "streamBroker.unassignProfile": {
43169
43571
  capName: "stream-broker",
43170
43572
  capScope: "system",
@@ -43177,12 +43579,6 @@ Object.freeze({
43177
43579
  addonId: null,
43178
43580
  access: "create"
43179
43581
  },
43180
- "streamBroker.unsubscribeFrames": {
43181
- capName: "stream-broker",
43182
- capScope: "system",
43183
- addonId: null,
43184
- access: "create"
43185
- },
43186
43582
  "streamCatalog.getCatalog": {
43187
43583
  capName: "stream-catalog",
43188
43584
  capScope: "device",
@@ -43477,18 +43873,36 @@ Object.freeze({
43477
43873
  addonId: null,
43478
43874
  access: "delete"
43479
43875
  },
43876
+ "userManagement.findUserByExternalIdentity": {
43877
+ capName: "user-management",
43878
+ capScope: "system",
43879
+ addonId: null,
43880
+ access: "view"
43881
+ },
43480
43882
  "userManagement.getTotpStatus": {
43481
43883
  capName: "user-management",
43482
43884
  capScope: "system",
43483
43885
  addonId: null,
43484
43886
  access: "view"
43485
43887
  },
43888
+ "userManagement.linkExternalIdentity": {
43889
+ capName: "user-management",
43890
+ capScope: "system",
43891
+ addonId: null,
43892
+ access: "create"
43893
+ },
43486
43894
  "userManagement.listApiKeys": {
43487
43895
  capName: "user-management",
43488
43896
  capScope: "system",
43489
43897
  addonId: null,
43490
43898
  access: "view"
43491
43899
  },
43900
+ "userManagement.listExternalIdentities": {
43901
+ capName: "user-management",
43902
+ capScope: "system",
43903
+ addonId: null,
43904
+ access: "view"
43905
+ },
43492
43906
  "userManagement.listOauthSessions": {
43493
43907
  capName: "user-management",
43494
43908
  capScope: "system",
@@ -43567,6 +43981,12 @@ Object.freeze({
43567
43981
  addonId: null,
43568
43982
  access: "create"
43569
43983
  },
43984
+ "userManagement.unlinkExternalIdentity": {
43985
+ capName: "user-management",
43986
+ capScope: "system",
43987
+ addonId: null,
43988
+ access: "delete"
43989
+ },
43570
43990
  "userManagement.updateUser": {
43571
43991
  capName: "user-management",
43572
43992
  capScope: "system",
@@ -45696,11 +46116,6 @@ Object.freeze({
45696
46116
  form: "single",
45697
46117
  optional: false
45698
46118
  }],
45699
- "decoder.createSession": [{
45700
- name: "deviceId",
45701
- form: "single",
45702
- optional: true
45703
- }],
45704
46119
  "detectionPipeline.applyDeviceSettingsPatch": [{
45705
46120
  name: "deviceId",
45706
46121
  form: "single",
@@ -46911,6 +47326,11 @@ Object.freeze({
46911
47326
  form: "single",
46912
47327
  optional: false
46913
47328
  }],
47329
+ "pipelineAnalytics.setRetrainFrameComplete": [{
47330
+ name: "deviceId",
47331
+ form: "single",
47332
+ optional: false
47333
+ }],
46914
47334
  "pipelineAnalytics.setTrackFlags": [{
46915
47335
  name: "deviceId",
46916
47336
  form: "single",
@@ -46931,6 +47351,11 @@ Object.freeze({
46931
47351
  form: "single",
46932
47352
  optional: false
46933
47353
  }],
47354
+ "pipelineExecutor.clearModelBoundDeviceOverrides": [{
47355
+ name: "deviceIds",
47356
+ form: "array",
47357
+ optional: true
47358
+ }],
46934
47359
  "pipelineExecutor.runPipeline": [{
46935
47360
  name: "deviceId",
46936
47361
  form: "single",
@@ -47036,6 +47461,11 @@ Object.freeze({
47036
47461
  form: "single",
47037
47462
  optional: false
47038
47463
  }],
47464
+ "pipelineOrchestrator.setCameraStepSettings": [{
47465
+ name: "deviceId",
47466
+ form: "single",
47467
+ optional: false
47468
+ }],
47039
47469
  "pipelineOrchestrator.setCameraStepToggle": [{
47040
47470
  name: "deviceId",
47041
47471
  form: "single",
@@ -48956,10 +49386,11 @@ var MB = 1024 * 1024;
48956
49386
  /**
48957
49387
  * Google Home export — customActions catalog.
48958
49388
  *
48959
- * One entry. The settings form's `type: 'button'` field dispatches through the
48960
- * generic `api.addons.custom.mutate({ addonId, action, input })` channel, so a
48961
- * button here costs no capability, no codegen and no framework publish train —
48962
- * the catalog travels inside this addon's own bundle.
49389
+ * One entry. The settings form's `addon-action-button` dispatches through the
49390
+ * generic `api.addons.custom.mutate({ addonId, action, input })` channel and
49391
+ * shows the result under the button, so a button here costs no capability, no
49392
+ * codegen and no framework publish train — the catalog travels inside this
49393
+ * addon's own bundle. Admin-only: it writes this addon's settings.
48963
49394
  */
48964
49395
  var exportGoogleActions = defineCustomActions({
48965
49396
  /**
@@ -48975,8 +49406,13 @@ var exportGoogleActions = defineCustomActions({
48975
49406
  detectPublicHubUrl: customAction(object({}).optional(), object({
48976
49407
  publicHubUrl: string(),
48977
49408
  detectedPublicHubUrl: string(),
48978
- filled: boolean()
48979
- }), { kind: "mutation" }) });
49409
+ filled: boolean(),
49410
+ /** One sentence saying what happened, for the button. */
49411
+ summary: string()
49412
+ }), {
49413
+ kind: "mutation",
49414
+ auth: "admin"
49415
+ }) });
48980
49416
  //#endregion
48981
49417
  //#region src/google-home/trait-catalog.ts
48982
49418
  /**
@@ -50005,6 +50441,14 @@ var refreshPublicHubUrl = async (deps) => {
50005
50441
  else if (resolution.publicHubUrl.length === 0) deps.logger.warn("export-google: public hub URL still unset after detection — the Google console URLs cannot be rendered until one is available", { meta: { detectedCount: detected.length } });
50006
50442
  return resolution;
50007
50443
  };
50444
+ /** What "Detect external address" did, in one sentence for the button. */
50445
+ function describeDetectResult(result) {
50446
+ const { publicHubUrl, detectedPublicHubUrl, filled } = result;
50447
+ if (filled) return `Filled in ${publicHubUrl}.`;
50448
+ if (detectedPublicHubUrl.length === 0) return publicHubUrl.length > 0 ? `No public HTTPS address detected; your value ${publicHubUrl} was kept.` : "No public HTTPS address detected. Set up remote access first.";
50449
+ if (detectedPublicHubUrl === publicHubUrl) return `Detected ${publicHubUrl}, already in use.`;
50450
+ return `Detected ${detectedPublicHubUrl}; your value ${publicHubUrl} was kept.`;
50451
+ }
50008
50452
  //#endregion
50009
50453
  //#region src/types.ts
50010
50454
  var DEFAULT_SETTINGS = {
@@ -50187,11 +50631,15 @@ var ExportGoogleAddon = class extends BaseAddon {
50187
50631
  persist: (patch) => this.updateGlobalSettings(patch),
50188
50632
  logger: this.ctx.logger
50189
50633
  });
50190
- return {
50634
+ const result = {
50191
50635
  publicHubUrl: resolution.publicHubUrl,
50192
50636
  detectedPublicHubUrl: resolution.detectedPublicHubUrl,
50193
50637
  filled: resolution.defaulted
50194
50638
  };
50639
+ return {
50640
+ ...result,
50641
+ summary: describeDetectResult(result)
50642
+ };
50195
50643
  }
50196
50644
  async onShutdown() {
50197
50645
  this.gateway = null;
@@ -50270,7 +50718,7 @@ var ExportGoogleAddon = class extends BaseAddon {
50270
50718
  globalSettingsSchema() {
50271
50719
  return this.schema({ sections: [{
50272
50720
  id: ADDON_ID,
50273
- title: "Google Home export",
50721
+ title: "Connection",
50274
50722
  description: "Publishes switches, dimmable lights, locks and covers to Google Home. The hub answers Google directly — no cloud function, and no Google credential is stored here.",
50275
50723
  columns: 1,
50276
50724
  fields: [
@@ -50300,13 +50748,15 @@ var ExportGoogleAddon = class extends BaseAddon {
50300
50748
  ...buildPublicHubUrlNotice(this.publicHubUrlState())
50301
50749
  },
50302
50750
  {
50303
- type: "button",
50751
+ type: "addon-action-button",
50752
+ addonId: ADDON_ID,
50304
50753
  key: "__detect-public-hub-url",
50305
50754
  label: "External address",
50306
50755
  description: "Re-scan the connected remote-access providers. Fills the field above when it is empty; a value you set is left exactly as it is.",
50307
50756
  buttonLabel: "Detect external address",
50308
50757
  action: "detectPublicHubUrl",
50309
- variant: "default"
50758
+ variant: "default",
50759
+ successMessage: "{summary}"
50310
50760
  }
50311
50761
  ]
50312
50762
  }] });