@camstack/addon-export-hap 1.2.150 → 1.2.152
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/hap-export.addon.js +760 -498
- package/dist/hap-export.addon.mjs +760 -498
- package/package.json +1 -1
package/dist/hap-export.addon.js
CHANGED
|
@@ -48,7 +48,7 @@ node_fs_promises = __toESM(node_fs_promises, 1);
|
|
|
48
48
|
let node_events = require("node:events");
|
|
49
49
|
let node_dgram = require("node:dgram");
|
|
50
50
|
let node_os = require("node:os");
|
|
51
|
-
//#region ../types/dist/event-category-
|
|
51
|
+
//#region ../types/dist/event-category-B_0XEcLF.mjs
|
|
52
52
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
53
53
|
EventCategory["SystemBoot"] = "system.boot";
|
|
54
54
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -549,15 +549,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
549
549
|
EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
|
|
550
550
|
EventCategory["AgentBackupActivated"] = "agent.backup.activated";
|
|
551
551
|
EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
|
|
552
|
-
/**
|
|
553
|
-
* Per-agent hwaccel preference changed (user override set, cleared, or
|
|
554
|
-
* re-probed). Observability event — decoders pull the current pref at
|
|
555
|
-
* `createSession`, so running sessions keep their current backend until
|
|
556
|
-
* they rotate naturally (camera add/remove, stream restart). Future
|
|
557
|
-
* work can wire a listener in stream-broker that force-rotates live
|
|
558
|
-
* sessions; for now this event powers logs + admin-UI toast feedback.
|
|
559
|
-
*/
|
|
560
|
-
EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
|
|
561
552
|
EventCategory["MotionAnalysis"] = "detection.motion-analysis";
|
|
562
553
|
/** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
|
|
563
554
|
EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
|
|
@@ -5428,7 +5419,7 @@ var ZodIssueCode = {
|
|
|
5428
5419
|
var ZodFirstPartyTypeKind;
|
|
5429
5420
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5430
5421
|
//#endregion
|
|
5431
|
-
//#region ../types/dist/sleep-
|
|
5422
|
+
//#region ../types/dist/sleep-BNeXenvr.mjs
|
|
5432
5423
|
/**
|
|
5433
5424
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5434
5425
|
* window to float samples (D455).
|
|
@@ -6794,32 +6785,12 @@ object({
|
|
|
6794
6785
|
audioCodec: string().optional(),
|
|
6795
6786
|
metadata: record(string(), unknown()).readonly().optional()
|
|
6796
6787
|
});
|
|
6797
|
-
var EncodedPacketSchema = object({
|
|
6798
|
-
type: _enum(["video", "audio"]),
|
|
6799
|
-
data: _instanceof(Uint8Array),
|
|
6800
|
-
pts: number(),
|
|
6801
|
-
dts: number(),
|
|
6802
|
-
keyframe: boolean(),
|
|
6803
|
-
codec: string()
|
|
6804
|
-
});
|
|
6805
|
-
var DecodedFrameSchema = object({
|
|
6806
|
-
data: _instanceof(Uint8Array),
|
|
6807
|
-
width: number(),
|
|
6808
|
-
height: number(),
|
|
6809
|
-
format: _enum([
|
|
6810
|
-
"jpeg",
|
|
6811
|
-
"rgb",
|
|
6812
|
-
"bgr",
|
|
6813
|
-
"yuv420",
|
|
6814
|
-
"gray"
|
|
6815
|
-
]),
|
|
6816
|
-
timestamp: number()
|
|
6817
|
-
});
|
|
6818
6788
|
/**
|
|
6819
6789
|
* Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
|
|
6820
6790
|
* frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
|
|
6821
|
-
* interface in `interfaces/frame-handle.ts` field-for-field so a
|
|
6822
|
-
*
|
|
6791
|
+
* interface in `interfaces/frame-handle.ts` field-for-field so a cap method
|
|
6792
|
+
* (the runner's native-crop and pipeline-executor inputs) can carry handles
|
|
6793
|
+
* over tRPC / Moleculer.
|
|
6823
6794
|
*
|
|
6824
6795
|
* The `satisfies` assertion below pins this schema to the interface: if a
|
|
6825
6796
|
* field is added to / removed from `FrameHandle` without a matching schema
|
|
@@ -6845,50 +6816,6 @@ var FrameHandleSchema = object({
|
|
|
6845
6816
|
slotCount: number().int().positive()
|
|
6846
6817
|
});
|
|
6847
6818
|
/**
|
|
6848
|
-
* Pixel format a frame-handle subscriber can request from the broker
|
|
6849
|
-
* (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
|
|
6850
|
-
* `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
|
|
6851
|
-
* `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
|
|
6852
|
-
* payload, and no decoded-frame consumer requests it over the shm plane.
|
|
6853
|
-
*/
|
|
6854
|
-
var FrameHandleFormatSchema = _enum([
|
|
6855
|
-
"rgb",
|
|
6856
|
-
"bgr",
|
|
6857
|
-
"yuv420",
|
|
6858
|
-
"gray"
|
|
6859
|
-
]);
|
|
6860
|
-
/**
|
|
6861
|
-
* Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
|
|
6862
|
-
* broker for a `FrameHandle` stream of one `format`; the broker maintains one
|
|
6863
|
-
* shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
|
|
6864
|
-
* subscriber (motion) and an `rgb` subscriber (detection) each read the format
|
|
6865
|
-
* they asked for with no broker-side conversion.
|
|
6866
|
-
*/
|
|
6867
|
-
var SubscribeFramesInputSchema = object({
|
|
6868
|
-
brokerId: string(),
|
|
6869
|
-
format: FrameHandleFormatSchema,
|
|
6870
|
-
/**
|
|
6871
|
-
* Optional reader-side cadence hint in frames per second. The broker does
|
|
6872
|
-
* NOT throttle — latest-wins ring reads drop frames implicitly for a slow
|
|
6873
|
-
* consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
|
|
6874
|
-
* the consumer can pace its own `pullFrameHandles` polling.
|
|
6875
|
-
*/
|
|
6876
|
-
maxFps: number().positive().optional(),
|
|
6877
|
-
/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
|
|
6878
|
-
tag: string().optional()
|
|
6879
|
-
});
|
|
6880
|
-
/**
|
|
6881
|
-
* Result of `stream-broker.subscribeFrames`. The consumer then polls
|
|
6882
|
-
* `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
|
|
6883
|
-
* `FrameHandle` to a `FrameRingReader`.
|
|
6884
|
-
*/
|
|
6885
|
-
var SubscribeFramesResultSchema = object({
|
|
6886
|
-
/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
|
|
6887
|
-
subscriptionId: string(),
|
|
6888
|
-
/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
|
|
6889
|
-
maxFps: number().nonnegative()
|
|
6890
|
-
});
|
|
6891
|
-
/**
|
|
6892
6819
|
* Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
|
|
6893
6820
|
* `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
|
|
6894
6821
|
* sample bytes plus the track parameters a consumer needs to interpret them.
|
|
@@ -6896,8 +6823,8 @@ var SubscribeFramesResultSchema = object({
|
|
|
6896
6823
|
* Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
|
|
6897
6824
|
* Float32 PCM), so unlike video frames they ship their bytes INLINE over
|
|
6898
6825
|
* tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
|
|
6899
|
-
* (the wire-serialisable supertype of `Buffer`)
|
|
6900
|
-
*
|
|
6826
|
+
* (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
|
|
6827
|
+
* it.
|
|
6901
6828
|
*/
|
|
6902
6829
|
var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
|
|
6903
6830
|
var DecodedAudioChunkSchema = object({
|
|
@@ -6915,11 +6842,10 @@ var DecodedAudioChunkSchema = object({
|
|
|
6915
6842
|
format: AudioChunkFormatSchema.optional()
|
|
6916
6843
|
});
|
|
6917
6844
|
/**
|
|
6918
|
-
* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9).
|
|
6919
|
-
*
|
|
6920
|
-
*
|
|
6921
|
-
*
|
|
6922
|
-
* `pullAudioChunks`.
|
|
6845
|
+
* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
|
|
6846
|
+
* its bytes inline: a consumer asks the broker for the decoded audio-chunk
|
|
6847
|
+
* stream of one broker; the broker keeps a per-subscription bounded FIFO queue
|
|
6848
|
+
* the consumer drains via `pullAudioChunks`.
|
|
6923
6849
|
*/
|
|
6924
6850
|
var SubscribeAudioChunksInputSchema = object({
|
|
6925
6851
|
brokerId: string(),
|
|
@@ -6950,9 +6876,7 @@ var BrokerStatsSchema = object({
|
|
|
6950
6876
|
"stopped"
|
|
6951
6877
|
]),
|
|
6952
6878
|
inputFps: number(),
|
|
6953
|
-
decodeFps: number(),
|
|
6954
6879
|
encodedSubscribers: number(),
|
|
6955
|
-
decodedSubscribers: number(),
|
|
6956
6880
|
uptimeMs: number(),
|
|
6957
6881
|
bitrateKbps: number(),
|
|
6958
6882
|
idrIntervalMs: number(),
|
|
@@ -6965,14 +6889,6 @@ var BrokerStatsSchema = object({
|
|
|
6965
6889
|
preBufferMs: number(),
|
|
6966
6890
|
preBufferPackets: number(),
|
|
6967
6891
|
/**
|
|
6968
|
-
* Moleculer node id of the decoder provider currently servicing this
|
|
6969
|
-
* stream's decoded subscribers. `null` until the deferred decoder is
|
|
6970
|
-
* created (no decoded clients yet, or codec not detected). Surfaces the
|
|
6971
|
-
* runtime decoder placement so the UI can show "Decoder: <agent>" without
|
|
6972
|
-
* a separate cap call per broker.
|
|
6973
|
-
*/
|
|
6974
|
-
decoderNodeId: string().nullable(),
|
|
6975
|
-
/**
|
|
6976
6892
|
* Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
|
|
6977
6893
|
* when the stream has no audio track or the broker is in cold start.
|
|
6978
6894
|
* `supported = false` means the codec was detected but the local
|
|
@@ -11094,70 +11010,6 @@ var StorageLocationDeclarationSchema = object({
|
|
|
11094
11010
|
"backup"
|
|
11095
11011
|
]).optional()
|
|
11096
11012
|
});
|
|
11097
|
-
var DecoderStatsSchema = object({
|
|
11098
|
-
inputFps: number(),
|
|
11099
|
-
outputFps: number(),
|
|
11100
|
-
avgDecodeTimeMs: number(),
|
|
11101
|
-
droppedFrames: number(),
|
|
11102
|
-
/**
|
|
11103
|
-
* Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
|
|
11104
|
-
* lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
|
|
11105
|
-
* the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
|
|
11106
|
-
* is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
|
|
11107
|
-
*/
|
|
11108
|
-
lagMs: number().optional(),
|
|
11109
|
-
effectiveFps: number().optional(),
|
|
11110
|
-
adaptiveFps: number().optional()
|
|
11111
|
-
});
|
|
11112
|
-
var DecoderSessionConfigSchema = object({
|
|
11113
|
-
codec: string(),
|
|
11114
|
-
maxFps: number().default(0),
|
|
11115
|
-
outputFormat: _enum([
|
|
11116
|
-
"jpeg",
|
|
11117
|
-
"rgb",
|
|
11118
|
-
"bgr",
|
|
11119
|
-
"yuv420",
|
|
11120
|
-
"gray"
|
|
11121
|
-
]).default("jpeg"),
|
|
11122
|
-
scale: number().default(1),
|
|
11123
|
-
width: number().optional(),
|
|
11124
|
-
height: number().optional(),
|
|
11125
|
-
/**
|
|
11126
|
-
* Identifier of the camera this decoder session serves. Optional
|
|
11127
|
-
* because the cap is generic (any caller could request decode), but
|
|
11128
|
-
* stream-broker passes it so decoder logs include `deviceId` for
|
|
11129
|
-
* per-camera filtering when diagnosing failures (e.g. node-av
|
|
11130
|
-
* sendPacket errors on a single hung camera).
|
|
11131
|
-
*/
|
|
11132
|
-
deviceId: number().int().nonnegative().optional(),
|
|
11133
|
-
/**
|
|
11134
|
-
* Free-form tag for log scoping. Stream-broker uses
|
|
11135
|
-
* `broker:<deviceId>/<profile>`. Decoder session logger surfaces it
|
|
11136
|
-
* on every line so `grep tag=broker:5/high` filters one camera
|
|
11137
|
-
* profile cleanly.
|
|
11138
|
-
*/
|
|
11139
|
-
tag: string().optional(),
|
|
11140
|
-
/**
|
|
11141
|
-
* Where the session delivers decoded frames (Phase 5 / D9):
|
|
11142
|
-
*
|
|
11143
|
-
* - `'callback'` (default) — the legacy pixel path: decoded frames are
|
|
11144
|
-
* buffered as `DecodedFrame`s and drained via `pullFrames`.
|
|
11145
|
-
* - `'shm'` — the shared-memory frame plane: decoded frames are written
|
|
11146
|
-
* into an OS shared-memory ring and drained as zero-pixel
|
|
11147
|
-
* `FrameHandle`s via `pullHandles`. A session is one mode or the
|
|
11148
|
-
* other — `pullFrames` returns nothing for an `'shm'` session and
|
|
11149
|
-
* `pullHandles` returns nothing for a `'callback'` session.
|
|
11150
|
-
*/
|
|
11151
|
-
frameSink: _enum(["callback", "shm"]).default("callback"),
|
|
11152
|
-
/**
|
|
11153
|
-
* Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
|
|
11154
|
-
* a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
|
|
11155
|
-
* real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
|
|
11156
|
-
* stream-broker's `streamingDebug` gate — off by default so production logs
|
|
11157
|
-
* stay quiet and the emit path pays zero per-frame cost when disabled.
|
|
11158
|
-
*/
|
|
11159
|
-
debug: boolean().optional()
|
|
11160
|
-
});
|
|
11161
11013
|
/**
|
|
11162
11014
|
* Per-component log CHANNELS — the gate a hot path consults, and the registry
|
|
11163
11015
|
* an addon declares its channels in.
|
|
@@ -11396,7 +11248,18 @@ var LABEL_SUPPLY_STEP_IDS = [
|
|
|
11396
11248
|
];
|
|
11397
11249
|
/** Steps whose box a root detection can BE. */
|
|
11398
11250
|
var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
|
|
11399
|
-
|
|
11251
|
+
/**
|
|
11252
|
+
* Steps whose per-detection MASK a root detection can carry (D737). The live
|
|
11253
|
+
* mask step is `segmentation` — a frame-plane refiner that runs its own model
|
|
11254
|
+
* once per detection crop. (`instance-segmentation` is a dormant step id that
|
|
11255
|
+
* no camera tree carries.)
|
|
11256
|
+
*/
|
|
11257
|
+
var MASK_SUPPLY_STEP_IDS = ["segmentation"];
|
|
11258
|
+
[
|
|
11259
|
+
...LABEL_SUPPLY_STEP_IDS,
|
|
11260
|
+
...CROP_SUPPLY_STEP_IDS,
|
|
11261
|
+
...MASK_SUPPLY_STEP_IDS
|
|
11262
|
+
];
|
|
11400
11263
|
var MODEL_FORMATS = [
|
|
11401
11264
|
"onnx",
|
|
11402
11265
|
"coreml",
|
|
@@ -11425,7 +11288,53 @@ var ModelFormatEntrySchema = object({
|
|
|
11425
11288
|
/** Multi-file payload (directory members or sibling files). */
|
|
11426
11289
|
files: array(string()).readonly().optional(),
|
|
11427
11290
|
/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
|
|
11428
|
-
runtimes: array(_enum(["python"])).readonly().optional()
|
|
11291
|
+
runtimes: array(_enum(["python"])).readonly().optional(),
|
|
11292
|
+
/**
|
|
11293
|
+
* Content revision of the artefact, for one hosted OFF the CamStack mirror.
|
|
11294
|
+
* A format on the mirror leaves it unset: its revision (the sha256 of its
|
|
11295
|
+
* weight file) comes from the downloader's generated table, kept in step
|
|
11296
|
+
* with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
|
|
11297
|
+
* node records the revision it downloaded next to the file
|
|
11298
|
+
* (`<file>.revision`); a copy with no record or a different one is stale
|
|
11299
|
+
* unless its weight file hashes to the revision, and a stale copy is
|
|
11300
|
+
* downloaded again, the old one serving until the new one is complete. No
|
|
11301
|
+
* revision at all ⇒ a file on disk is current, whatever it holds (D743).
|
|
11302
|
+
*/
|
|
11303
|
+
revision: string().min(1).optional()
|
|
11304
|
+
});
|
|
11305
|
+
/**
|
|
11306
|
+
* What a node holds for one (model, format) (D746). `current` is a complete
|
|
11307
|
+
* copy at its catalog revision — exactly what `downloaded: true` means.
|
|
11308
|
+
* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
|
|
11309
|
+
* no or a different revision record, or a missing sibling. `missing` is no
|
|
11310
|
+
* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
|
|
11311
|
+
* reclaimable bytes and a copy about to be replaced.
|
|
11312
|
+
*/
|
|
11313
|
+
var ModelOnDiskStateSchema = _enum([
|
|
11314
|
+
"current",
|
|
11315
|
+
"stale",
|
|
11316
|
+
"missing"
|
|
11317
|
+
]);
|
|
11318
|
+
/**
|
|
11319
|
+
* The numeric precision of one format's BUILD (D746) — reported only when the
|
|
11320
|
+
* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
|
|
11321
|
+
* CamStack Core ML export). Absent means "not stated", never "fp32".
|
|
11322
|
+
*/
|
|
11323
|
+
var ModelFormatPrecisionSchema = _enum([
|
|
11324
|
+
"fp32",
|
|
11325
|
+
"fp16",
|
|
11326
|
+
"int8"
|
|
11327
|
+
]);
|
|
11328
|
+
/**
|
|
11329
|
+
* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
|
|
11330
|
+
* `onDisk` / `precision` are optional for version skew: a runner that predates
|
|
11331
|
+
* them omits them, and a reader falls back to `downloaded`.
|
|
11332
|
+
*/
|
|
11333
|
+
var PipelineModelFormatStatusSchema = object({
|
|
11334
|
+
downloaded: boolean(),
|
|
11335
|
+
sizeMB: number(),
|
|
11336
|
+
onDisk: ModelOnDiskStateSchema.optional(),
|
|
11337
|
+
precision: ModelFormatPrecisionSchema.optional()
|
|
11429
11338
|
});
|
|
11430
11339
|
/**
|
|
11431
11340
|
* Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
|
|
@@ -11539,25 +11448,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
|
|
|
11539
11448
|
* - `crop`: the root draws the box the step would have found (`license_plate`
|
|
11540
11449
|
* for plate-detection, `face` for face-detection). The box becomes a detail
|
|
11541
11450
|
* child of the `parentMacro` detection that contains it — never a track.
|
|
11451
|
+
* - `mask`: the root's decode emits an instance mask with every detection (a
|
|
11452
|
+
* YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
|
|
11453
|
+
* detection in the shape that step produces. Derived from the model's
|
|
11454
|
+
* postprocessor on read, never stored by an import.
|
|
11542
11455
|
*/
|
|
11543
|
-
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
11544
|
-
|
|
11545
|
-
|
|
11546
|
-
|
|
11547
|
-
|
|
11548
|
-
|
|
11549
|
-
|
|
11550
|
-
|
|
11551
|
-
|
|
11552
|
-
|
|
11553
|
-
|
|
11554
|
-
|
|
11555
|
-
|
|
11556
|
-
|
|
11557
|
-
|
|
11558
|
-
|
|
11559
|
-
|
|
11560
|
-
|
|
11456
|
+
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
11457
|
+
object({
|
|
11458
|
+
kind: literal("label"),
|
|
11459
|
+
stepId: _enum(LABEL_SUPPLY_STEP_IDS),
|
|
11460
|
+
labelToEffect: record(string(), string()),
|
|
11461
|
+
uncovered: array(string()).readonly()
|
|
11462
|
+
}),
|
|
11463
|
+
object({
|
|
11464
|
+
kind: literal("crop"),
|
|
11465
|
+
stepId: _enum(CROP_SUPPLY_STEP_IDS),
|
|
11466
|
+
rootLabels: array(string()).readonly(),
|
|
11467
|
+
parentMacro: _enum(["vehicle", "person"]),
|
|
11468
|
+
childClass: _enum(["plate", "face"]),
|
|
11469
|
+
/**
|
|
11470
|
+
* The root's smaller input side, stamped on read by `rootSuppliesOf` from
|
|
11471
|
+
* the model entry — what a step's `minRootInputPx` gate judges. Never
|
|
11472
|
+
* stored by an import.
|
|
11473
|
+
*/
|
|
11474
|
+
rootInputPx: number().int().positive().optional()
|
|
11475
|
+
}),
|
|
11476
|
+
object({
|
|
11477
|
+
kind: literal("mask"),
|
|
11478
|
+
stepId: _enum(MASK_SUPPLY_STEP_IDS)
|
|
11479
|
+
})
|
|
11480
|
+
]);
|
|
11561
11481
|
var ModelCatalogEntrySchema = object({
|
|
11562
11482
|
id: string(),
|
|
11563
11483
|
name: string(),
|
|
@@ -11623,6 +11543,35 @@ var ModelCatalogEntrySchema = object({
|
|
|
11623
11543
|
*/
|
|
11624
11544
|
defaultConfidence: number().min(0).max(1).optional(),
|
|
11625
11545
|
/**
|
|
11546
|
+
* Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
|
|
11547
|
+
* on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
|
|
11548
|
+
* absent here runs at the step slider's global default. The same row shape
|
|
11549
|
+
* the floor measurement produces (`model-floors.json`: modelId → floors), so
|
|
11550
|
+
* a measured table is copied in as-is. An operator override is bound to the
|
|
11551
|
+
* model it was made for and does not survive a model change (D738). A custom
|
|
11552
|
+
* / imported model may declare it; without it, the global defaults apply.
|
|
11553
|
+
*/
|
|
11554
|
+
defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11555
|
+
/**
|
|
11556
|
+
* The inference precision this model's OpenVINO IR needs on an Intel GPU.
|
|
11557
|
+
* Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
|
|
11558
|
+
* that produces invalid output at f16 — measured 2026-10-07 for YOLO26
|
|
11559
|
+
* base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
|
|
11560
|
+
* scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
|
|
11561
|
+
* `PoolModelConfig.gpuInferencePrecision`; the pool sets
|
|
11562
|
+
* INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
|
|
11563
|
+
*/
|
|
11564
|
+
gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
|
|
11565
|
+
/**
|
|
11566
|
+
* ROOT detectors only: per supplied step (`animal-classifier`, …), the
|
|
11567
|
+
* minimum DETECTION score from which this root's own fine label (species,
|
|
11568
|
+
* vehicle type — D736 root supply) is taken (D741). Below it the detection
|
|
11569
|
+
* keeps its macro class without the fine label. `1` = never take it from
|
|
11570
|
+
* this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
|
|
11571
|
+
* `minConfidence` slider, bound to the ROOT model, overrides it.
|
|
11572
|
+
*/
|
|
11573
|
+
suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11574
|
+
/**
|
|
11626
11575
|
* When true, the executor produces a landmark-aligned crop (similarity warp
|
|
11627
11576
|
* onto the canonical template) before this step runs, instead of a plain
|
|
11628
11577
|
* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
|
|
@@ -13295,13 +13244,6 @@ var BrokerRtspClientSchema = object({
|
|
|
13295
13244
|
lastRtpAt: number(),
|
|
13296
13245
|
bytesSent: number()
|
|
13297
13246
|
});
|
|
13298
|
-
var BrokerDecodedClientSchema = object({
|
|
13299
|
-
tag: string(),
|
|
13300
|
-
subscribedAt: number(),
|
|
13301
|
-
maxFps: number(),
|
|
13302
|
-
framesDelivered: number(),
|
|
13303
|
-
framesDropped: number()
|
|
13304
|
-
});
|
|
13305
13247
|
var BrokerAudioClientSchema = object({
|
|
13306
13248
|
tag: string(),
|
|
13307
13249
|
subscribedAt: number(),
|
|
@@ -13393,7 +13335,6 @@ var BrokerEncodedClientSchema = object({
|
|
|
13393
13335
|
});
|
|
13394
13336
|
var BrokerClientsSchema = object({
|
|
13395
13337
|
rtsp: array(BrokerRtspClientSchema).readonly(),
|
|
13396
|
-
decoded: array(BrokerDecodedClientSchema).readonly(),
|
|
13397
13338
|
audio: array(BrokerAudioClientSchema).readonly(),
|
|
13398
13339
|
encoded: array(BrokerEncodedClientSchema).readonly(),
|
|
13399
13340
|
pipeClients: number(),
|
|
@@ -13762,11 +13703,7 @@ method(object({
|
|
|
13762
13703
|
auth: "admin"
|
|
13763
13704
|
}), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
|
|
13764
13705
|
brokerId: string(),
|
|
13765
|
-
channel: _enum([
|
|
13766
|
-
"rtsp",
|
|
13767
|
-
"decoded",
|
|
13768
|
-
"audio"
|
|
13769
|
-
]),
|
|
13706
|
+
channel: _enum(["rtsp", "audio"]),
|
|
13770
13707
|
handle: string()
|
|
13771
13708
|
}), object({ killed: boolean() }), {
|
|
13772
13709
|
kind: "mutation",
|
|
@@ -13801,10 +13738,7 @@ method(object({
|
|
|
13801
13738
|
}), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
|
|
13802
13739
|
subscriptionId: string(),
|
|
13803
13740
|
maxCount: number().int().positive().default(8)
|
|
13804
|
-
}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(
|
|
13805
|
-
subscriptionId: string(),
|
|
13806
|
-
maxCount: number().int().positive().default(4)
|
|
13807
|
-
}), array(FrameHandleSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
|
|
13741
|
+
}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
|
|
13808
13742
|
brokerId: string(),
|
|
13809
13743
|
seconds: number().min(0).max(30)
|
|
13810
13744
|
}), _void(), {
|
|
@@ -15017,54 +14951,12 @@ var HWACCEL_OPTIONS = [
|
|
|
15017
14951
|
label: "DRM (Linux generic)"
|
|
15018
14952
|
}
|
|
15019
14953
|
];
|
|
15020
|
-
|
|
15021
|
-
* shm ring usage stats for a `frameSink: 'shm'` decoder session —
|
|
15022
|
-
* exposed via `decoder.getShmStats` so downstream consumers can
|
|
15023
|
-
* observe ring pressure (slot count, byte budget, hit/miss ratio).
|
|
15024
|
-
*/
|
|
15025
|
-
var ShmRingStatsSchema = object({
|
|
15026
|
-
sessionId: string(),
|
|
15027
|
-
slotCount: number().int(),
|
|
15028
|
-
slotByteLength: number().int(),
|
|
15029
|
-
segmentBytes: number().int(),
|
|
15030
|
-
budgetMb: number().int(),
|
|
15031
|
-
framesWritten: number().int(),
|
|
15032
|
-
getFrameHits: number().int(),
|
|
15033
|
-
getFrameMisses: number().int()
|
|
15034
|
-
});
|
|
15035
|
-
method(object({ codec: string() }), boolean()), method(_void(), object({
|
|
14954
|
+
method(_void(), object({
|
|
15036
14955
|
id: string(),
|
|
15037
14956
|
name: string(),
|
|
15038
|
-
isPullMode: boolean().optional(),
|
|
15039
|
-
priority: number().optional(),
|
|
15040
14957
|
hwaccel: string().optional(),
|
|
15041
14958
|
probedBestHwaccel: string().optional()
|
|
15042
|
-
})), method(
|
|
15043
|
-
sessionId: string(),
|
|
15044
|
-
nodeId: string()
|
|
15045
|
-
})), method(object({ sessionId: string() }), _void()), method(object({
|
|
15046
|
-
sessionId: string(),
|
|
15047
|
-
packet: EncodedPacketSchema
|
|
15048
|
-
}), _void()), method(object({
|
|
15049
|
-
sessionId: string(),
|
|
15050
|
-
url: string()
|
|
15051
|
-
}), _void()), method(object({
|
|
15052
|
-
sessionId: string(),
|
|
15053
|
-
maxCount: number().default(1),
|
|
15054
|
-
waitMs: number().optional()
|
|
15055
|
-
}), array(DecodedFrameSchema)), method(object({
|
|
15056
|
-
sessionId: string(),
|
|
15057
|
-
maxCount: number().default(1),
|
|
15058
|
-
waitMs: number().optional()
|
|
15059
|
-
}), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
|
|
15060
|
-
sessionId: string(),
|
|
15061
|
-
config: DecoderSessionConfigSchema.partial()
|
|
15062
|
-
}), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
|
|
15063
|
-
sessionId: string(),
|
|
15064
|
-
codec: string(),
|
|
15065
|
-
outputFormat: string(),
|
|
15066
|
-
createdAtMs: number()
|
|
15067
|
-
})).readonly()), method(_void(), object({ backend: string() }), {
|
|
14959
|
+
})), method(_void(), object({ backend: string() }), {
|
|
15068
14960
|
kind: "mutation",
|
|
15069
14961
|
auth: "admin"
|
|
15070
14962
|
});
|
|
@@ -16933,6 +16825,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
|
|
|
16933
16825
|
kind: "mutation",
|
|
16934
16826
|
auth: "admin"
|
|
16935
16827
|
});
|
|
16828
|
+
var HUB_ADDRESS_ROLES = [
|
|
16829
|
+
"appConnections",
|
|
16830
|
+
"notificationTaps",
|
|
16831
|
+
"internal",
|
|
16832
|
+
"publicEndpoint"
|
|
16833
|
+
];
|
|
16936
16834
|
/**
|
|
16937
16835
|
* Transport bounds for AI capability methods.
|
|
16938
16836
|
*
|
|
@@ -21104,7 +21002,13 @@ var NcAlarmModeDelaysListSchema = array(object({
|
|
|
21104
21002
|
* Absent = false (logged, not sent). Even when true it is not sent when that same sensor
|
|
21105
21003
|
* is the one that starts the entry delay — the entry-delay notification already names it.
|
|
21106
21004
|
*/
|
|
21107
|
-
notifySensorRewatched: boolean().optional()
|
|
21005
|
+
notifySensorRewatched: boolean().optional(),
|
|
21006
|
+
/**
|
|
21007
|
+
* D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
|
|
21008
|
+
* change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
|
|
21009
|
+
* re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
|
|
21010
|
+
*/
|
|
21011
|
+
notifySensorIgnored: boolean().optional()
|
|
21108
21012
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
|
|
21109
21013
|
var NcAlarmModeDelaysEditListSchema = array(object({
|
|
21110
21014
|
mode: AlarmArmModeSchema,
|
|
@@ -21117,7 +21021,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
|
|
|
21117
21021
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21118
21022
|
notifyDuringEntryDelay: boolean().nullable().optional(),
|
|
21119
21023
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21120
|
-
notifySensorRewatched: boolean().nullable().optional()
|
|
21024
|
+
notifySensorRewatched: boolean().nullable().optional(),
|
|
21025
|
+
/** D735: set the switch, or `null` to clear it (back to the default, false). */
|
|
21026
|
+
notifySensorIgnored: boolean().nullable().optional()
|
|
21121
21027
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
|
|
21122
21028
|
/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
|
|
21123
21029
|
var NcAlarmNonBlockingEditSchema = object({
|
|
@@ -22095,8 +22001,8 @@ Object.freeze(Object.fromEntries([{
|
|
|
22095
22001
|
var CLUSTER_STEP_SETTING_FIELDS = [{
|
|
22096
22002
|
stepId: "face-embedding",
|
|
22097
22003
|
key: "minLandmarkFaceSize",
|
|
22098
|
-
label: "Min face size
|
|
22099
|
-
description: "
|
|
22004
|
+
label: "Min face size to embed (detection-frame px)",
|
|
22005
|
+
description: "Faces smaller than this in the small frame the detector sees are not embedded, so they can never be recognised. Below it the face cannot be aligned reliably and a bad embedding matches everyone. Same value on every node. 0 = no limit.",
|
|
22100
22006
|
type: "slider",
|
|
22101
22007
|
min: 0,
|
|
22102
22008
|
max: 64,
|
|
@@ -24091,7 +23997,7 @@ var FrameRefSchema = object({
|
|
|
24091
23997
|
timestamp: number(),
|
|
24092
23998
|
capturedAt: number().optional()
|
|
24093
23999
|
});
|
|
24094
|
-
var ModelFormatSchema$
|
|
24000
|
+
var ModelFormatSchema$2 = _enum([
|
|
24095
24001
|
"onnx",
|
|
24096
24002
|
"coreml",
|
|
24097
24003
|
"openvino",
|
|
@@ -24109,7 +24015,7 @@ var PipelineSlotSchema = _enum([
|
|
|
24109
24015
|
var PipelineEngineChoiceSchema = object({
|
|
24110
24016
|
runtime: literal("python"),
|
|
24111
24017
|
backend: string(),
|
|
24112
|
-
format: ModelFormatSchema$
|
|
24018
|
+
format: ModelFormatSchema$2,
|
|
24113
24019
|
device: string().optional()
|
|
24114
24020
|
});
|
|
24115
24021
|
/**
|
|
@@ -24148,28 +24054,10 @@ var PipelineDefaultStepSchema = lazy(() => object({
|
|
|
24148
24054
|
group: string().optional(),
|
|
24149
24055
|
settings: record(string(), unknown()).optional()
|
|
24150
24056
|
}));
|
|
24151
|
-
var PipelineTemplateStepSchema = lazy(() => object({
|
|
24152
|
-
addonId: string(),
|
|
24153
|
-
enabled: boolean(),
|
|
24154
|
-
modelId: string(),
|
|
24155
|
-
children: array(PipelineTemplateStepSchema).readonly(),
|
|
24156
|
-
settings: record(string(), unknown()).optional()
|
|
24157
|
-
}));
|
|
24158
|
-
var PipelineTemplateSchema$1 = object({
|
|
24159
|
-
id: string(),
|
|
24160
|
-
name: string(),
|
|
24161
|
-
createdAt: string(),
|
|
24162
|
-
updatedAt: string(),
|
|
24163
|
-
engine: PipelineEngineChoiceSchema,
|
|
24164
|
-
steps: array(PipelineTemplateStepSchema).readonly()
|
|
24165
|
-
});
|
|
24166
24057
|
var PipelineModelOptionSchema = object({
|
|
24167
24058
|
id: string(),
|
|
24168
24059
|
name: string(),
|
|
24169
|
-
formats: record(string(),
|
|
24170
|
-
downloaded: boolean(),
|
|
24171
|
-
sizeMB: number()
|
|
24172
|
-
})),
|
|
24060
|
+
formats: record(string(), PipelineModelFormatStatusSchema),
|
|
24173
24061
|
group: ModelVariantGroupSchema.optional(),
|
|
24174
24062
|
legacy: boolean().optional(),
|
|
24175
24063
|
provider: ModelProviderIdSchema.optional(),
|
|
@@ -24336,6 +24224,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24336
24224
|
}), {
|
|
24337
24225
|
kind: "mutation",
|
|
24338
24226
|
auth: "admin"
|
|
24227
|
+
}), method(object({
|
|
24228
|
+
nodeId: string(),
|
|
24229
|
+
deviceIds: array(number()).readonly().optional(),
|
|
24230
|
+
dryRun: boolean()
|
|
24231
|
+
}), object({
|
|
24232
|
+
entries: array(object({
|
|
24233
|
+
deviceId: number(),
|
|
24234
|
+
keys: array(string()).readonly()
|
|
24235
|
+
})).readonly(),
|
|
24236
|
+
refused: array(object({
|
|
24237
|
+
deviceId: number(),
|
|
24238
|
+
reason: string()
|
|
24239
|
+
})).readonly()
|
|
24240
|
+
}), {
|
|
24241
|
+
kind: "mutation",
|
|
24242
|
+
auth: "admin"
|
|
24339
24243
|
}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
|
|
24340
24244
|
/** `<backend>:<device>`, e.g. `openvino:gpu`. */
|
|
24341
24245
|
deviceKey: string(),
|
|
@@ -24361,22 +24265,14 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24361
24265
|
}), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
|
|
24362
24266
|
steps: array(PipelineStepInputSchema),
|
|
24363
24267
|
deviceKey: string().optional()
|
|
24364
|
-
}), PipelineValidationResultSchema), method(_void(),
|
|
24365
|
-
name: string(),
|
|
24366
|
-
steps: array(PipelineTemplateStepSchema).readonly(),
|
|
24367
|
-
engine: PipelineEngineChoiceSchema
|
|
24368
|
-
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
|
|
24369
|
-
id: string(),
|
|
24370
|
-
name: string().optional(),
|
|
24371
|
-
steps: array(PipelineTemplateStepSchema).readonly().optional()
|
|
24372
|
-
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24268
|
+
}), PipelineValidationResultSchema), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24373
24269
|
addonId: string(),
|
|
24374
24270
|
modelId: string(),
|
|
24375
|
-
format: ModelFormatSchema$
|
|
24271
|
+
format: ModelFormatSchema$2
|
|
24376
24272
|
}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
|
|
24377
24273
|
addonId: string(),
|
|
24378
24274
|
modelId: string(),
|
|
24379
|
-
format: ModelFormatSchema$
|
|
24275
|
+
format: ModelFormatSchema$2
|
|
24380
24276
|
}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
|
|
24381
24277
|
steps: array(PipelineStepInputSchema).min(1),
|
|
24382
24278
|
frame: FrameInputSchema.optional(),
|
|
@@ -24533,6 +24429,375 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24533
24429
|
filename: string().optional(),
|
|
24534
24430
|
settings: record(string(), unknown()).optional()
|
|
24535
24431
|
}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
|
|
24432
|
+
/**
|
|
24433
|
+
* The wire shapes of the Auto tune plan and apply (D745), used by the
|
|
24434
|
+
* `pipeline-orchestrator` cap. The recommender's own types
|
|
24435
|
+
* (`recommend.ts`) are the TS face of the same data; these
|
|
24436
|
+
* schemas are what crosses the cap boundary.
|
|
24437
|
+
*/
|
|
24438
|
+
var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
|
|
24439
|
+
/** The operator's range for it. */
|
|
24440
|
+
var MIN_SESSIONS_PER_DEVICE_RANGE = {
|
|
24441
|
+
min: 1,
|
|
24442
|
+
max: 8
|
|
24443
|
+
};
|
|
24444
|
+
var HardwareClassIdSchema = _enum([
|
|
24445
|
+
"intel-core-ultra",
|
|
24446
|
+
"intel-n-series",
|
|
24447
|
+
"apple-m-base",
|
|
24448
|
+
"apple-m-pro",
|
|
24449
|
+
"unknown"
|
|
24450
|
+
]);
|
|
24451
|
+
var AcceleratorKindSchema = _enum([
|
|
24452
|
+
"intel-npu",
|
|
24453
|
+
"intel-igpu",
|
|
24454
|
+
"x86-cpu",
|
|
24455
|
+
"arm-cpu",
|
|
24456
|
+
"apple-ane",
|
|
24457
|
+
"coral"
|
|
24458
|
+
]);
|
|
24459
|
+
var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
24460
|
+
object({
|
|
24461
|
+
kind: literal("capacity"),
|
|
24462
|
+
sessions: number(),
|
|
24463
|
+
minSessions: number()
|
|
24464
|
+
}),
|
|
24465
|
+
object({
|
|
24466
|
+
kind: literal("tie-faster"),
|
|
24467
|
+
over: string(),
|
|
24468
|
+
recallDelta: number()
|
|
24469
|
+
}),
|
|
24470
|
+
object({
|
|
24471
|
+
kind: literal("stepped-down"),
|
|
24472
|
+
from: string(),
|
|
24473
|
+
to: string(),
|
|
24474
|
+
limitedBy: string()
|
|
24475
|
+
}),
|
|
24476
|
+
object({
|
|
24477
|
+
kind: literal("no-fit-lightest"),
|
|
24478
|
+
sessions: number(),
|
|
24479
|
+
minSessions: number()
|
|
24480
|
+
}),
|
|
24481
|
+
object({
|
|
24482
|
+
kind: literal("derived-latency"),
|
|
24483
|
+
modelId: string()
|
|
24484
|
+
}),
|
|
24485
|
+
object({ kind: literal("cpu-device") }),
|
|
24486
|
+
object({ kind: literal("coral-untouched") }),
|
|
24487
|
+
object({ kind: literal("device-disabled") }),
|
|
24488
|
+
object({ kind: literal("device-unavailable") }),
|
|
24489
|
+
object({ kind: literal("node-offline") }),
|
|
24490
|
+
object({ kind: literal("no-hardware-facts") }),
|
|
24491
|
+
object({
|
|
24492
|
+
kind: literal("no-measured-data"),
|
|
24493
|
+
hardwareClass: HardwareClassIdSchema
|
|
24494
|
+
}),
|
|
24495
|
+
object({
|
|
24496
|
+
kind: literal("no-family-build"),
|
|
24497
|
+
format: ModelFormatSchema$1
|
|
24498
|
+
})
|
|
24499
|
+
]);
|
|
24500
|
+
var DeviceModelChoiceSchema = object({
|
|
24501
|
+
modelId: string(),
|
|
24502
|
+
p50Ms: number(),
|
|
24503
|
+
fps: number(),
|
|
24504
|
+
measured: boolean(),
|
|
24505
|
+
/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
|
|
24506
|
+
capacitySessions: number(),
|
|
24507
|
+
personRecall: number()
|
|
24508
|
+
});
|
|
24509
|
+
var DeviceRecommendationSchema = object({
|
|
24510
|
+
deviceKey: string(),
|
|
24511
|
+
accelerator: AcceleratorKindSchema.nullable(),
|
|
24512
|
+
enabled: boolean(),
|
|
24513
|
+
available: boolean(),
|
|
24514
|
+
chosen: DeviceModelChoiceSchema.nullable(),
|
|
24515
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24516
|
+
});
|
|
24517
|
+
var NodeRecommendationSchema = object({
|
|
24518
|
+
nodeId: string(),
|
|
24519
|
+
reachable: boolean(),
|
|
24520
|
+
hardwareClass: HardwareClassIdSchema.nullable(),
|
|
24521
|
+
cpuModel: string().nullable(),
|
|
24522
|
+
skipped: boolean(),
|
|
24523
|
+
acceleratorModelId: string().nullable(),
|
|
24524
|
+
devices: array(DeviceRecommendationSchema).readonly(),
|
|
24525
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24526
|
+
});
|
|
24527
|
+
var ModelPinChangeSchema = object({
|
|
24528
|
+
stepId: string(),
|
|
24529
|
+
before: string().nullable(),
|
|
24530
|
+
after: string().nullable()
|
|
24531
|
+
});
|
|
24532
|
+
var NodeDeviceChangeSchema = object({
|
|
24533
|
+
nodeId: string(),
|
|
24534
|
+
deviceKey: string(),
|
|
24535
|
+
madeExplicit: boolean(),
|
|
24536
|
+
modelPins: array(ModelPinChangeSchema).readonly(),
|
|
24537
|
+
thresholds: array(object({
|
|
24538
|
+
stepId: string(),
|
|
24539
|
+
keys: array(string()).readonly()
|
|
24540
|
+
})).readonly()
|
|
24541
|
+
});
|
|
24542
|
+
var CameraOverrideClearSchema = object({
|
|
24543
|
+
deviceId: number(),
|
|
24544
|
+
source: _enum(["step-override", "wholesale"]),
|
|
24545
|
+
nodeId: string(),
|
|
24546
|
+
deviceKey: string().nullable(),
|
|
24547
|
+
stepId: string(),
|
|
24548
|
+
modelIdBefore: string().nullable(),
|
|
24549
|
+
keys: array(string()).readonly()
|
|
24550
|
+
});
|
|
24551
|
+
var DetectorStoreClearSchema = object({
|
|
24552
|
+
deviceId: number(),
|
|
24553
|
+
keys: array(string()).readonly()
|
|
24554
|
+
});
|
|
24555
|
+
var AutoTuneWarningSchema = discriminatedUnion("kind", [
|
|
24556
|
+
object({
|
|
24557
|
+
kind: literal("detector-store-cluster-wide"),
|
|
24558
|
+
skippedNodes: array(string()).readonly()
|
|
24559
|
+
}),
|
|
24560
|
+
object({
|
|
24561
|
+
kind: literal("detector-store-unreadable"),
|
|
24562
|
+
error: string()
|
|
24563
|
+
}),
|
|
24564
|
+
object({
|
|
24565
|
+
kind: literal("coral-enabled"),
|
|
24566
|
+
nodeId: string(),
|
|
24567
|
+
deviceKey: string()
|
|
24568
|
+
})
|
|
24569
|
+
]);
|
|
24570
|
+
var AutoTuneOptionsSchema = object({
|
|
24571
|
+
/** Share of each accelerator's throughput kept free (0.3–0.5). */
|
|
24572
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24573
|
+
/**
|
|
24574
|
+
* The least number of parallel sessions every device must sustain at the
|
|
24575
|
+
* camera rate with the headroom kept free (D755). The most accurate model
|
|
24576
|
+
* that reaches it wins.
|
|
24577
|
+
*/
|
|
24578
|
+
minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
|
|
24579
|
+
});
|
|
24580
|
+
var AutoTunePlanSchema = object({
|
|
24581
|
+
/** Hash of everything the apply will write — the apply refuses a different one. */
|
|
24582
|
+
planHash: string(),
|
|
24583
|
+
family: literal("yolov9"),
|
|
24584
|
+
headroom: number(),
|
|
24585
|
+
minSessionsPerDevice: number(),
|
|
24586
|
+
/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
|
|
24587
|
+
cameraFps: number(),
|
|
24588
|
+
generatedAt: number(),
|
|
24589
|
+
nodes: array(NodeRecommendationSchema).readonly(),
|
|
24590
|
+
nodeChanges: array(NodeDeviceChangeSchema).readonly(),
|
|
24591
|
+
cameraClears: array(CameraOverrideClearSchema).readonly(),
|
|
24592
|
+
detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
|
|
24593
|
+
warnings: array(AutoTuneWarningSchema).readonly()
|
|
24594
|
+
});
|
|
24595
|
+
var AutoTuneApplyInputSchema = object({
|
|
24596
|
+
planHash: string(),
|
|
24597
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24598
|
+
minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
|
|
24599
|
+
});
|
|
24600
|
+
var AutoTunePhaseResultSchema = object({
|
|
24601
|
+
phase: _enum([
|
|
24602
|
+
"download",
|
|
24603
|
+
"camera-overrides",
|
|
24604
|
+
"detector-thresholds",
|
|
24605
|
+
"node-models",
|
|
24606
|
+
"redispatch"
|
|
24607
|
+
]),
|
|
24608
|
+
ok: boolean(),
|
|
24609
|
+
detail: string()
|
|
24610
|
+
});
|
|
24611
|
+
var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
|
|
24612
|
+
object({
|
|
24613
|
+
kind: literal("applied"),
|
|
24614
|
+
planHash: string(),
|
|
24615
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24616
|
+
}),
|
|
24617
|
+
object({
|
|
24618
|
+
kind: literal("aborted"),
|
|
24619
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24620
|
+
}),
|
|
24621
|
+
object({
|
|
24622
|
+
kind: literal("stale"),
|
|
24623
|
+
plan: AutoTunePlanSchema
|
|
24624
|
+
}),
|
|
24625
|
+
object({
|
|
24626
|
+
kind: literal("refused"),
|
|
24627
|
+
reason: _enum(["apply-in-progress"])
|
|
24628
|
+
})
|
|
24629
|
+
]);
|
|
24630
|
+
/**
|
|
24631
|
+
* Wire shapes of the Load balancing surface (D748): the session placement
|
|
24632
|
+
* policy, the atomic share write, the observed placement statistics, the
|
|
24633
|
+
* hardware share suggestion and the stale device pins.
|
|
24634
|
+
*/
|
|
24635
|
+
/**
|
|
24636
|
+
* How a new detection session picks its node and device.
|
|
24637
|
+
* - `least-loaded` — the historical rule: lowest `attached / weight`, a
|
|
24638
|
+
* constant node order at a tie (D37). An idle node always ties at 0, so a
|
|
24639
|
+
* weight only bites once a node already holds a session.
|
|
24640
|
+
* - `share` — the share of PARALLEL sessions is held to the weights, and a
|
|
24641
|
+
* full or drowning node yields to a free one (D748).
|
|
24642
|
+
*/
|
|
24643
|
+
var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
|
|
24644
|
+
var LoadBalancingSharesInputSchema = object({
|
|
24645
|
+
/** nodeId → share (> 0). A node left out keeps its weight. */
|
|
24646
|
+
nodes: record(string(), number().positive()).default({}),
|
|
24647
|
+
/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
|
|
24648
|
+
devices: record(string(), record(string(), number().positive())).default({})
|
|
24649
|
+
});
|
|
24650
|
+
var PlacementStatsInputSchema = object({
|
|
24651
|
+
/** Window the observed shares are averaged over (default 1 h, max 24 h). */
|
|
24652
|
+
windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
|
|
24653
|
+
var PlacementDeviceStatsSchema = object({
|
|
24654
|
+
deviceKey: string(),
|
|
24655
|
+
/** Sessions running on this device now. */
|
|
24656
|
+
sessionsNow: number(),
|
|
24657
|
+
/** Sessions started on this device inside the window. */
|
|
24658
|
+
sessionsStarted: number(),
|
|
24659
|
+
/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
|
|
24660
|
+
observedShare: number().nullable()
|
|
24661
|
+
});
|
|
24662
|
+
var PlacementNodeStatsSchema = object({
|
|
24663
|
+
nodeId: string(),
|
|
24664
|
+
sessionsNow: number(),
|
|
24665
|
+
sessionsStarted: number(),
|
|
24666
|
+
/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
|
|
24667
|
+
observedShare: number().nullable(),
|
|
24668
|
+
/** Most sessions this node ran at once inside the window. */
|
|
24669
|
+
peakSessions: number(),
|
|
24670
|
+
/** Sessions a share election handed elsewhere because this node was full or drowning. */
|
|
24671
|
+
yieldsAway: number(),
|
|
24672
|
+
devices: array(PlacementDeviceStatsSchema).readonly()
|
|
24673
|
+
});
|
|
24674
|
+
/** A camera's device pin that the session path cannot honour. */
|
|
24675
|
+
var StaleDevicePinSchema = object({
|
|
24676
|
+
deviceId: number(),
|
|
24677
|
+
deviceKey: string(),
|
|
24678
|
+
/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
|
|
24679
|
+
reason: _enum(["disabled", "absent"])
|
|
24680
|
+
});
|
|
24681
|
+
var PlacementStatsSchema = object({
|
|
24682
|
+
policy: SessionPlacementPolicySchema,
|
|
24683
|
+
windowMs: number(),
|
|
24684
|
+
/** How much of the window was actually observed (the hub keeps it in memory). */
|
|
24685
|
+
observedForMs: number(),
|
|
24686
|
+
sessionsNow: number(),
|
|
24687
|
+
/** Most parallel sessions across the cluster inside the window. */
|
|
24688
|
+
clusterPeakSessions: number(),
|
|
24689
|
+
nodes: array(PlacementNodeStatsSchema).readonly(),
|
|
24690
|
+
stalePins: array(StaleDevicePinSchema).readonly()
|
|
24691
|
+
});
|
|
24692
|
+
/**
|
|
24693
|
+
* Where an automatic share's capacity comes from (D755).
|
|
24694
|
+
* - `hardware` — the static capacity of each device at its Auto tune model:
|
|
24695
|
+
* the measured latency table for the node's hardware class.
|
|
24696
|
+
* - `benchmark` — the node's own measured capacity (node benchmark results).
|
|
24697
|
+
* A node with no results falls back to `hardware`, and says so.
|
|
24698
|
+
*/
|
|
24699
|
+
var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
|
|
24700
|
+
/** Why a node under the `benchmark` source was sized from hardware instead. */
|
|
24701
|
+
var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
|
|
24702
|
+
var SuggestSharesInputSchema = object({
|
|
24703
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24704
|
+
/** Default `hardware`. */
|
|
24705
|
+
source: CapacitySourceSchema.default("hardware")
|
|
24706
|
+
});
|
|
24707
|
+
var SuggestedDeviceShareSchema = object({
|
|
24708
|
+
deviceKey: string(),
|
|
24709
|
+
/** Share of the node (0–100, rounded). */
|
|
24710
|
+
share: number(),
|
|
24711
|
+
modelId: string().nullable(),
|
|
24712
|
+
/** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
|
|
24713
|
+
fps: number().nullable(),
|
|
24714
|
+
/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
|
|
24715
|
+
measured: boolean(),
|
|
24716
|
+
/**
|
|
24717
|
+
* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
|
|
24718
|
+
* or the benchmark's measured max sessions. Never enforced.
|
|
24719
|
+
*/
|
|
24720
|
+
suggestedMaxSessions: number().nullable()
|
|
24721
|
+
});
|
|
24722
|
+
var SuggestedNodeShareSchema = object({
|
|
24723
|
+
nodeId: string(),
|
|
24724
|
+
/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
|
|
24725
|
+
share: number().nullable(),
|
|
24726
|
+
/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
|
|
24727
|
+
capacitySessions: number(),
|
|
24728
|
+
devices: array(SuggestedDeviceShareSchema).readonly(),
|
|
24729
|
+
skippedReason: string().nullable(),
|
|
24730
|
+
/** What this node's capacity was read from; null when the node is skipped. */
|
|
24731
|
+
capacitySource: CapacitySourceSchema.nullable(),
|
|
24732
|
+
/** Set when the `benchmark` source was asked for and this node used `hardware`. */
|
|
24733
|
+
capacityFallback: CapacityFallbackSchema.nullable()
|
|
24734
|
+
});
|
|
24735
|
+
var SuggestSharesResultSchema = object({
|
|
24736
|
+
headroom: number(),
|
|
24737
|
+
/** The source asked for; each node says what it actually used. */
|
|
24738
|
+
source: CapacitySourceSchema,
|
|
24739
|
+
/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
|
|
24740
|
+
cameraFps: number(),
|
|
24741
|
+
/** The Auto tune capacity floor the models were picked at. */
|
|
24742
|
+
minSessionsPerDevice: number(),
|
|
24743
|
+
nodes: array(SuggestedNodeShareSchema).readonly()
|
|
24744
|
+
});
|
|
24745
|
+
/**
|
|
24746
|
+
* Where the node and device shares come from (D750, D755).
|
|
24747
|
+
* - `hardware` (default) — computed by the system from each node's static
|
|
24748
|
+
* capacity (its accelerators at their Auto tune models, from the measured
|
|
24749
|
+
* latency table), recomputed whenever a node or device joins, leaves, is
|
|
24750
|
+
* switched on or off, or changes model. No load input.
|
|
24751
|
+
* - `benchmark` — the same, from each node's measured capacity (node
|
|
24752
|
+
* benchmark results); a node without results falls back to `hardware`.
|
|
24753
|
+
* - `manual` — the operator's stored sliders.
|
|
24754
|
+
* Either way a node or device that cannot take sessions gives its share to
|
|
24755
|
+
* the others in proportion; the stored values are never rewritten for that.
|
|
24756
|
+
*/
|
|
24757
|
+
var ShareSourceSchema = _enum([
|
|
24758
|
+
"hardware",
|
|
24759
|
+
"benchmark",
|
|
24760
|
+
"manual"
|
|
24761
|
+
]);
|
|
24762
|
+
var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
|
|
24763
|
+
object({
|
|
24764
|
+
nodes: record(string(), number()),
|
|
24765
|
+
devices: record(string(), record(string(), number()))
|
|
24766
|
+
});
|
|
24767
|
+
var EffectiveDeviceShareSchema = object({
|
|
24768
|
+
deviceKey: string(),
|
|
24769
|
+
/** Can take sessions now (enabled, available, can run the root). */
|
|
24770
|
+
eligible: boolean(),
|
|
24771
|
+
/** The share the source assigns, as a percentage of the node's devices. */
|
|
24772
|
+
configuredPct: number(),
|
|
24773
|
+
/** The share actually used, after an ineligible device's share went to the others. */
|
|
24774
|
+
effectivePct: number()
|
|
24775
|
+
});
|
|
24776
|
+
var EffectiveNodeShareSchema = object({
|
|
24777
|
+
nodeId: string(),
|
|
24778
|
+
eligible: boolean(),
|
|
24779
|
+
configuredPct: number(),
|
|
24780
|
+
effectivePct: number(),
|
|
24781
|
+
/** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
|
|
24782
|
+
capacitySource: CapacitySourceSchema.nullable(),
|
|
24783
|
+
/** Automatic `benchmark`: why this node used `hardware` instead. */
|
|
24784
|
+
capacityFallback: CapacityFallbackSchema.nullable(),
|
|
24785
|
+
devices: array(EffectiveDeviceShareSchema).readonly()
|
|
24786
|
+
});
|
|
24787
|
+
var EffectiveSharesSchema = object({
|
|
24788
|
+
source: ShareSourceSchema,
|
|
24789
|
+
policy: SessionPlacementPolicySchema,
|
|
24790
|
+
/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
|
|
24791
|
+
autoPending: boolean(),
|
|
24792
|
+
/** When the automatic shares were last computed (ms epoch); null = never. */
|
|
24793
|
+
computedAt: number().nullable(),
|
|
24794
|
+
/** What made the system recompute them last. */
|
|
24795
|
+
trigger: string().nullable(),
|
|
24796
|
+
nodes: array(EffectiveNodeShareSchema).readonly(),
|
|
24797
|
+
/** The relative weights the election reads (before eligibility). */
|
|
24798
|
+
nodeWeights: record(string(), number()),
|
|
24799
|
+
deviceWeights: record(string(), record(string(), number()))
|
|
24800
|
+
});
|
|
24536
24801
|
object({
|
|
24537
24802
|
activeCameras: number(),
|
|
24538
24803
|
throttledCameras: number(),
|
|
@@ -25410,14 +25675,15 @@ var RunnerLocalLoadSchema = object({
|
|
|
25410
25675
|
* Per-inference-device live load (multi-device C4). One entry per deviceKey
|
|
25411
25676
|
* this runner currently has attached cameras on, so the orchestrator's second
|
|
25412
25677
|
* `balance()` pass (over a node's devices) weights on real per-pool session
|
|
25413
|
-
* counts. Empty on single-device / pre-multi-device runners.
|
|
25414
|
-
* per
|
|
25678
|
+
* counts. Empty on single-device / pre-multi-device runners. There is no
|
|
25679
|
+
* per-device queue depth: the inference pool's backlog has no accessor, and
|
|
25680
|
+
* a field that always read 0 was removed rather than shown as a measurement
|
|
25681
|
+
* (D762).
|
|
25415
25682
|
*/
|
|
25416
25683
|
devices: array(object({
|
|
25417
25684
|
deviceKey: string(),
|
|
25418
25685
|
backend: string(),
|
|
25419
|
-
attachedCameras: number()
|
|
25420
|
-
queueDepthTotal: number()
|
|
25686
|
+
attachedCameras: number()
|
|
25421
25687
|
})).default([]),
|
|
25422
25688
|
/** Hardware capability flags reported by this node. */
|
|
25423
25689
|
hardware: object({
|
|
@@ -25631,14 +25897,6 @@ var CameraPipelineConfigSchema = object({
|
|
|
25631
25897
|
settings: record(string(), unknown()).readonly().optional()
|
|
25632
25898
|
}).nullable().optional()
|
|
25633
25899
|
});
|
|
25634
|
-
var PipelineTemplateSchema = object({
|
|
25635
|
-
id: string(),
|
|
25636
|
-
name: string(),
|
|
25637
|
-
description: string().optional(),
|
|
25638
|
-
config: CameraPipelineConfigSchema,
|
|
25639
|
-
createdAt: string(),
|
|
25640
|
-
updatedAt: string()
|
|
25641
|
-
});
|
|
25642
25900
|
var DeviceStepConfigSchema = object({
|
|
25643
25901
|
modelId: string().optional(),
|
|
25644
25902
|
settings: record(string(), unknown()).optional(),
|
|
@@ -25712,9 +25970,10 @@ var CameraStepOverridePatchSchema = object({
|
|
|
25712
25970
|
modelId: string().optional(),
|
|
25713
25971
|
settings: record(string(), unknown()).readonly().optional()
|
|
25714
25972
|
});
|
|
25973
|
+
var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
|
|
25715
25974
|
var CameraPipelineSettingsSchema = object({
|
|
25716
|
-
pinnedAgentNodeId: string().optional(),
|
|
25717
25975
|
stepToggles: record(string(), boolean()).optional(),
|
|
25976
|
+
stepSettings: CameraStepSettingsSchema.optional(),
|
|
25718
25977
|
stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
|
|
25719
25978
|
pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
|
|
25720
25979
|
});
|
|
@@ -25747,7 +26006,10 @@ var PipelineAssignmentSchema = object({
|
|
|
25747
26006
|
});
|
|
25748
26007
|
/**
|
|
25749
26008
|
* Per-agent load summary surfaced to the load balancer + dashboards.
|
|
25750
|
-
* Aggregated from each runner's `getLocalLoad` cap call.
|
|
26009
|
+
* Aggregated from each runner's `getLocalLoad` cap call. In the
|
|
26010
|
+
* `getAgentLoad` report, a single-device node's default-pool sessions (no
|
|
26011
|
+
* `deviceKey`) are credited to its one eligible device in `load.devices` —
|
|
26012
|
+
* the default pool IS that device (D745); the balancer's census stays raw.
|
|
25751
26013
|
*/
|
|
25752
26014
|
var AgentLoadSummarySchema = object({
|
|
25753
26015
|
nodeId: string(),
|
|
@@ -25836,26 +26098,27 @@ var CameraBrokerStatusSchema = object({
|
|
|
25836
26098
|
width: number(),
|
|
25837
26099
|
height: number(),
|
|
25838
26100
|
subscribers: number(),
|
|
25839
|
-
|
|
25840
|
-
|
|
26101
|
+
/**
|
|
26102
|
+
* Encoded packets/s the broker receives from the camera. null when the
|
|
26103
|
+
* broker's stats read failed — unknown, never 0 (a 0 here reads as a stall).
|
|
26104
|
+
* There is no output rate: decoding runs in the session decode workers, not
|
|
26105
|
+
* in the broker, so the broker's own decoded-frame rate is 0 on every live
|
|
26106
|
+
* camera and is not served (D758).
|
|
26107
|
+
*/
|
|
26108
|
+
inFps: number().nullable()
|
|
25841
26109
|
})).readonly(),
|
|
25842
26110
|
webrtcSessions: number(),
|
|
25843
26111
|
rtspRestream: boolean()
|
|
25844
26112
|
});
|
|
25845
|
-
/**
|
|
25846
|
-
|
|
25847
|
-
|
|
25848
|
-
|
|
25849
|
-
|
|
25850
|
-
|
|
25851
|
-
|
|
25852
|
-
|
|
25853
|
-
var CameraDecoderStatusSchema = object({
|
|
25854
|
-
nodeId: string(),
|
|
25855
|
-
formats: array(string()).readonly(),
|
|
25856
|
-
sessionCount: number(),
|
|
25857
|
-
shm: CameraDecoderShmSchema
|
|
25858
|
-
});
|
|
26113
|
+
/**
|
|
26114
|
+
* Decoder block — WHERE decode runs (co-located with the detection node by
|
|
26115
|
+
* construction); null when the camera has no detection node. It carries no
|
|
26116
|
+
* frame counter: the shared-memory plane whose counters it used to serve is
|
|
26117
|
+
* gone, and those fields read 0 forever. Whether frames actually flow is read
|
|
26118
|
+
* from `detection.actualFps` (frames delivered to and processed by the
|
|
26119
|
+
* detector), never from a counter nothing feeds.
|
|
26120
|
+
*/
|
|
26121
|
+
var CameraDecoderStatusSchema = object({ nodeId: string() });
|
|
25859
26122
|
/** Motion block — null when motion detection is not active for this device. */
|
|
25860
26123
|
var CameraMotionStatusSchema = object({
|
|
25861
26124
|
enabled: boolean(),
|
|
@@ -26212,12 +26475,6 @@ method(object({
|
|
|
26212
26475
|
}), object({ success: literal(true) }), {
|
|
26213
26476
|
kind: "mutation",
|
|
26214
26477
|
auth: "admin"
|
|
26215
|
-
}), method(object({
|
|
26216
|
-
agentNodeId: string(),
|
|
26217
|
-
detectWeight: number().positive().nullable()
|
|
26218
|
-
}), object({ success: literal(true) }), {
|
|
26219
|
-
kind: "mutation",
|
|
26220
|
-
auth: "admin"
|
|
26221
26478
|
}), method(object({
|
|
26222
26479
|
agentNodeId: string(),
|
|
26223
26480
|
detect: boolean().nullable().optional(),
|
|
@@ -26259,6 +26516,15 @@ method(object({
|
|
|
26259
26516
|
}), {
|
|
26260
26517
|
kind: "mutation",
|
|
26261
26518
|
auth: "admin"
|
|
26519
|
+
}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
|
|
26520
|
+
kind: "mutation",
|
|
26521
|
+
auth: "admin"
|
|
26522
|
+
}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
|
|
26523
|
+
kind: "mutation",
|
|
26524
|
+
auth: "admin"
|
|
26525
|
+
}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
|
|
26526
|
+
kind: "mutation",
|
|
26527
|
+
auth: "admin"
|
|
26262
26528
|
}), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
|
|
26263
26529
|
deviceId: number(),
|
|
26264
26530
|
addonId: string(),
|
|
@@ -26275,6 +26541,13 @@ method(object({
|
|
|
26275
26541
|
}), object({ success: literal(true) }), {
|
|
26276
26542
|
kind: "mutation",
|
|
26277
26543
|
auth: "admin"
|
|
26544
|
+
}), method(object({
|
|
26545
|
+
deviceId: number(),
|
|
26546
|
+
addonId: string(),
|
|
26547
|
+
settings: record(string(), unknown()).nullable()
|
|
26548
|
+
}), object({ success: literal(true) }), {
|
|
26549
|
+
kind: "mutation",
|
|
26550
|
+
auth: "admin"
|
|
26278
26551
|
}), method(object({
|
|
26279
26552
|
deviceId: number(),
|
|
26280
26553
|
agentNodeId: string(),
|
|
@@ -26298,25 +26571,7 @@ method(object({
|
|
|
26298
26571
|
}), method(_void(), DiskReconcileJobSchema, {
|
|
26299
26572
|
kind: "mutation",
|
|
26300
26573
|
auth: "admin"
|
|
26301
|
-
}), method(_void(), DiskReconcileJobSchema, { auth: "admin" })
|
|
26302
|
-
name: string(),
|
|
26303
|
-
description: string().optional(),
|
|
26304
|
-
config: CameraPipelineConfigSchema
|
|
26305
|
-
}), PipelineTemplateSchema, {
|
|
26306
|
-
kind: "mutation",
|
|
26307
|
-
auth: "admin"
|
|
26308
|
-
}), method(object({
|
|
26309
|
-
id: string(),
|
|
26310
|
-
name: string().optional(),
|
|
26311
|
-
description: string().optional(),
|
|
26312
|
-
config: CameraPipelineConfigSchema.optional()
|
|
26313
|
-
}), PipelineTemplateSchema, {
|
|
26314
|
-
kind: "mutation",
|
|
26315
|
-
auth: "admin"
|
|
26316
|
-
}), method(object({ id: string() }), object({ success: literal(true) }), {
|
|
26317
|
-
kind: "mutation",
|
|
26318
|
-
auth: "admin"
|
|
26319
|
-
});
|
|
26574
|
+
}), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
|
|
26320
26575
|
/**
|
|
26321
26576
|
* Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
|
|
26322
26577
|
* `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
|
|
@@ -28729,8 +28984,6 @@ var WebrtcStreamChoiceSchema = object({
|
|
|
28729
28984
|
]).nullable(),
|
|
28730
28985
|
/** Input FPS from the camera (null for adaptive). */
|
|
28731
28986
|
inputFps: number().nullable(),
|
|
28732
|
-
/** Decoded FPS (null for adaptive). */
|
|
28733
|
-
decodeFps: number().nullable(),
|
|
28734
28987
|
/** Bitrate in kbps (null for adaptive). */
|
|
28735
28988
|
bitrateKbps: number().nullable()
|
|
28736
28989
|
});
|
|
@@ -29062,6 +29315,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
|
|
|
29062
29315
|
*/
|
|
29063
29316
|
alive: boolean()
|
|
29064
29317
|
})), method(object({
|
|
29318
|
+
deviceId: number().int().nonnegative(),
|
|
29319
|
+
sessionId: string(),
|
|
29320
|
+
downlinkMbps: number().nonnegative()
|
|
29321
|
+
}), object({
|
|
29322
|
+
outcome: _enum(["switching", "held"]),
|
|
29323
|
+
tier: CamProfileSchema.nullable(),
|
|
29324
|
+
reason: string()
|
|
29325
|
+
}), { kind: "mutation" }), method(object({
|
|
29065
29326
|
deviceId: number().int().nonnegative(),
|
|
29066
29327
|
sessionId: string()
|
|
29067
29328
|
}), WebrtcSessionDebugSchema, { kind: "query" });
|
|
@@ -31773,7 +32034,8 @@ var ConnectionEndpointSchema = object({
|
|
|
31773
32034
|
"lan-ipv6",
|
|
31774
32035
|
"public",
|
|
31775
32036
|
"loopback",
|
|
31776
|
-
"app-link"
|
|
32037
|
+
"app-link",
|
|
32038
|
+
"custom"
|
|
31777
32039
|
]),
|
|
31778
32040
|
/**
|
|
31779
32041
|
* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
|
|
@@ -31842,7 +32104,7 @@ var GetConnectionEndpointsResultSchema = object({
|
|
|
31842
32104
|
localPort: AdvertisedLocalPortSchema
|
|
31843
32105
|
});
|
|
31844
32106
|
/**
|
|
31845
|
-
* The address flagged for notification
|
|
32107
|
+
* The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
|
|
31846
32108
|
* since D709 is the CamStack app link; `resolved` reports the effective value,
|
|
31847
32109
|
* so the UI can show it either way.
|
|
31848
32110
|
*/
|
|
@@ -31876,13 +32138,12 @@ var ViewerEndpointsSchema = object({
|
|
|
31876
32138
|
resolved: array(string()).readonly()
|
|
31877
32139
|
});
|
|
31878
32140
|
/**
|
|
31879
|
-
*
|
|
31880
|
-
*
|
|
32141
|
+
* DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
|
|
32142
|
+
* for addons built against it): `cluster` is the `internal` role, `browser`
|
|
32143
|
+
* the `publicEndpoint` role; `override` is the flagged address.
|
|
31881
32144
|
*/
|
|
31882
32145
|
var HubAddressSnapshotSchema = object({
|
|
31883
|
-
/** The operator's override, or null for automatic. */
|
|
31884
32146
|
override: string().nullable(),
|
|
31885
|
-
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
31886
32147
|
resolved: string().nullable(),
|
|
31887
32148
|
source: _enum([
|
|
31888
32149
|
"override",
|
|
@@ -31891,11 +32152,57 @@ var HubAddressSnapshotSchema = object({
|
|
|
31891
32152
|
])
|
|
31892
32153
|
});
|
|
31893
32154
|
var HubAddressesSchema = object({
|
|
31894
|
-
/** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
|
|
31895
32155
|
cluster: HubAddressSnapshotSchema,
|
|
31896
|
-
/** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
|
|
31897
32156
|
browser: HubAddressSnapshotSchema
|
|
31898
32157
|
});
|
|
32158
|
+
/**
|
|
32159
|
+
* What an address is used for (`hub-address.ts`, D734). `appConnections` is
|
|
32160
|
+
* many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
|
|
32161
|
+
* by at most one address.
|
|
32162
|
+
*/
|
|
32163
|
+
var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
|
|
32164
|
+
var RoleSourceSchema = _enum([
|
|
32165
|
+
"flagged",
|
|
32166
|
+
"auto",
|
|
32167
|
+
"none"
|
|
32168
|
+
]);
|
|
32169
|
+
/** One single-valued role: the flagged address, the one in use, and why. */
|
|
32170
|
+
var HubAddressRoleResolutionSchema = object({
|
|
32171
|
+
/** The address carrying the flag, or null = automatic. */
|
|
32172
|
+
flagged: string().nullable(),
|
|
32173
|
+
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
32174
|
+
resolved: string().nullable(),
|
|
32175
|
+
source: RoleSourceSchema
|
|
32176
|
+
});
|
|
32177
|
+
var HubAppConnectionsResolutionSchema = object({
|
|
32178
|
+
/** The addresses flagged `appConnections`, or empty = automatic. */
|
|
32179
|
+
flagged: array(string()).readonly(),
|
|
32180
|
+
/** What the apps race right now. */
|
|
32181
|
+
resolved: array(string()).readonly(),
|
|
32182
|
+
source: RoleSourceSchema
|
|
32183
|
+
});
|
|
32184
|
+
var HubAddressBookSchema = object({
|
|
32185
|
+
rows: array(ConnectionEndpointSchema.extend({
|
|
32186
|
+
/** In the hub's detected palette right now. */
|
|
32187
|
+
detected: boolean(),
|
|
32188
|
+
/** Entered by the operator (removable). */
|
|
32189
|
+
custom: boolean(),
|
|
32190
|
+
/** The roles explicitly flagged on this address. */
|
|
32191
|
+
flags: array(HubAddressRoleSchema).readonly(),
|
|
32192
|
+
/** The roles this address serves right now — flagged or automatic. */
|
|
32193
|
+
inUse: array(HubAddressRoleSchema).readonly(),
|
|
32194
|
+
/** The roles this address may be flagged with. */
|
|
32195
|
+
eligible: array(HubAddressRoleSchema).readonly()
|
|
32196
|
+
})).readonly(),
|
|
32197
|
+
roles: object({
|
|
32198
|
+
appConnections: HubAppConnectionsResolutionSchema,
|
|
32199
|
+
notificationTaps: HubAddressRoleResolutionSchema,
|
|
32200
|
+
internal: HubAddressRoleResolutionSchema,
|
|
32201
|
+
publicEndpoint: HubAddressRoleResolutionSchema
|
|
32202
|
+
}),
|
|
32203
|
+
/** The `hub=` an app link carries (D709), or null. */
|
|
32204
|
+
appLinkHub: string().nullable()
|
|
32205
|
+
});
|
|
31899
32206
|
var AllowedAddressesSchema = object({
|
|
31900
32207
|
/**
|
|
31901
32208
|
* Allowlist of interface addresses operators have explicitly opted
|
|
@@ -31939,16 +32246,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
|
|
|
31939
32246
|
* tunnel always emits `https://` regardless. */
|
|
31940
32247
|
scheme: _enum(["http", "https"]).optional(),
|
|
31941
32248
|
/** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
|
|
31942
|
-
* an address notification
|
|
32249
|
+
* an address notification taps can be flagged with, not a hub
|
|
31943
32250
|
* route. Default `false`: racers and rankers never see it. */
|
|
31944
32251
|
includeAppLink: boolean().optional()
|
|
31945
|
-
}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(
|
|
31946
|
-
|
|
31947
|
-
|
|
31948
|
-
}),
|
|
32252
|
+
}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(object({ scheme: _enum(["http", "https"]).optional() }).optional(), HubAddressBookSchema), method(object({
|
|
32253
|
+
baseUrl: string(),
|
|
32254
|
+
label: string().max(80)
|
|
32255
|
+
}), HubAddressBookSchema, {
|
|
31949
32256
|
kind: "mutation",
|
|
31950
32257
|
auth: "admin"
|
|
31951
|
-
}), method(
|
|
32258
|
+
}), method(object({ baseUrl: string() }), HubAddressBookSchema, {
|
|
32259
|
+
kind: "mutation",
|
|
32260
|
+
auth: "admin"
|
|
32261
|
+
}), method(object({
|
|
32262
|
+
role: HubAddressRoleSchema,
|
|
32263
|
+
baseUrl: string().nullable(),
|
|
32264
|
+
enabled: boolean(),
|
|
32265
|
+
acceptInsecureHttp: boolean().optional()
|
|
32266
|
+
}), HubAddressBookSchema, {
|
|
32267
|
+
kind: "mutation",
|
|
32268
|
+
auth: "admin"
|
|
32269
|
+
}), method(_void(), HubAddressesSchema), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
|
|
31952
32270
|
kind: "mutation",
|
|
31953
32271
|
auth: "admin"
|
|
31954
32272
|
}), method(object({
|
|
@@ -37495,6 +37813,16 @@ DeviceType.Camera, method(object({
|
|
|
37495
37813
|
package: array(ZoneRuleSchema).readonly()
|
|
37496
37814
|
});
|
|
37497
37815
|
SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
|
|
37816
|
+
Object.freeze({
|
|
37817
|
+
person: .5,
|
|
37818
|
+
vehicle: .5,
|
|
37819
|
+
animal: .5
|
|
37820
|
+
});
|
|
37821
|
+
Object.freeze({
|
|
37822
|
+
person: .65,
|
|
37823
|
+
vehicle: .65,
|
|
37824
|
+
animal: .65
|
|
37825
|
+
});
|
|
37498
37826
|
/**
|
|
37499
37827
|
* Accessory device helpers — shared across drivers.
|
|
37500
37828
|
*
|
|
@@ -38851,90 +39179,18 @@ Object.freeze({
|
|
|
38851
39179
|
addonId: null,
|
|
38852
39180
|
access: "create"
|
|
38853
39181
|
},
|
|
38854
|
-
"decoder.createSession": {
|
|
38855
|
-
capName: "decoder",
|
|
38856
|
-
capScope: "system",
|
|
38857
|
-
addonId: null,
|
|
38858
|
-
access: "view"
|
|
38859
|
-
},
|
|
38860
|
-
"decoder.destroySession": {
|
|
38861
|
-
capName: "decoder",
|
|
38862
|
-
capScope: "system",
|
|
38863
|
-
addonId: null,
|
|
38864
|
-
access: "delete"
|
|
38865
|
-
},
|
|
38866
|
-
"decoder.getFrame": {
|
|
38867
|
-
capName: "decoder",
|
|
38868
|
-
capScope: "system",
|
|
38869
|
-
addonId: null,
|
|
38870
|
-
access: "view"
|
|
38871
|
-
},
|
|
38872
39182
|
"decoder.getInfo": {
|
|
38873
39183
|
capName: "decoder",
|
|
38874
39184
|
capScope: "system",
|
|
38875
39185
|
addonId: null,
|
|
38876
39186
|
access: "view"
|
|
38877
39187
|
},
|
|
38878
|
-
"decoder.getShmStats": {
|
|
38879
|
-
capName: "decoder",
|
|
38880
|
-
capScope: "system",
|
|
38881
|
-
addonId: null,
|
|
38882
|
-
access: "view"
|
|
38883
|
-
},
|
|
38884
|
-
"decoder.getStats": {
|
|
38885
|
-
capName: "decoder",
|
|
38886
|
-
capScope: "system",
|
|
38887
|
-
addonId: null,
|
|
38888
|
-
access: "view"
|
|
38889
|
-
},
|
|
38890
|
-
"decoder.listActiveSessions": {
|
|
38891
|
-
capName: "decoder",
|
|
38892
|
-
capScope: "system",
|
|
38893
|
-
addonId: null,
|
|
38894
|
-
access: "view"
|
|
38895
|
-
},
|
|
38896
|
-
"decoder.openStream": {
|
|
38897
|
-
capName: "decoder",
|
|
38898
|
-
capScope: "system",
|
|
38899
|
-
addonId: null,
|
|
38900
|
-
access: "view"
|
|
38901
|
-
},
|
|
38902
|
-
"decoder.pullFrames": {
|
|
38903
|
-
capName: "decoder",
|
|
38904
|
-
capScope: "system",
|
|
38905
|
-
addonId: null,
|
|
38906
|
-
access: "view"
|
|
38907
|
-
},
|
|
38908
|
-
"decoder.pullHandles": {
|
|
38909
|
-
capName: "decoder",
|
|
38910
|
-
capScope: "system",
|
|
38911
|
-
addonId: null,
|
|
38912
|
-
access: "view"
|
|
38913
|
-
},
|
|
38914
|
-
"decoder.pushPacket": {
|
|
38915
|
-
capName: "decoder",
|
|
38916
|
-
capScope: "system",
|
|
38917
|
-
addonId: null,
|
|
38918
|
-
access: "view"
|
|
38919
|
-
},
|
|
38920
39188
|
"decoder.reprobeHwaccel": {
|
|
38921
39189
|
capName: "decoder",
|
|
38922
39190
|
capScope: "system",
|
|
38923
39191
|
addonId: null,
|
|
38924
39192
|
access: "create"
|
|
38925
39193
|
},
|
|
38926
|
-
"decoder.supportsCodec": {
|
|
38927
|
-
capName: "decoder",
|
|
38928
|
-
capScope: "system",
|
|
38929
|
-
addonId: null,
|
|
38930
|
-
access: "view"
|
|
38931
|
-
},
|
|
38932
|
-
"decoder.updateConfig": {
|
|
38933
|
-
capName: "decoder",
|
|
38934
|
-
capScope: "system",
|
|
38935
|
-
addonId: null,
|
|
38936
|
-
access: "view"
|
|
38937
|
-
},
|
|
38938
39194
|
"detectionPipeline.applyDeviceSettingsPatch": {
|
|
38939
39195
|
capName: "detection-pipeline",
|
|
38940
39196
|
capScope: "device",
|
|
@@ -40423,12 +40679,24 @@ Object.freeze({
|
|
|
40423
40679
|
addonId: null,
|
|
40424
40680
|
access: "view"
|
|
40425
40681
|
},
|
|
40682
|
+
"localNetwork.addCustomAddress": {
|
|
40683
|
+
capName: "local-network",
|
|
40684
|
+
capScope: "system",
|
|
40685
|
+
addonId: null,
|
|
40686
|
+
access: "create"
|
|
40687
|
+
},
|
|
40426
40688
|
"localNetwork.downloadCa": {
|
|
40427
40689
|
capName: "local-network",
|
|
40428
40690
|
capScope: "system",
|
|
40429
40691
|
addonId: null,
|
|
40430
40692
|
access: "view"
|
|
40431
40693
|
},
|
|
40694
|
+
"localNetwork.getAddresses": {
|
|
40695
|
+
capName: "local-network",
|
|
40696
|
+
capScope: "system",
|
|
40697
|
+
addonId: null,
|
|
40698
|
+
access: "view"
|
|
40699
|
+
},
|
|
40432
40700
|
"localNetwork.getAllowedAddresses": {
|
|
40433
40701
|
capName: "local-network",
|
|
40434
40702
|
capScope: "system",
|
|
@@ -40483,6 +40751,12 @@ Object.freeze({
|
|
|
40483
40751
|
addonId: null,
|
|
40484
40752
|
access: "create"
|
|
40485
40753
|
},
|
|
40754
|
+
"localNetwork.removeCustomAddress": {
|
|
40755
|
+
capName: "local-network",
|
|
40756
|
+
capScope: "system",
|
|
40757
|
+
addonId: null,
|
|
40758
|
+
access: "delete"
|
|
40759
|
+
},
|
|
40486
40760
|
"localNetwork.resetAllowlistToBestMatch": {
|
|
40487
40761
|
capName: "local-network",
|
|
40488
40762
|
capScope: "system",
|
|
@@ -40495,13 +40769,13 @@ Object.freeze({
|
|
|
40495
40769
|
addonId: null,
|
|
40496
40770
|
access: "create"
|
|
40497
40771
|
},
|
|
40498
|
-
"localNetwork.
|
|
40772
|
+
"localNetwork.setAddressRole": {
|
|
40499
40773
|
capName: "local-network",
|
|
40500
40774
|
capScope: "system",
|
|
40501
40775
|
addonId: null,
|
|
40502
40776
|
access: "create"
|
|
40503
40777
|
},
|
|
40504
|
-
"localNetwork.
|
|
40778
|
+
"localNetwork.setAllowedAddresses": {
|
|
40505
40779
|
capName: "local-network",
|
|
40506
40780
|
capScope: "system",
|
|
40507
40781
|
addonId: null,
|
|
@@ -41995,13 +42269,13 @@ Object.freeze({
|
|
|
41995
42269
|
addonId: null,
|
|
41996
42270
|
access: "delete"
|
|
41997
42271
|
},
|
|
41998
|
-
"pipelineExecutor.
|
|
42272
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": {
|
|
41999
42273
|
capName: "pipeline-executor",
|
|
42000
42274
|
capScope: "system",
|
|
42001
42275
|
addonId: null,
|
|
42002
42276
|
access: "delete"
|
|
42003
42277
|
},
|
|
42004
|
-
"pipelineExecutor.
|
|
42278
|
+
"pipelineExecutor.deleteModel": {
|
|
42005
42279
|
capName: "pipeline-executor",
|
|
42006
42280
|
capScope: "system",
|
|
42007
42281
|
addonId: null,
|
|
@@ -42145,12 +42419,6 @@ Object.freeze({
|
|
|
42145
42419
|
addonId: null,
|
|
42146
42420
|
access: "view"
|
|
42147
42421
|
},
|
|
42148
|
-
"pipelineExecutor.listTemplates": {
|
|
42149
|
-
capName: "pipeline-executor",
|
|
42150
|
-
capScope: "system",
|
|
42151
|
-
addonId: null,
|
|
42152
|
-
access: "view"
|
|
42153
|
-
},
|
|
42154
42422
|
"pipelineExecutor.rearmInferenceDevice": {
|
|
42155
42423
|
capName: "pipeline-executor",
|
|
42156
42424
|
capScope: "system",
|
|
@@ -42175,12 +42443,6 @@ Object.freeze({
|
|
|
42175
42443
|
addonId: null,
|
|
42176
42444
|
access: "create"
|
|
42177
42445
|
},
|
|
42178
|
-
"pipelineExecutor.saveTemplate": {
|
|
42179
|
-
capName: "pipeline-executor",
|
|
42180
|
-
capScope: "system",
|
|
42181
|
-
addonId: null,
|
|
42182
|
-
access: "create"
|
|
42183
|
-
},
|
|
42184
42446
|
"pipelineExecutor.setVideoPipelineSteps": {
|
|
42185
42447
|
capName: "pipeline-executor",
|
|
42186
42448
|
capScope: "system",
|
|
@@ -42199,41 +42461,35 @@ Object.freeze({
|
|
|
42199
42461
|
addonId: null,
|
|
42200
42462
|
access: "create"
|
|
42201
42463
|
},
|
|
42202
|
-
"pipelineExecutor.updateTemplate": {
|
|
42203
|
-
capName: "pipeline-executor",
|
|
42204
|
-
capScope: "system",
|
|
42205
|
-
addonId: null,
|
|
42206
|
-
access: "create"
|
|
42207
|
-
},
|
|
42208
42464
|
"pipelineExecutor.validatePipeline": {
|
|
42209
42465
|
capName: "pipeline-executor",
|
|
42210
42466
|
capScope: "system",
|
|
42211
42467
|
addonId: null,
|
|
42212
42468
|
access: "view"
|
|
42213
42469
|
},
|
|
42214
|
-
"pipelineOrchestrator.
|
|
42470
|
+
"pipelineOrchestrator.applyAutoTune": {
|
|
42215
42471
|
capName: "pipeline-orchestrator",
|
|
42216
42472
|
capScope: "system",
|
|
42217
42473
|
addonId: null,
|
|
42218
42474
|
access: "create"
|
|
42219
42475
|
},
|
|
42220
|
-
"pipelineOrchestrator.
|
|
42476
|
+
"pipelineOrchestrator.applyDeviceSettingsPatch": {
|
|
42221
42477
|
capName: "pipeline-orchestrator",
|
|
42222
42478
|
capScope: "system",
|
|
42223
42479
|
addonId: null,
|
|
42224
42480
|
access: "create"
|
|
42225
42481
|
},
|
|
42226
|
-
"pipelineOrchestrator.
|
|
42482
|
+
"pipelineOrchestrator.assignAudio": {
|
|
42227
42483
|
capName: "pipeline-orchestrator",
|
|
42228
42484
|
capScope: "system",
|
|
42229
42485
|
addonId: null,
|
|
42230
42486
|
access: "create"
|
|
42231
42487
|
},
|
|
42232
|
-
"pipelineOrchestrator.
|
|
42488
|
+
"pipelineOrchestrator.assignPipeline": {
|
|
42233
42489
|
capName: "pipeline-orchestrator",
|
|
42234
42490
|
capScope: "system",
|
|
42235
42491
|
addonId: null,
|
|
42236
|
-
access: "
|
|
42492
|
+
access: "create"
|
|
42237
42493
|
},
|
|
42238
42494
|
"pipelineOrchestrator.getAgentLoad": {
|
|
42239
42495
|
capName: "pipeline-orchestrator",
|
|
@@ -42325,6 +42581,12 @@ Object.freeze({
|
|
|
42325
42581
|
addonId: null,
|
|
42326
42582
|
access: "view"
|
|
42327
42583
|
},
|
|
42584
|
+
"pipelineOrchestrator.getEffectiveShares": {
|
|
42585
|
+
capName: "pipeline-orchestrator",
|
|
42586
|
+
capScope: "system",
|
|
42587
|
+
addonId: null,
|
|
42588
|
+
access: "view"
|
|
42589
|
+
},
|
|
42328
42590
|
"pipelineOrchestrator.getGlobalMetrics": {
|
|
42329
42591
|
capName: "pipeline-orchestrator",
|
|
42330
42592
|
capScope: "system",
|
|
@@ -42361,19 +42623,19 @@ Object.freeze({
|
|
|
42361
42623
|
addonId: null,
|
|
42362
42624
|
access: "view"
|
|
42363
42625
|
},
|
|
42364
|
-
"pipelineOrchestrator.
|
|
42626
|
+
"pipelineOrchestrator.getPlacementStats": {
|
|
42365
42627
|
capName: "pipeline-orchestrator",
|
|
42366
42628
|
capScope: "system",
|
|
42367
42629
|
addonId: null,
|
|
42368
42630
|
access: "view"
|
|
42369
42631
|
},
|
|
42370
|
-
"pipelineOrchestrator.
|
|
42632
|
+
"pipelineOrchestrator.getReconcileFromDiskStatus": {
|
|
42371
42633
|
capName: "pipeline-orchestrator",
|
|
42372
42634
|
capScope: "system",
|
|
42373
42635
|
addonId: null,
|
|
42374
42636
|
access: "view"
|
|
42375
42637
|
},
|
|
42376
|
-
"pipelineOrchestrator.
|
|
42638
|
+
"pipelineOrchestrator.listAgentSettings": {
|
|
42377
42639
|
capName: "pipeline-orchestrator",
|
|
42378
42640
|
capScope: "system",
|
|
42379
42641
|
addonId: null,
|
|
@@ -42385,6 +42647,12 @@ Object.freeze({
|
|
|
42385
42647
|
addonId: null,
|
|
42386
42648
|
access: "create"
|
|
42387
42649
|
},
|
|
42650
|
+
"pipelineOrchestrator.planAutoTune": {
|
|
42651
|
+
capName: "pipeline-orchestrator",
|
|
42652
|
+
capScope: "system",
|
|
42653
|
+
addonId: null,
|
|
42654
|
+
access: "view"
|
|
42655
|
+
},
|
|
42388
42656
|
"pipelineOrchestrator.rebalance": {
|
|
42389
42657
|
capName: "pipeline-orchestrator",
|
|
42390
42658
|
capScope: "system",
|
|
@@ -42427,12 +42695,6 @@ Object.freeze({
|
|
|
42427
42695
|
addonId: null,
|
|
42428
42696
|
access: "create"
|
|
42429
42697
|
},
|
|
42430
|
-
"pipelineOrchestrator.saveTemplate": {
|
|
42431
|
-
capName: "pipeline-orchestrator",
|
|
42432
|
-
capScope: "system",
|
|
42433
|
-
addonId: null,
|
|
42434
|
-
access: "create"
|
|
42435
|
-
},
|
|
42436
42698
|
"pipelineOrchestrator.setAgentCapabilities": {
|
|
42437
42699
|
capName: "pipeline-orchestrator",
|
|
42438
42700
|
capScope: "system",
|
|
@@ -42445,12 +42707,6 @@ Object.freeze({
|
|
|
42445
42707
|
addonId: null,
|
|
42446
42708
|
access: "create"
|
|
42447
42709
|
},
|
|
42448
|
-
"pipelineOrchestrator.setAgentDetectWeight": {
|
|
42449
|
-
capName: "pipeline-orchestrator",
|
|
42450
|
-
capScope: "system",
|
|
42451
|
-
addonId: null,
|
|
42452
|
-
access: "create"
|
|
42453
|
-
},
|
|
42454
42710
|
"pipelineOrchestrator.setAgentInferenceDevices": {
|
|
42455
42711
|
capName: "pipeline-orchestrator",
|
|
42456
42712
|
capScope: "system",
|
|
@@ -42487,6 +42743,12 @@ Object.freeze({
|
|
|
42487
42743
|
addonId: null,
|
|
42488
42744
|
access: "create"
|
|
42489
42745
|
},
|
|
42746
|
+
"pipelineOrchestrator.setCameraStepSettings": {
|
|
42747
|
+
capName: "pipeline-orchestrator",
|
|
42748
|
+
capScope: "system",
|
|
42749
|
+
addonId: null,
|
|
42750
|
+
access: "create"
|
|
42751
|
+
},
|
|
42490
42752
|
"pipelineOrchestrator.setCameraStepToggle": {
|
|
42491
42753
|
capName: "pipeline-orchestrator",
|
|
42492
42754
|
capScope: "system",
|
|
@@ -42505,25 +42767,37 @@ Object.freeze({
|
|
|
42505
42767
|
addonId: null,
|
|
42506
42768
|
access: "create"
|
|
42507
42769
|
},
|
|
42770
|
+
"pipelineOrchestrator.setLoadBalancingShares": {
|
|
42771
|
+
capName: "pipeline-orchestrator",
|
|
42772
|
+
capScope: "system",
|
|
42773
|
+
addonId: null,
|
|
42774
|
+
access: "create"
|
|
42775
|
+
},
|
|
42508
42776
|
"pipelineOrchestrator.setPipelineDevicePin": {
|
|
42509
42777
|
capName: "pipeline-orchestrator",
|
|
42510
42778
|
capScope: "system",
|
|
42511
42779
|
addonId: null,
|
|
42512
42780
|
access: "create"
|
|
42513
42781
|
},
|
|
42514
|
-
"pipelineOrchestrator.
|
|
42782
|
+
"pipelineOrchestrator.setShareSource": {
|
|
42515
42783
|
capName: "pipeline-orchestrator",
|
|
42516
42784
|
capScope: "system",
|
|
42517
42785
|
addonId: null,
|
|
42518
42786
|
access: "create"
|
|
42519
42787
|
},
|
|
42520
|
-
"pipelineOrchestrator.
|
|
42788
|
+
"pipelineOrchestrator.suggestShares": {
|
|
42789
|
+
capName: "pipeline-orchestrator",
|
|
42790
|
+
capScope: "system",
|
|
42791
|
+
addonId: null,
|
|
42792
|
+
access: "view"
|
|
42793
|
+
},
|
|
42794
|
+
"pipelineOrchestrator.unassignAudio": {
|
|
42521
42795
|
capName: "pipeline-orchestrator",
|
|
42522
42796
|
capScope: "system",
|
|
42523
42797
|
addonId: null,
|
|
42524
42798
|
access: "create"
|
|
42525
42799
|
},
|
|
42526
|
-
"pipelineOrchestrator.
|
|
42800
|
+
"pipelineOrchestrator.unassignPipeline": {
|
|
42527
42801
|
capName: "pipeline-orchestrator",
|
|
42528
42802
|
capScope: "system",
|
|
42529
42803
|
addonId: null,
|
|
@@ -43963,12 +44237,6 @@ Object.freeze({
|
|
|
43963
44237
|
addonId: null,
|
|
43964
44238
|
access: "view"
|
|
43965
44239
|
},
|
|
43966
|
-
"streamBroker.pullFrameHandles": {
|
|
43967
|
-
capName: "stream-broker",
|
|
43968
|
-
capScope: "system",
|
|
43969
|
-
addonId: null,
|
|
43970
|
-
access: "view"
|
|
43971
|
-
},
|
|
43972
44240
|
"streamBroker.regenerateRtspToken": {
|
|
43973
44241
|
capName: "stream-broker",
|
|
43974
44242
|
capScope: "system",
|
|
@@ -44035,12 +44303,6 @@ Object.freeze({
|
|
|
44035
44303
|
addonId: null,
|
|
44036
44304
|
access: "create"
|
|
44037
44305
|
},
|
|
44038
|
-
"streamBroker.subscribeFrames": {
|
|
44039
|
-
capName: "stream-broker",
|
|
44040
|
-
capScope: "system",
|
|
44041
|
-
addonId: null,
|
|
44042
|
-
access: "create"
|
|
44043
|
-
},
|
|
44044
44306
|
"streamBroker.unassignProfile": {
|
|
44045
44307
|
capName: "stream-broker",
|
|
44046
44308
|
capScope: "system",
|
|
@@ -44053,12 +44315,6 @@ Object.freeze({
|
|
|
44053
44315
|
addonId: null,
|
|
44054
44316
|
access: "create"
|
|
44055
44317
|
},
|
|
44056
|
-
"streamBroker.unsubscribeFrames": {
|
|
44057
|
-
capName: "stream-broker",
|
|
44058
|
-
capScope: "system",
|
|
44059
|
-
addonId: null,
|
|
44060
|
-
access: "create"
|
|
44061
|
-
},
|
|
44062
44318
|
"streamCatalog.getCatalog": {
|
|
44063
44319
|
capName: "stream-catalog",
|
|
44064
44320
|
capScope: "device",
|
|
@@ -44755,6 +45011,12 @@ Object.freeze({
|
|
|
44755
45011
|
addonId: null,
|
|
44756
45012
|
access: "create"
|
|
44757
45013
|
},
|
|
45014
|
+
"webrtcSession.applyDownlinkProbe": {
|
|
45015
|
+
capName: "webrtc-session",
|
|
45016
|
+
capScope: "device",
|
|
45017
|
+
addonId: null,
|
|
45018
|
+
access: "create"
|
|
45019
|
+
},
|
|
44758
45020
|
"webrtcSession.closeSession": {
|
|
44759
45021
|
capName: "webrtc-session",
|
|
44760
45022
|
capScope: "device",
|
|
@@ -46566,11 +46828,6 @@ Object.freeze({
|
|
|
46566
46828
|
form: "single",
|
|
46567
46829
|
optional: false
|
|
46568
46830
|
}],
|
|
46569
|
-
"decoder.createSession": [{
|
|
46570
|
-
name: "deviceId",
|
|
46571
|
-
form: "single",
|
|
46572
|
-
optional: true
|
|
46573
|
-
}],
|
|
46574
46831
|
"detectionPipeline.applyDeviceSettingsPatch": [{
|
|
46575
46832
|
name: "deviceId",
|
|
46576
46833
|
form: "single",
|
|
@@ -47801,6 +48058,11 @@ Object.freeze({
|
|
|
47801
48058
|
form: "single",
|
|
47802
48059
|
optional: false
|
|
47803
48060
|
}],
|
|
48061
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": [{
|
|
48062
|
+
name: "deviceIds",
|
|
48063
|
+
form: "array",
|
|
48064
|
+
optional: true
|
|
48065
|
+
}],
|
|
47804
48066
|
"pipelineExecutor.runPipeline": [{
|
|
47805
48067
|
name: "deviceId",
|
|
47806
48068
|
form: "single",
|
|
@@ -47906,6 +48168,11 @@ Object.freeze({
|
|
|
47906
48168
|
form: "single",
|
|
47907
48169
|
optional: false
|
|
47908
48170
|
}],
|
|
48171
|
+
"pipelineOrchestrator.setCameraStepSettings": [{
|
|
48172
|
+
name: "deviceId",
|
|
48173
|
+
form: "single",
|
|
48174
|
+
optional: false
|
|
48175
|
+
}],
|
|
47909
48176
|
"pipelineOrchestrator.setCameraStepToggle": [{
|
|
47910
48177
|
name: "deviceId",
|
|
47911
48178
|
form: "single",
|
|
@@ -48677,6 +48944,11 @@ Object.freeze({
|
|
|
48677
48944
|
form: "single",
|
|
48678
48945
|
optional: false
|
|
48679
48946
|
}],
|
|
48947
|
+
"webrtcSession.applyDownlinkProbe": [{
|
|
48948
|
+
name: "deviceId",
|
|
48949
|
+
form: "single",
|
|
48950
|
+
optional: false
|
|
48951
|
+
}],
|
|
48680
48952
|
"webrtcSession.closeSession": [{
|
|
48681
48953
|
name: "deviceId",
|
|
48682
48954
|
form: "single",
|
|
@@ -116152,7 +116424,6 @@ var HAP_STREAM_PREFERENCE_OPTIONS = [
|
|
|
116152
116424
|
];
|
|
116153
116425
|
var DEFAULT_CONFIG = {
|
|
116154
116426
|
bridgeName: "CamStack Bridge",
|
|
116155
|
-
port: 0,
|
|
116156
116427
|
fixedPin: "",
|
|
116157
116428
|
interfaceName: "",
|
|
116158
116429
|
ptzPulseMs: 400,
|
|
@@ -116829,20 +117100,11 @@ var ExportHapAddon = class extends BaseAddon {
|
|
|
116829
117100
|
type: "text",
|
|
116830
117101
|
key: "bridgeName",
|
|
116831
117102
|
label: "Installation name",
|
|
116832
|
-
description: "
|
|
117103
|
+
description: "The name of the shared bridge that carries every exposed device that is not a camera (switches, sensors, locks, alarm panels) — what iOS Home lists under Add Accessory. Cameras are never bridged: each one is published as its own accessory under its device name. Set it before you add the bridge in iOS Home.",
|
|
116833
117104
|
default: DEFAULT_CONFIG.bridgeName,
|
|
116834
117105
|
requiresRestart: true,
|
|
116835
117106
|
placement: { tab: "advanced" }
|
|
116836
117107
|
}),
|
|
116837
|
-
this.field({
|
|
116838
|
-
type: "number",
|
|
116839
|
-
key: "port",
|
|
116840
|
-
label: "HAP port",
|
|
116841
|
-
description: "Local port for the HAP server. 0 = random ephemeral port (recommended).",
|
|
116842
|
-
default: DEFAULT_CONFIG.port,
|
|
116843
|
-
requiresRestart: true,
|
|
116844
|
-
placement: { tab: "advanced" }
|
|
116845
|
-
}),
|
|
116846
117108
|
this.field({
|
|
116847
117109
|
type: "text",
|
|
116848
117110
|
key: "fixedPin",
|