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