@camstack/addon-export-google 0.1.86 → 0.1.88
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/export-google.addon.js +1057 -509
- package/dist/export-google.addon.mjs +1057 -509
- package/package.json +1 -1
|
@@ -73,7 +73,7 @@ function createApiDeviceGateway(deps) {
|
|
|
73
73
|
};
|
|
74
74
|
}
|
|
75
75
|
//#endregion
|
|
76
|
-
//#region ../types/dist/event-category-
|
|
76
|
+
//#region ../types/dist/event-category-B_0XEcLF.mjs
|
|
77
77
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
78
78
|
EventCategory["SystemBoot"] = "system.boot";
|
|
79
79
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -574,15 +574,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
574
574
|
EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
|
|
575
575
|
EventCategory["AgentBackupActivated"] = "agent.backup.activated";
|
|
576
576
|
EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
|
|
577
|
-
/**
|
|
578
|
-
* Per-agent hwaccel preference changed (user override set, cleared, or
|
|
579
|
-
* re-probed). Observability event — decoders pull the current pref at
|
|
580
|
-
* `createSession`, so running sessions keep their current backend until
|
|
581
|
-
* they rotate naturally (camera add/remove, stream restart). Future
|
|
582
|
-
* work can wire a listener in stream-broker that force-rotates live
|
|
583
|
-
* sessions; for now this event powers logs + admin-UI toast feedback.
|
|
584
|
-
*/
|
|
585
|
-
EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
|
|
586
577
|
EventCategory["MotionAnalysis"] = "detection.motion-analysis";
|
|
587
578
|
/** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
|
|
588
579
|
EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
|
|
@@ -5453,7 +5444,7 @@ var ZodIssueCode = {
|
|
|
5453
5444
|
var ZodFirstPartyTypeKind;
|
|
5454
5445
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5455
5446
|
//#endregion
|
|
5456
|
-
//#region ../types/dist/sleep-
|
|
5447
|
+
//#region ../types/dist/sleep-B0JG7-_F.mjs
|
|
5457
5448
|
/**
|
|
5458
5449
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5459
5450
|
* window to float samples (D455).
|
|
@@ -6819,32 +6810,12 @@ object({
|
|
|
6819
6810
|
audioCodec: string().optional(),
|
|
6820
6811
|
metadata: record(string(), unknown()).readonly().optional()
|
|
6821
6812
|
});
|
|
6822
|
-
var EncodedPacketSchema = object({
|
|
6823
|
-
type: _enum(["video", "audio"]),
|
|
6824
|
-
data: _instanceof(Uint8Array),
|
|
6825
|
-
pts: number(),
|
|
6826
|
-
dts: number(),
|
|
6827
|
-
keyframe: boolean(),
|
|
6828
|
-
codec: string()
|
|
6829
|
-
});
|
|
6830
|
-
var DecodedFrameSchema = object({
|
|
6831
|
-
data: _instanceof(Uint8Array),
|
|
6832
|
-
width: number(),
|
|
6833
|
-
height: number(),
|
|
6834
|
-
format: _enum([
|
|
6835
|
-
"jpeg",
|
|
6836
|
-
"rgb",
|
|
6837
|
-
"bgr",
|
|
6838
|
-
"yuv420",
|
|
6839
|
-
"gray"
|
|
6840
|
-
]),
|
|
6841
|
-
timestamp: number()
|
|
6842
|
-
});
|
|
6843
6813
|
/**
|
|
6844
6814
|
* Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
|
|
6845
6815
|
* frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
|
|
6846
|
-
* interface in `interfaces/frame-handle.ts` field-for-field so a
|
|
6847
|
-
*
|
|
6816
|
+
* interface in `interfaces/frame-handle.ts` field-for-field so a cap method
|
|
6817
|
+
* (the runner's native-crop and pipeline-executor inputs) can carry handles
|
|
6818
|
+
* over tRPC / Moleculer.
|
|
6848
6819
|
*
|
|
6849
6820
|
* The `satisfies` assertion below pins this schema to the interface: if a
|
|
6850
6821
|
* field is added to / removed from `FrameHandle` without a matching schema
|
|
@@ -6870,50 +6841,6 @@ var FrameHandleSchema = object({
|
|
|
6870
6841
|
slotCount: number().int().positive()
|
|
6871
6842
|
});
|
|
6872
6843
|
/**
|
|
6873
|
-
* Pixel format a frame-handle subscriber can request from the broker
|
|
6874
|
-
* (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
|
|
6875
|
-
* `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
|
|
6876
|
-
* `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
|
|
6877
|
-
* payload, and no decoded-frame consumer requests it over the shm plane.
|
|
6878
|
-
*/
|
|
6879
|
-
var FrameHandleFormatSchema = _enum([
|
|
6880
|
-
"rgb",
|
|
6881
|
-
"bgr",
|
|
6882
|
-
"yuv420",
|
|
6883
|
-
"gray"
|
|
6884
|
-
]);
|
|
6885
|
-
/**
|
|
6886
|
-
* Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
|
|
6887
|
-
* broker for a `FrameHandle` stream of one `format`; the broker maintains one
|
|
6888
|
-
* shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
|
|
6889
|
-
* subscriber (motion) and an `rgb` subscriber (detection) each read the format
|
|
6890
|
-
* they asked for with no broker-side conversion.
|
|
6891
|
-
*/
|
|
6892
|
-
var SubscribeFramesInputSchema = object({
|
|
6893
|
-
brokerId: string(),
|
|
6894
|
-
format: FrameHandleFormatSchema,
|
|
6895
|
-
/**
|
|
6896
|
-
* Optional reader-side cadence hint in frames per second. The broker does
|
|
6897
|
-
* NOT throttle — latest-wins ring reads drop frames implicitly for a slow
|
|
6898
|
-
* consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
|
|
6899
|
-
* the consumer can pace its own `pullFrameHandles` polling.
|
|
6900
|
-
*/
|
|
6901
|
-
maxFps: number().positive().optional(),
|
|
6902
|
-
/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
|
|
6903
|
-
tag: string().optional()
|
|
6904
|
-
});
|
|
6905
|
-
/**
|
|
6906
|
-
* Result of `stream-broker.subscribeFrames`. The consumer then polls
|
|
6907
|
-
* `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
|
|
6908
|
-
* `FrameHandle` to a `FrameRingReader`.
|
|
6909
|
-
*/
|
|
6910
|
-
var SubscribeFramesResultSchema = object({
|
|
6911
|
-
/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
|
|
6912
|
-
subscriptionId: string(),
|
|
6913
|
-
/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
|
|
6914
|
-
maxFps: number().nonnegative()
|
|
6915
|
-
});
|
|
6916
|
-
/**
|
|
6917
6844
|
* Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
|
|
6918
6845
|
* `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
|
|
6919
6846
|
* sample bytes plus the track parameters a consumer needs to interpret them.
|
|
@@ -6921,8 +6848,8 @@ var SubscribeFramesResultSchema = object({
|
|
|
6921
6848
|
* Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
|
|
6922
6849
|
* Float32 PCM), so unlike video frames they ship their bytes INLINE over
|
|
6923
6850
|
* tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
|
|
6924
|
-
* (the wire-serialisable supertype of `Buffer`)
|
|
6925
|
-
*
|
|
6851
|
+
* (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
|
|
6852
|
+
* it.
|
|
6926
6853
|
*/
|
|
6927
6854
|
var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
|
|
6928
6855
|
var DecodedAudioChunkSchema = object({
|
|
@@ -6940,11 +6867,10 @@ var DecodedAudioChunkSchema = object({
|
|
|
6940
6867
|
format: AudioChunkFormatSchema.optional()
|
|
6941
6868
|
});
|
|
6942
6869
|
/**
|
|
6943
|
-
* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9).
|
|
6944
|
-
*
|
|
6945
|
-
*
|
|
6946
|
-
*
|
|
6947
|
-
* `pullAudioChunks`.
|
|
6870
|
+
* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
|
|
6871
|
+
* its bytes inline: a consumer asks the broker for the decoded audio-chunk
|
|
6872
|
+
* stream of one broker; the broker keeps a per-subscription bounded FIFO queue
|
|
6873
|
+
* the consumer drains via `pullAudioChunks`.
|
|
6948
6874
|
*/
|
|
6949
6875
|
var SubscribeAudioChunksInputSchema = object({
|
|
6950
6876
|
brokerId: string(),
|
|
@@ -6975,9 +6901,7 @@ var BrokerStatsSchema = object({
|
|
|
6975
6901
|
"stopped"
|
|
6976
6902
|
]),
|
|
6977
6903
|
inputFps: number(),
|
|
6978
|
-
decodeFps: number(),
|
|
6979
6904
|
encodedSubscribers: number(),
|
|
6980
|
-
decodedSubscribers: number(),
|
|
6981
6905
|
uptimeMs: number(),
|
|
6982
6906
|
bitrateKbps: number(),
|
|
6983
6907
|
idrIntervalMs: number(),
|
|
@@ -6990,14 +6914,6 @@ var BrokerStatsSchema = object({
|
|
|
6990
6914
|
preBufferMs: number(),
|
|
6991
6915
|
preBufferPackets: number(),
|
|
6992
6916
|
/**
|
|
6993
|
-
* Moleculer node id of the decoder provider currently servicing this
|
|
6994
|
-
* stream's decoded subscribers. `null` until the deferred decoder is
|
|
6995
|
-
* created (no decoded clients yet, or codec not detected). Surfaces the
|
|
6996
|
-
* runtime decoder placement so the UI can show "Decoder: <agent>" without
|
|
6997
|
-
* a separate cap call per broker.
|
|
6998
|
-
*/
|
|
6999
|
-
decoderNodeId: string().nullable(),
|
|
7000
|
-
/**
|
|
7001
6917
|
* Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
|
|
7002
6918
|
* when the stream has no audio track or the broker is in cold start.
|
|
7003
6919
|
* `supported = false` means the codec was detected but the local
|
|
@@ -8485,8 +8401,8 @@ function buildAddonRouteProvider(id, routes) {
|
|
|
8485
8401
|
const reply = buildCapturingReply(envelope);
|
|
8486
8402
|
const request = {
|
|
8487
8403
|
params: {
|
|
8488
|
-
...
|
|
8489
|
-
...
|
|
8404
|
+
...match.params,
|
|
8405
|
+
...input.params
|
|
8490
8406
|
},
|
|
8491
8407
|
query: input.query,
|
|
8492
8408
|
body: input.body,
|
|
@@ -10468,70 +10384,6 @@ var StorageLocationDeclarationSchema = object({
|
|
|
10468
10384
|
"backup"
|
|
10469
10385
|
]).optional()
|
|
10470
10386
|
});
|
|
10471
|
-
var DecoderStatsSchema = object({
|
|
10472
|
-
inputFps: number(),
|
|
10473
|
-
outputFps: number(),
|
|
10474
|
-
avgDecodeTimeMs: number(),
|
|
10475
|
-
droppedFrames: number(),
|
|
10476
|
-
/**
|
|
10477
|
-
* Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
|
|
10478
|
-
* lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
|
|
10479
|
-
* the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
|
|
10480
|
-
* is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
|
|
10481
|
-
*/
|
|
10482
|
-
lagMs: number().optional(),
|
|
10483
|
-
effectiveFps: number().optional(),
|
|
10484
|
-
adaptiveFps: number().optional()
|
|
10485
|
-
});
|
|
10486
|
-
var DecoderSessionConfigSchema = object({
|
|
10487
|
-
codec: string(),
|
|
10488
|
-
maxFps: number().default(0),
|
|
10489
|
-
outputFormat: _enum([
|
|
10490
|
-
"jpeg",
|
|
10491
|
-
"rgb",
|
|
10492
|
-
"bgr",
|
|
10493
|
-
"yuv420",
|
|
10494
|
-
"gray"
|
|
10495
|
-
]).default("jpeg"),
|
|
10496
|
-
scale: number().default(1),
|
|
10497
|
-
width: number().optional(),
|
|
10498
|
-
height: number().optional(),
|
|
10499
|
-
/**
|
|
10500
|
-
* Identifier of the camera this decoder session serves. Optional
|
|
10501
|
-
* because the cap is generic (any caller could request decode), but
|
|
10502
|
-
* stream-broker passes it so decoder logs include `deviceId` for
|
|
10503
|
-
* per-camera filtering when diagnosing failures (e.g. node-av
|
|
10504
|
-
* sendPacket errors on a single hung camera).
|
|
10505
|
-
*/
|
|
10506
|
-
deviceId: number().int().nonnegative().optional(),
|
|
10507
|
-
/**
|
|
10508
|
-
* Free-form tag for log scoping. Stream-broker uses
|
|
10509
|
-
* `broker:<deviceId>/<profile>`. Decoder session logger surfaces it
|
|
10510
|
-
* on every line so `grep tag=broker:5/high` filters one camera
|
|
10511
|
-
* profile cleanly.
|
|
10512
|
-
*/
|
|
10513
|
-
tag: string().optional(),
|
|
10514
|
-
/**
|
|
10515
|
-
* Where the session delivers decoded frames (Phase 5 / D9):
|
|
10516
|
-
*
|
|
10517
|
-
* - `'callback'` (default) — the legacy pixel path: decoded frames are
|
|
10518
|
-
* buffered as `DecodedFrame`s and drained via `pullFrames`.
|
|
10519
|
-
* - `'shm'` — the shared-memory frame plane: decoded frames are written
|
|
10520
|
-
* into an OS shared-memory ring and drained as zero-pixel
|
|
10521
|
-
* `FrameHandle`s via `pullHandles`. A session is one mode or the
|
|
10522
|
-
* other — `pullFrames` returns nothing for an `'shm'` session and
|
|
10523
|
-
* `pullHandles` returns nothing for a `'callback'` session.
|
|
10524
|
-
*/
|
|
10525
|
-
frameSink: _enum(["callback", "shm"]).default("callback"),
|
|
10526
|
-
/**
|
|
10527
|
-
* Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
|
|
10528
|
-
* a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
|
|
10529
|
-
* real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
|
|
10530
|
-
* stream-broker's `streamingDebug` gate — off by default so production logs
|
|
10531
|
-
* stay quiet and the emit path pays zero per-frame cost when disabled.
|
|
10532
|
-
*/
|
|
10533
|
-
debug: boolean().optional()
|
|
10534
|
-
});
|
|
10535
10387
|
/**
|
|
10536
10388
|
* Per-component log CHANNELS — the gate a hot path consults, and the registry
|
|
10537
10389
|
* an addon declares its channels in.
|
|
@@ -10682,7 +10534,18 @@ var LABEL_SUPPLY_STEP_IDS = [
|
|
|
10682
10534
|
];
|
|
10683
10535
|
/** Steps whose box a root detection can BE. */
|
|
10684
10536
|
var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
|
|
10685
|
-
|
|
10537
|
+
/**
|
|
10538
|
+
* Steps whose per-detection MASK a root detection can carry (D737). The live
|
|
10539
|
+
* mask step is `segmentation` — a frame-plane refiner that runs its own model
|
|
10540
|
+
* once per detection crop. (`instance-segmentation` is a dormant step id that
|
|
10541
|
+
* no camera tree carries.)
|
|
10542
|
+
*/
|
|
10543
|
+
var MASK_SUPPLY_STEP_IDS = ["segmentation"];
|
|
10544
|
+
[
|
|
10545
|
+
...LABEL_SUPPLY_STEP_IDS,
|
|
10546
|
+
...CROP_SUPPLY_STEP_IDS,
|
|
10547
|
+
...MASK_SUPPLY_STEP_IDS
|
|
10548
|
+
];
|
|
10686
10549
|
var MODEL_FORMATS = [
|
|
10687
10550
|
"onnx",
|
|
10688
10551
|
"coreml",
|
|
@@ -10711,7 +10574,53 @@ var ModelFormatEntrySchema = object({
|
|
|
10711
10574
|
/** Multi-file payload (directory members or sibling files). */
|
|
10712
10575
|
files: array(string()).readonly().optional(),
|
|
10713
10576
|
/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
|
|
10714
|
-
runtimes: array(_enum(["python"])).readonly().optional()
|
|
10577
|
+
runtimes: array(_enum(["python"])).readonly().optional(),
|
|
10578
|
+
/**
|
|
10579
|
+
* Content revision of the artefact, for one hosted OFF the CamStack mirror.
|
|
10580
|
+
* A format on the mirror leaves it unset: its revision (the sha256 of its
|
|
10581
|
+
* weight file) comes from the downloader's generated table, kept in step
|
|
10582
|
+
* with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
|
|
10583
|
+
* node records the revision it downloaded next to the file
|
|
10584
|
+
* (`<file>.revision`); a copy with no record or a different one is stale
|
|
10585
|
+
* unless its weight file hashes to the revision, and a stale copy is
|
|
10586
|
+
* downloaded again, the old one serving until the new one is complete. No
|
|
10587
|
+
* revision at all ⇒ a file on disk is current, whatever it holds (D743).
|
|
10588
|
+
*/
|
|
10589
|
+
revision: string().min(1).optional()
|
|
10590
|
+
});
|
|
10591
|
+
/**
|
|
10592
|
+
* What a node holds for one (model, format) (D746). `current` is a complete
|
|
10593
|
+
* copy at its catalog revision — exactly what `downloaded: true` means.
|
|
10594
|
+
* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
|
|
10595
|
+
* no or a different revision record, or a missing sibling. `missing` is no
|
|
10596
|
+
* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
|
|
10597
|
+
* reclaimable bytes and a copy about to be replaced.
|
|
10598
|
+
*/
|
|
10599
|
+
var ModelOnDiskStateSchema = _enum([
|
|
10600
|
+
"current",
|
|
10601
|
+
"stale",
|
|
10602
|
+
"missing"
|
|
10603
|
+
]);
|
|
10604
|
+
/**
|
|
10605
|
+
* The numeric precision of one format's BUILD (D746) — reported only when the
|
|
10606
|
+
* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
|
|
10607
|
+
* CamStack Core ML export). Absent means "not stated", never "fp32".
|
|
10608
|
+
*/
|
|
10609
|
+
var ModelFormatPrecisionSchema = _enum([
|
|
10610
|
+
"fp32",
|
|
10611
|
+
"fp16",
|
|
10612
|
+
"int8"
|
|
10613
|
+
]);
|
|
10614
|
+
/**
|
|
10615
|
+
* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
|
|
10616
|
+
* `onDisk` / `precision` are optional for version skew: a runner that predates
|
|
10617
|
+
* them omits them, and a reader falls back to `downloaded`.
|
|
10618
|
+
*/
|
|
10619
|
+
var PipelineModelFormatStatusSchema = object({
|
|
10620
|
+
downloaded: boolean(),
|
|
10621
|
+
sizeMB: number(),
|
|
10622
|
+
onDisk: ModelOnDiskStateSchema.optional(),
|
|
10623
|
+
precision: ModelFormatPrecisionSchema.optional()
|
|
10715
10624
|
});
|
|
10716
10625
|
/**
|
|
10717
10626
|
* Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
|
|
@@ -10825,25 +10734,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
|
|
|
10825
10734
|
* - `crop`: the root draws the box the step would have found (`license_plate`
|
|
10826
10735
|
* for plate-detection, `face` for face-detection). The box becomes a detail
|
|
10827
10736
|
* child of the `parentMacro` detection that contains it — never a track.
|
|
10737
|
+
* - `mask`: the root's decode emits an instance mask with every detection (a
|
|
10738
|
+
* YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
|
|
10739
|
+
* detection in the shape that step produces. Derived from the model's
|
|
10740
|
+
* postprocessor on read, never stored by an import.
|
|
10828
10741
|
*/
|
|
10829
|
-
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
10830
|
-
|
|
10831
|
-
|
|
10832
|
-
|
|
10833
|
-
|
|
10834
|
-
|
|
10835
|
-
|
|
10836
|
-
|
|
10837
|
-
|
|
10838
|
-
|
|
10839
|
-
|
|
10840
|
-
|
|
10841
|
-
|
|
10842
|
-
|
|
10843
|
-
|
|
10844
|
-
|
|
10845
|
-
|
|
10846
|
-
|
|
10742
|
+
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
10743
|
+
object({
|
|
10744
|
+
kind: literal("label"),
|
|
10745
|
+
stepId: _enum(LABEL_SUPPLY_STEP_IDS),
|
|
10746
|
+
labelToEffect: record(string(), string()),
|
|
10747
|
+
uncovered: array(string()).readonly()
|
|
10748
|
+
}),
|
|
10749
|
+
object({
|
|
10750
|
+
kind: literal("crop"),
|
|
10751
|
+
stepId: _enum(CROP_SUPPLY_STEP_IDS),
|
|
10752
|
+
rootLabels: array(string()).readonly(),
|
|
10753
|
+
parentMacro: _enum(["vehicle", "person"]),
|
|
10754
|
+
childClass: _enum(["plate", "face"]),
|
|
10755
|
+
/**
|
|
10756
|
+
* The root's smaller input side, stamped on read by `rootSuppliesOf` from
|
|
10757
|
+
* the model entry — what a step's `minRootInputPx` gate judges. Never
|
|
10758
|
+
* stored by an import.
|
|
10759
|
+
*/
|
|
10760
|
+
rootInputPx: number().int().positive().optional()
|
|
10761
|
+
}),
|
|
10762
|
+
object({
|
|
10763
|
+
kind: literal("mask"),
|
|
10764
|
+
stepId: _enum(MASK_SUPPLY_STEP_IDS)
|
|
10765
|
+
})
|
|
10766
|
+
]);
|
|
10847
10767
|
var ModelCatalogEntrySchema = object({
|
|
10848
10768
|
id: string(),
|
|
10849
10769
|
name: string(),
|
|
@@ -10909,6 +10829,35 @@ var ModelCatalogEntrySchema = object({
|
|
|
10909
10829
|
*/
|
|
10910
10830
|
defaultConfidence: number().min(0).max(1).optional(),
|
|
10911
10831
|
/**
|
|
10832
|
+
* Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
|
|
10833
|
+
* on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
|
|
10834
|
+
* absent here runs at the step slider's global default. The same row shape
|
|
10835
|
+
* the floor measurement produces (`model-floors.json`: modelId → floors), so
|
|
10836
|
+
* a measured table is copied in as-is. An operator override is bound to the
|
|
10837
|
+
* model it was made for and does not survive a model change (D738). A custom
|
|
10838
|
+
* / imported model may declare it; without it, the global defaults apply.
|
|
10839
|
+
*/
|
|
10840
|
+
defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
|
|
10841
|
+
/**
|
|
10842
|
+
* The inference precision this model's OpenVINO IR needs on an Intel GPU.
|
|
10843
|
+
* Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
|
|
10844
|
+
* that produces invalid output at f16 — measured 2026-10-07 for YOLO26
|
|
10845
|
+
* base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
|
|
10846
|
+
* scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
|
|
10847
|
+
* `PoolModelConfig.gpuInferencePrecision`; the pool sets
|
|
10848
|
+
* INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
|
|
10849
|
+
*/
|
|
10850
|
+
gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
|
|
10851
|
+
/**
|
|
10852
|
+
* ROOT detectors only: per supplied step (`animal-classifier`, …), the
|
|
10853
|
+
* minimum DETECTION score from which this root's own fine label (species,
|
|
10854
|
+
* vehicle type — D736 root supply) is taken (D741). Below it the detection
|
|
10855
|
+
* keeps its macro class without the fine label. `1` = never take it from
|
|
10856
|
+
* this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
|
|
10857
|
+
* `minConfidence` slider, bound to the ROOT model, overrides it.
|
|
10858
|
+
*/
|
|
10859
|
+
suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
|
|
10860
|
+
/**
|
|
10912
10861
|
* When true, the executor produces a landmark-aligned crop (similarity warp
|
|
10913
10862
|
* onto the canonical template) before this step runs, instead of a plain
|
|
10914
10863
|
* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
|
|
@@ -12607,13 +12556,6 @@ var BrokerRtspClientSchema = object({
|
|
|
12607
12556
|
lastRtpAt: number(),
|
|
12608
12557
|
bytesSent: number()
|
|
12609
12558
|
});
|
|
12610
|
-
var BrokerDecodedClientSchema = object({
|
|
12611
|
-
tag: string(),
|
|
12612
|
-
subscribedAt: number(),
|
|
12613
|
-
maxFps: number(),
|
|
12614
|
-
framesDelivered: number(),
|
|
12615
|
-
framesDropped: number()
|
|
12616
|
-
});
|
|
12617
12559
|
var BrokerAudioClientSchema = object({
|
|
12618
12560
|
tag: string(),
|
|
12619
12561
|
subscribedAt: number(),
|
|
@@ -12705,7 +12647,6 @@ var BrokerEncodedClientSchema = object({
|
|
|
12705
12647
|
});
|
|
12706
12648
|
var BrokerClientsSchema = object({
|
|
12707
12649
|
rtsp: array(BrokerRtspClientSchema).readonly(),
|
|
12708
|
-
decoded: array(BrokerDecodedClientSchema).readonly(),
|
|
12709
12650
|
audio: array(BrokerAudioClientSchema).readonly(),
|
|
12710
12651
|
encoded: array(BrokerEncodedClientSchema).readonly(),
|
|
12711
12652
|
pipeClients: number(),
|
|
@@ -13074,11 +13015,7 @@ method(object({
|
|
|
13074
13015
|
auth: "admin"
|
|
13075
13016
|
}), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
|
|
13076
13017
|
brokerId: string(),
|
|
13077
|
-
channel: _enum([
|
|
13078
|
-
"rtsp",
|
|
13079
|
-
"decoded",
|
|
13080
|
-
"audio"
|
|
13081
|
-
]),
|
|
13018
|
+
channel: _enum(["rtsp", "audio"]),
|
|
13082
13019
|
handle: string()
|
|
13083
13020
|
}), object({ killed: boolean() }), {
|
|
13084
13021
|
kind: "mutation",
|
|
@@ -13113,10 +13050,7 @@ method(object({
|
|
|
13113
13050
|
}), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
|
|
13114
13051
|
subscriptionId: string(),
|
|
13115
13052
|
maxCount: number().int().positive().default(8)
|
|
13116
|
-
}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(
|
|
13117
|
-
subscriptionId: string(),
|
|
13118
|
-
maxCount: number().int().positive().default(4)
|
|
13119
|
-
}), array(FrameHandleSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
|
|
13053
|
+
}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
|
|
13120
13054
|
brokerId: string(),
|
|
13121
13055
|
seconds: number().min(0).max(30)
|
|
13122
13056
|
}), _void(), {
|
|
@@ -14273,54 +14207,12 @@ id: union([string(), number()]) }), {
|
|
|
14273
14207
|
kind: "mutation",
|
|
14274
14208
|
auth: "admin"
|
|
14275
14209
|
});
|
|
14276
|
-
|
|
14277
|
-
* shm ring usage stats for a `frameSink: 'shm'` decoder session —
|
|
14278
|
-
* exposed via `decoder.getShmStats` so downstream consumers can
|
|
14279
|
-
* observe ring pressure (slot count, byte budget, hit/miss ratio).
|
|
14280
|
-
*/
|
|
14281
|
-
var ShmRingStatsSchema = object({
|
|
14282
|
-
sessionId: string(),
|
|
14283
|
-
slotCount: number().int(),
|
|
14284
|
-
slotByteLength: number().int(),
|
|
14285
|
-
segmentBytes: number().int(),
|
|
14286
|
-
budgetMb: number().int(),
|
|
14287
|
-
framesWritten: number().int(),
|
|
14288
|
-
getFrameHits: number().int(),
|
|
14289
|
-
getFrameMisses: number().int()
|
|
14290
|
-
});
|
|
14291
|
-
method(object({ codec: string() }), boolean()), method(_void(), object({
|
|
14210
|
+
method(_void(), object({
|
|
14292
14211
|
id: string(),
|
|
14293
14212
|
name: string(),
|
|
14294
|
-
isPullMode: boolean().optional(),
|
|
14295
|
-
priority: number().optional(),
|
|
14296
14213
|
hwaccel: string().optional(),
|
|
14297
14214
|
probedBestHwaccel: string().optional()
|
|
14298
|
-
})), method(
|
|
14299
|
-
sessionId: string(),
|
|
14300
|
-
nodeId: string()
|
|
14301
|
-
})), method(object({ sessionId: string() }), _void()), method(object({
|
|
14302
|
-
sessionId: string(),
|
|
14303
|
-
packet: EncodedPacketSchema
|
|
14304
|
-
}), _void()), method(object({
|
|
14305
|
-
sessionId: string(),
|
|
14306
|
-
url: string()
|
|
14307
|
-
}), _void()), method(object({
|
|
14308
|
-
sessionId: string(),
|
|
14309
|
-
maxCount: number().default(1),
|
|
14310
|
-
waitMs: number().optional()
|
|
14311
|
-
}), array(DecodedFrameSchema)), method(object({
|
|
14312
|
-
sessionId: string(),
|
|
14313
|
-
maxCount: number().default(1),
|
|
14314
|
-
waitMs: number().optional()
|
|
14315
|
-
}), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
|
|
14316
|
-
sessionId: string(),
|
|
14317
|
-
config: DecoderSessionConfigSchema.partial()
|
|
14318
|
-
}), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
|
|
14319
|
-
sessionId: string(),
|
|
14320
|
-
codec: string(),
|
|
14321
|
-
outputFormat: string(),
|
|
14322
|
-
createdAtMs: number()
|
|
14323
|
-
})).readonly()), method(_void(), object({ backend: string() }), {
|
|
14215
|
+
})), method(_void(), object({ backend: string() }), {
|
|
14324
14216
|
kind: "mutation",
|
|
14325
14217
|
auth: "admin"
|
|
14326
14218
|
});
|
|
@@ -15157,6 +15049,10 @@ var DeviceInfoSchema = object({
|
|
|
15157
15049
|
isCamera: boolean(),
|
|
15158
15050
|
/** Current config values — serializable snapshot */
|
|
15159
15051
|
config: record(string(), unknown()),
|
|
15052
|
+
/** Paths inside `config` the device's schema declares secret (D783) —
|
|
15053
|
+
* what the non-admin redaction withholds. Paths, never values. Absent
|
|
15054
|
+
* when the owning runner has not reported them. */
|
|
15055
|
+
secretConfigPaths: array(string()).optional(),
|
|
15160
15056
|
/** Hardware + identity blob (manufacturer / model / firmware / sn /
|
|
15161
15057
|
* uid / mac / …). Populated by drivers; editable via setMetadata. */
|
|
15162
15058
|
metadata: record(string(), unknown()).nullable().optional(),
|
|
@@ -15362,7 +15258,13 @@ var DeviceRegisterPayloadSchema = object({
|
|
|
15362
15258
|
* call (workers re-register on init), so probe-driven updates
|
|
15363
15259
|
* (e.g. PTZ flag flipping after the abilities probe) propagate. */
|
|
15364
15260
|
features: array(string()).optional(),
|
|
15365
|
-
config: record(string(), unknown())
|
|
15261
|
+
config: record(string(), unknown()),
|
|
15262
|
+
/** Config paths the device's own schema DECLARES secret
|
|
15263
|
+
* (`.meta({ secret: true })` — dotted, `[]` for array items, e.g.
|
|
15264
|
+
* `connection.password`). Re-published on every register; the non-admin
|
|
15265
|
+
* redaction withholds them at any depth (D783). Optional: an older runner
|
|
15266
|
+
* omits it and the keyword backstop applies. */
|
|
15267
|
+
secretConfigPaths: array(string()).optional()
|
|
15366
15268
|
});
|
|
15367
15269
|
var DeviceRemovePayloadSchema = object({ deviceId: number() });
|
|
15368
15270
|
var DevicePersistConfigPayloadSchema = object({
|
|
@@ -16189,6 +16091,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
|
|
|
16189
16091
|
kind: "mutation",
|
|
16190
16092
|
auth: "admin"
|
|
16191
16093
|
});
|
|
16094
|
+
var HUB_ADDRESS_ROLES = [
|
|
16095
|
+
"appConnections",
|
|
16096
|
+
"notificationTaps",
|
|
16097
|
+
"internal",
|
|
16098
|
+
"publicEndpoint"
|
|
16099
|
+
];
|
|
16192
16100
|
/**
|
|
16193
16101
|
* Transport bounds for AI capability methods.
|
|
16194
16102
|
*
|
|
@@ -17015,7 +16923,14 @@ var LoginMethodContributionSchema = discriminatedUnion("kind", [
|
|
|
17015
16923
|
icon: string().optional(),
|
|
17016
16924
|
/** Addon-owned HTTP route the button navigates to (GET). */
|
|
17017
16925
|
startUrl: string(),
|
|
17018
|
-
stage: LoginStageEnum
|
|
16926
|
+
stage: LoginStageEnum,
|
|
16927
|
+
/**
|
|
16928
|
+
* The provider names an external identity a signed-in user can link to
|
|
16929
|
+
* their own account (D782): `auth.listLinkableProviders` /
|
|
16930
|
+
* `beginExternalLink` offer exactly the redirect methods that set this,
|
|
16931
|
+
* whatever their id. Absent / false — a login button only (magic-link).
|
|
16932
|
+
*/
|
|
16933
|
+
linkable: boolean().optional()
|
|
17019
16934
|
}),
|
|
17020
16935
|
object({
|
|
17021
16936
|
kind: literal("widget"),
|
|
@@ -20360,7 +20275,13 @@ var NcAlarmModeDelaysListSchema = array(object({
|
|
|
20360
20275
|
* Absent = false (logged, not sent). Even when true it is not sent when that same sensor
|
|
20361
20276
|
* is the one that starts the entry delay — the entry-delay notification already names it.
|
|
20362
20277
|
*/
|
|
20363
|
-
notifySensorRewatched: boolean().optional()
|
|
20278
|
+
notifySensorRewatched: boolean().optional(),
|
|
20279
|
+
/**
|
|
20280
|
+
* D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
|
|
20281
|
+
* change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
|
|
20282
|
+
* re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
|
|
20283
|
+
*/
|
|
20284
|
+
notifySensorIgnored: boolean().optional()
|
|
20364
20285
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
|
|
20365
20286
|
var NcAlarmModeDelaysEditListSchema = array(object({
|
|
20366
20287
|
mode: AlarmArmModeSchema,
|
|
@@ -20373,7 +20294,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
|
|
|
20373
20294
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
20374
20295
|
notifyDuringEntryDelay: boolean().nullable().optional(),
|
|
20375
20296
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
20376
|
-
notifySensorRewatched: boolean().nullable().optional()
|
|
20297
|
+
notifySensorRewatched: boolean().nullable().optional(),
|
|
20298
|
+
/** D735: set the switch, or `null` to clear it (back to the default, false). */
|
|
20299
|
+
notifySensorIgnored: boolean().nullable().optional()
|
|
20377
20300
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
|
|
20378
20301
|
/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
|
|
20379
20302
|
var NcAlarmNonBlockingEditSchema = object({
|
|
@@ -21367,8 +21290,8 @@ Object.freeze(Object.fromEntries([{
|
|
|
21367
21290
|
var CLUSTER_STEP_SETTING_FIELDS = [{
|
|
21368
21291
|
stepId: "face-embedding",
|
|
21369
21292
|
key: "minLandmarkFaceSize",
|
|
21370
|
-
label: "Min face size
|
|
21371
|
-
description: "
|
|
21293
|
+
label: "Min face size to embed (detection-frame px)",
|
|
21294
|
+
description: "Faces smaller than this in the small frame the detector sees are not embedded, so they can never be recognised. Below it the face cannot be aligned reliably and a bad embedding matches everyone. Same value on every node. 0 = no limit.",
|
|
21372
21295
|
type: "slider",
|
|
21373
21296
|
min: 0,
|
|
21374
21297
|
max: 64,
|
|
@@ -22420,7 +22343,13 @@ var RetrainFrameSchema = object({
|
|
|
22420
22343
|
sizeBytes: number().int(),
|
|
22421
22344
|
width: number().int(),
|
|
22422
22345
|
height: number().int(),
|
|
22423
|
-
copiedAt: number()
|
|
22346
|
+
copiedAt: number(),
|
|
22347
|
+
/** When the CAMERA captured the frame. Absent on a copy taken before D785. */
|
|
22348
|
+
capturedAt: number().optional(),
|
|
22349
|
+
/** The operator's "every subject in this frame is boxed". Detector
|
|
22350
|
+
* evaluation keeps only complete frames: an unboxed subject would count as
|
|
22351
|
+
* a false positive. */
|
|
22352
|
+
complete: boolean()
|
|
22424
22353
|
});
|
|
22425
22354
|
/** Why a copy-on-select could not be honoured — named, never a silent skip. */
|
|
22426
22355
|
var RetrainCopyRefusalSchema = _enum([
|
|
@@ -22441,6 +22370,51 @@ var RetrainFrameListSchema = object({
|
|
|
22441
22370
|
/** What the page pre-selects — the native key frame when one survives. */
|
|
22442
22371
|
autoPickMediaId: number().int().optional()
|
|
22443
22372
|
});
|
|
22373
|
+
/**
|
|
22374
|
+
* Which frames an annotated export carries. Every field narrows; an empty
|
|
22375
|
+
* filter is every annotated copy. A dataset VERSION is a frozen `frameIds`
|
|
22376
|
+
* list owned by whoever trains (the training orchestrator), so `frameIds` is
|
|
22377
|
+
* the primitive a version export uses; `batchId` re-selects what an earlier
|
|
22378
|
+
* export carried (`exportedInBatch`).
|
|
22379
|
+
*/
|
|
22380
|
+
var RetrainExportFilterSchema = object({
|
|
22381
|
+
deviceIds: array(number()).optional(),
|
|
22382
|
+
frameIds: array(string()).max(2e4).optional(),
|
|
22383
|
+
batchId: string().optional(),
|
|
22384
|
+
/** Only frames the operator marked complete (all subjects boxed). */
|
|
22385
|
+
completeOnly: boolean().optional()
|
|
22386
|
+
});
|
|
22387
|
+
/**
|
|
22388
|
+
* `frames`: the full frame copies, boxes in `annotations.json`.
|
|
22389
|
+
* `crops`: additionally one JPEG per subject, cut with the runtime detail-crop
|
|
22390
|
+
* convention — the classifier layout.
|
|
22391
|
+
*/
|
|
22392
|
+
var RetrainExportLayoutSchema = _enum(["frames", "crops"]);
|
|
22393
|
+
/**
|
|
22394
|
+
* Where `writeRetrainArchive` streams the tar: one HTTP request whose body is
|
|
22395
|
+
* the archive, sent chunk by chunk. Covers a presigned PUT and a provider
|
|
22396
|
+
* addon's data-plane upload route alike. Headers are sent verbatim and never
|
|
22397
|
+
* logged.
|
|
22398
|
+
*/
|
|
22399
|
+
var RetrainArchiveTargetSchema = object({
|
|
22400
|
+
kind: literal("http"),
|
|
22401
|
+
method: _enum(["PUT", "POST"]),
|
|
22402
|
+
url: string().url(),
|
|
22403
|
+
headers: record(string(), string()).optional()
|
|
22404
|
+
});
|
|
22405
|
+
var RetrainArchiveResultSchema = object({
|
|
22406
|
+
batchId: string(),
|
|
22407
|
+
frames: number().int(),
|
|
22408
|
+
crops: number().int(),
|
|
22409
|
+
annotations: number().int(),
|
|
22410
|
+
/** Frames planned but not shipped (unreadable copy, path too long). */
|
|
22411
|
+
missing: number().int(),
|
|
22412
|
+
bytes: number().int(),
|
|
22413
|
+
/** sha256 of the exact bytes sent. */
|
|
22414
|
+
sha256: string(),
|
|
22415
|
+
/** The target's HTTP status. */
|
|
22416
|
+
status: number().int()
|
|
22417
|
+
});
|
|
22444
22418
|
/** What the operator asked the assist to look for. */
|
|
22445
22419
|
var RetrainAssistSubjectSchema = discriminatedUnion("kind", [object({
|
|
22446
22420
|
kind: literal("package"),
|
|
@@ -23235,9 +23209,25 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
23235
23209
|
}), RetrainTransitionResultSchema, {
|
|
23236
23210
|
kind: "mutation",
|
|
23237
23211
|
auth: "admin"
|
|
23238
|
-
}), method(
|
|
23212
|
+
}), method(RetrainExportFilterSchema.extend({ layout: RetrainExportLayoutSchema.optional() }), object({ url: string() }), {
|
|
23239
23213
|
kind: "query",
|
|
23240
23214
|
auth: "admin"
|
|
23215
|
+
}), method(object({
|
|
23216
|
+
deviceId: number(),
|
|
23217
|
+
trackId: string(),
|
|
23218
|
+
frameId: string(),
|
|
23219
|
+
complete: boolean()
|
|
23220
|
+
}), RetrainFrameSchema, {
|
|
23221
|
+
kind: "mutation",
|
|
23222
|
+
auth: "admin"
|
|
23223
|
+
}), method(object({
|
|
23224
|
+
filter: RetrainExportFilterSchema,
|
|
23225
|
+
layout: RetrainExportLayoutSchema,
|
|
23226
|
+
target: RetrainArchiveTargetSchema
|
|
23227
|
+
}), RetrainArchiveResultSchema, {
|
|
23228
|
+
kind: "mutation",
|
|
23229
|
+
auth: "admin",
|
|
23230
|
+
timeoutMs: 60 * 6e4
|
|
23241
23231
|
}), method(object({
|
|
23242
23232
|
/** Which of the three event tables owns the row. */
|
|
23243
23233
|
ownerType: EventOwnerTypeSchema,
|
|
@@ -23363,7 +23353,7 @@ var FrameRefSchema = object({
|
|
|
23363
23353
|
timestamp: number(),
|
|
23364
23354
|
capturedAt: number().optional()
|
|
23365
23355
|
});
|
|
23366
|
-
var ModelFormatSchema$
|
|
23356
|
+
var ModelFormatSchema$2 = _enum([
|
|
23367
23357
|
"onnx",
|
|
23368
23358
|
"coreml",
|
|
23369
23359
|
"openvino",
|
|
@@ -23381,7 +23371,7 @@ var PipelineSlotSchema = _enum([
|
|
|
23381
23371
|
var PipelineEngineChoiceSchema = object({
|
|
23382
23372
|
runtime: literal("python"),
|
|
23383
23373
|
backend: string(),
|
|
23384
|
-
format: ModelFormatSchema$
|
|
23374
|
+
format: ModelFormatSchema$2,
|
|
23385
23375
|
device: string().optional()
|
|
23386
23376
|
});
|
|
23387
23377
|
/**
|
|
@@ -23420,28 +23410,10 @@ var PipelineDefaultStepSchema = lazy(() => object({
|
|
|
23420
23410
|
group: string().optional(),
|
|
23421
23411
|
settings: record(string(), unknown()).optional()
|
|
23422
23412
|
}));
|
|
23423
|
-
var PipelineTemplateStepSchema = lazy(() => object({
|
|
23424
|
-
addonId: string(),
|
|
23425
|
-
enabled: boolean(),
|
|
23426
|
-
modelId: string(),
|
|
23427
|
-
children: array(PipelineTemplateStepSchema).readonly(),
|
|
23428
|
-
settings: record(string(), unknown()).optional()
|
|
23429
|
-
}));
|
|
23430
|
-
var PipelineTemplateSchema$1 = object({
|
|
23431
|
-
id: string(),
|
|
23432
|
-
name: string(),
|
|
23433
|
-
createdAt: string(),
|
|
23434
|
-
updatedAt: string(),
|
|
23435
|
-
engine: PipelineEngineChoiceSchema,
|
|
23436
|
-
steps: array(PipelineTemplateStepSchema).readonly()
|
|
23437
|
-
});
|
|
23438
23413
|
var PipelineModelOptionSchema = object({
|
|
23439
23414
|
id: string(),
|
|
23440
23415
|
name: string(),
|
|
23441
|
-
formats: record(string(),
|
|
23442
|
-
downloaded: boolean(),
|
|
23443
|
-
sizeMB: number()
|
|
23444
|
-
})),
|
|
23416
|
+
formats: record(string(), PipelineModelFormatStatusSchema),
|
|
23445
23417
|
group: ModelVariantGroupSchema.optional(),
|
|
23446
23418
|
legacy: boolean().optional(),
|
|
23447
23419
|
provider: ModelProviderIdSchema.optional(),
|
|
@@ -23608,6 +23580,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
23608
23580
|
}), {
|
|
23609
23581
|
kind: "mutation",
|
|
23610
23582
|
auth: "admin"
|
|
23583
|
+
}), method(object({
|
|
23584
|
+
nodeId: string(),
|
|
23585
|
+
deviceIds: array(number()).readonly().optional(),
|
|
23586
|
+
dryRun: boolean()
|
|
23587
|
+
}), object({
|
|
23588
|
+
entries: array(object({
|
|
23589
|
+
deviceId: number(),
|
|
23590
|
+
keys: array(string()).readonly()
|
|
23591
|
+
})).readonly(),
|
|
23592
|
+
refused: array(object({
|
|
23593
|
+
deviceId: number(),
|
|
23594
|
+
reason: string()
|
|
23595
|
+
})).readonly()
|
|
23596
|
+
}), {
|
|
23597
|
+
kind: "mutation",
|
|
23598
|
+
auth: "admin"
|
|
23611
23599
|
}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
|
|
23612
23600
|
/** `<backend>:<device>`, e.g. `openvino:gpu`. */
|
|
23613
23601
|
deviceKey: string(),
|
|
@@ -23633,22 +23621,14 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
23633
23621
|
}), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
|
|
23634
23622
|
steps: array(PipelineStepInputSchema),
|
|
23635
23623
|
deviceKey: string().optional()
|
|
23636
|
-
}), PipelineValidationResultSchema), method(_void(),
|
|
23637
|
-
name: string(),
|
|
23638
|
-
steps: array(PipelineTemplateStepSchema).readonly(),
|
|
23639
|
-
engine: PipelineEngineChoiceSchema
|
|
23640
|
-
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
|
|
23641
|
-
id: string(),
|
|
23642
|
-
name: string().optional(),
|
|
23643
|
-
steps: array(PipelineTemplateStepSchema).readonly().optional()
|
|
23644
|
-
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
23624
|
+
}), PipelineValidationResultSchema), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
23645
23625
|
addonId: string(),
|
|
23646
23626
|
modelId: string(),
|
|
23647
|
-
format: ModelFormatSchema$
|
|
23627
|
+
format: ModelFormatSchema$2
|
|
23648
23628
|
}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
|
|
23649
23629
|
addonId: string(),
|
|
23650
23630
|
modelId: string(),
|
|
23651
|
-
format: ModelFormatSchema$
|
|
23631
|
+
format: ModelFormatSchema$2
|
|
23652
23632
|
}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
|
|
23653
23633
|
steps: array(PipelineStepInputSchema).min(1),
|
|
23654
23634
|
frame: FrameInputSchema.optional(),
|
|
@@ -23805,6 +23785,375 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
23805
23785
|
filename: string().optional(),
|
|
23806
23786
|
settings: record(string(), unknown()).optional()
|
|
23807
23787
|
}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
|
|
23788
|
+
/**
|
|
23789
|
+
* The wire shapes of the Auto tune plan and apply (D745), used by the
|
|
23790
|
+
* `pipeline-orchestrator` cap. The recommender's own types
|
|
23791
|
+
* (`recommend.ts`) are the TS face of the same data; these
|
|
23792
|
+
* schemas are what crosses the cap boundary.
|
|
23793
|
+
*/
|
|
23794
|
+
var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
|
|
23795
|
+
/** The operator's range for it. */
|
|
23796
|
+
var MIN_SESSIONS_PER_DEVICE_RANGE = {
|
|
23797
|
+
min: 1,
|
|
23798
|
+
max: 8
|
|
23799
|
+
};
|
|
23800
|
+
var HardwareClassIdSchema = _enum([
|
|
23801
|
+
"intel-core-ultra",
|
|
23802
|
+
"intel-n-series",
|
|
23803
|
+
"apple-m-base",
|
|
23804
|
+
"apple-m-pro",
|
|
23805
|
+
"unknown"
|
|
23806
|
+
]);
|
|
23807
|
+
var AcceleratorKindSchema = _enum([
|
|
23808
|
+
"intel-npu",
|
|
23809
|
+
"intel-igpu",
|
|
23810
|
+
"x86-cpu",
|
|
23811
|
+
"arm-cpu",
|
|
23812
|
+
"apple-ane",
|
|
23813
|
+
"coral"
|
|
23814
|
+
]);
|
|
23815
|
+
var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
23816
|
+
object({
|
|
23817
|
+
kind: literal("capacity"),
|
|
23818
|
+
sessions: number(),
|
|
23819
|
+
minSessions: number()
|
|
23820
|
+
}),
|
|
23821
|
+
object({
|
|
23822
|
+
kind: literal("tie-faster"),
|
|
23823
|
+
over: string(),
|
|
23824
|
+
recallDelta: number()
|
|
23825
|
+
}),
|
|
23826
|
+
object({
|
|
23827
|
+
kind: literal("stepped-down"),
|
|
23828
|
+
from: string(),
|
|
23829
|
+
to: string(),
|
|
23830
|
+
limitedBy: string()
|
|
23831
|
+
}),
|
|
23832
|
+
object({
|
|
23833
|
+
kind: literal("no-fit-lightest"),
|
|
23834
|
+
sessions: number(),
|
|
23835
|
+
minSessions: number()
|
|
23836
|
+
}),
|
|
23837
|
+
object({
|
|
23838
|
+
kind: literal("derived-latency"),
|
|
23839
|
+
modelId: string()
|
|
23840
|
+
}),
|
|
23841
|
+
object({ kind: literal("cpu-device") }),
|
|
23842
|
+
object({ kind: literal("coral-untouched") }),
|
|
23843
|
+
object({ kind: literal("device-disabled") }),
|
|
23844
|
+
object({ kind: literal("device-unavailable") }),
|
|
23845
|
+
object({ kind: literal("node-offline") }),
|
|
23846
|
+
object({ kind: literal("no-hardware-facts") }),
|
|
23847
|
+
object({
|
|
23848
|
+
kind: literal("no-measured-data"),
|
|
23849
|
+
hardwareClass: HardwareClassIdSchema
|
|
23850
|
+
}),
|
|
23851
|
+
object({
|
|
23852
|
+
kind: literal("no-family-build"),
|
|
23853
|
+
format: ModelFormatSchema$1
|
|
23854
|
+
})
|
|
23855
|
+
]);
|
|
23856
|
+
var DeviceModelChoiceSchema = object({
|
|
23857
|
+
modelId: string(),
|
|
23858
|
+
p50Ms: number(),
|
|
23859
|
+
fps: number(),
|
|
23860
|
+
measured: boolean(),
|
|
23861
|
+
/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
|
|
23862
|
+
capacitySessions: number(),
|
|
23863
|
+
personRecall: number()
|
|
23864
|
+
});
|
|
23865
|
+
var DeviceRecommendationSchema = object({
|
|
23866
|
+
deviceKey: string(),
|
|
23867
|
+
accelerator: AcceleratorKindSchema.nullable(),
|
|
23868
|
+
enabled: boolean(),
|
|
23869
|
+
available: boolean(),
|
|
23870
|
+
chosen: DeviceModelChoiceSchema.nullable(),
|
|
23871
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
23872
|
+
});
|
|
23873
|
+
var NodeRecommendationSchema = object({
|
|
23874
|
+
nodeId: string(),
|
|
23875
|
+
reachable: boolean(),
|
|
23876
|
+
hardwareClass: HardwareClassIdSchema.nullable(),
|
|
23877
|
+
cpuModel: string().nullable(),
|
|
23878
|
+
skipped: boolean(),
|
|
23879
|
+
acceleratorModelId: string().nullable(),
|
|
23880
|
+
devices: array(DeviceRecommendationSchema).readonly(),
|
|
23881
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
23882
|
+
});
|
|
23883
|
+
var ModelPinChangeSchema = object({
|
|
23884
|
+
stepId: string(),
|
|
23885
|
+
before: string().nullable(),
|
|
23886
|
+
after: string().nullable()
|
|
23887
|
+
});
|
|
23888
|
+
var NodeDeviceChangeSchema = object({
|
|
23889
|
+
nodeId: string(),
|
|
23890
|
+
deviceKey: string(),
|
|
23891
|
+
madeExplicit: boolean(),
|
|
23892
|
+
modelPins: array(ModelPinChangeSchema).readonly(),
|
|
23893
|
+
thresholds: array(object({
|
|
23894
|
+
stepId: string(),
|
|
23895
|
+
keys: array(string()).readonly()
|
|
23896
|
+
})).readonly()
|
|
23897
|
+
});
|
|
23898
|
+
var CameraOverrideClearSchema = object({
|
|
23899
|
+
deviceId: number(),
|
|
23900
|
+
source: _enum(["step-override", "wholesale"]),
|
|
23901
|
+
nodeId: string(),
|
|
23902
|
+
deviceKey: string().nullable(),
|
|
23903
|
+
stepId: string(),
|
|
23904
|
+
modelIdBefore: string().nullable(),
|
|
23905
|
+
keys: array(string()).readonly()
|
|
23906
|
+
});
|
|
23907
|
+
var DetectorStoreClearSchema = object({
|
|
23908
|
+
deviceId: number(),
|
|
23909
|
+
keys: array(string()).readonly()
|
|
23910
|
+
});
|
|
23911
|
+
var AutoTuneWarningSchema = discriminatedUnion("kind", [
|
|
23912
|
+
object({
|
|
23913
|
+
kind: literal("detector-store-cluster-wide"),
|
|
23914
|
+
skippedNodes: array(string()).readonly()
|
|
23915
|
+
}),
|
|
23916
|
+
object({
|
|
23917
|
+
kind: literal("detector-store-unreadable"),
|
|
23918
|
+
error: string()
|
|
23919
|
+
}),
|
|
23920
|
+
object({
|
|
23921
|
+
kind: literal("coral-enabled"),
|
|
23922
|
+
nodeId: string(),
|
|
23923
|
+
deviceKey: string()
|
|
23924
|
+
})
|
|
23925
|
+
]);
|
|
23926
|
+
var AutoTuneOptionsSchema = object({
|
|
23927
|
+
/** Share of each accelerator's throughput kept free (0.3–0.5). */
|
|
23928
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
23929
|
+
/**
|
|
23930
|
+
* The least number of parallel sessions every device must sustain at the
|
|
23931
|
+
* camera rate with the headroom kept free (D755). The most accurate model
|
|
23932
|
+
* that reaches it wins.
|
|
23933
|
+
*/
|
|
23934
|
+
minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
|
|
23935
|
+
});
|
|
23936
|
+
var AutoTunePlanSchema = object({
|
|
23937
|
+
/** Hash of everything the apply will write — the apply refuses a different one. */
|
|
23938
|
+
planHash: string(),
|
|
23939
|
+
family: literal("yolov9"),
|
|
23940
|
+
headroom: number(),
|
|
23941
|
+
minSessionsPerDevice: number(),
|
|
23942
|
+
/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
|
|
23943
|
+
cameraFps: number(),
|
|
23944
|
+
generatedAt: number(),
|
|
23945
|
+
nodes: array(NodeRecommendationSchema).readonly(),
|
|
23946
|
+
nodeChanges: array(NodeDeviceChangeSchema).readonly(),
|
|
23947
|
+
cameraClears: array(CameraOverrideClearSchema).readonly(),
|
|
23948
|
+
detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
|
|
23949
|
+
warnings: array(AutoTuneWarningSchema).readonly()
|
|
23950
|
+
});
|
|
23951
|
+
var AutoTuneApplyInputSchema = object({
|
|
23952
|
+
planHash: string(),
|
|
23953
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
23954
|
+
minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
|
|
23955
|
+
});
|
|
23956
|
+
var AutoTunePhaseResultSchema = object({
|
|
23957
|
+
phase: _enum([
|
|
23958
|
+
"download",
|
|
23959
|
+
"camera-overrides",
|
|
23960
|
+
"detector-thresholds",
|
|
23961
|
+
"node-models",
|
|
23962
|
+
"redispatch"
|
|
23963
|
+
]),
|
|
23964
|
+
ok: boolean(),
|
|
23965
|
+
detail: string()
|
|
23966
|
+
});
|
|
23967
|
+
var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
|
|
23968
|
+
object({
|
|
23969
|
+
kind: literal("applied"),
|
|
23970
|
+
planHash: string(),
|
|
23971
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
23972
|
+
}),
|
|
23973
|
+
object({
|
|
23974
|
+
kind: literal("aborted"),
|
|
23975
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
23976
|
+
}),
|
|
23977
|
+
object({
|
|
23978
|
+
kind: literal("stale"),
|
|
23979
|
+
plan: AutoTunePlanSchema
|
|
23980
|
+
}),
|
|
23981
|
+
object({
|
|
23982
|
+
kind: literal("refused"),
|
|
23983
|
+
reason: _enum(["apply-in-progress"])
|
|
23984
|
+
})
|
|
23985
|
+
]);
|
|
23986
|
+
/**
|
|
23987
|
+
* Wire shapes of the Load balancing surface (D748): the session placement
|
|
23988
|
+
* policy, the atomic share write, the observed placement statistics, the
|
|
23989
|
+
* hardware share suggestion and the stale device pins.
|
|
23990
|
+
*/
|
|
23991
|
+
/**
|
|
23992
|
+
* How a new detection session picks its node and device.
|
|
23993
|
+
* - `least-loaded` — the historical rule: lowest `attached / weight`, a
|
|
23994
|
+
* constant node order at a tie (D37). An idle node always ties at 0, so a
|
|
23995
|
+
* weight only bites once a node already holds a session.
|
|
23996
|
+
* - `share` — the share of PARALLEL sessions is held to the weights, and a
|
|
23997
|
+
* full or drowning node yields to a free one (D748).
|
|
23998
|
+
*/
|
|
23999
|
+
var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
|
|
24000
|
+
var LoadBalancingSharesInputSchema = object({
|
|
24001
|
+
/** nodeId → share (> 0). A node left out keeps its weight. */
|
|
24002
|
+
nodes: record(string(), number().positive()).default({}),
|
|
24003
|
+
/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
|
|
24004
|
+
devices: record(string(), record(string(), number().positive())).default({})
|
|
24005
|
+
});
|
|
24006
|
+
var PlacementStatsInputSchema = object({
|
|
24007
|
+
/** Window the observed shares are averaged over (default 1 h, max 24 h). */
|
|
24008
|
+
windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
|
|
24009
|
+
var PlacementDeviceStatsSchema = object({
|
|
24010
|
+
deviceKey: string(),
|
|
24011
|
+
/** Sessions running on this device now. */
|
|
24012
|
+
sessionsNow: number(),
|
|
24013
|
+
/** Sessions started on this device inside the window. */
|
|
24014
|
+
sessionsStarted: number(),
|
|
24015
|
+
/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
|
|
24016
|
+
observedShare: number().nullable()
|
|
24017
|
+
});
|
|
24018
|
+
var PlacementNodeStatsSchema = object({
|
|
24019
|
+
nodeId: string(),
|
|
24020
|
+
sessionsNow: number(),
|
|
24021
|
+
sessionsStarted: number(),
|
|
24022
|
+
/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
|
|
24023
|
+
observedShare: number().nullable(),
|
|
24024
|
+
/** Most sessions this node ran at once inside the window. */
|
|
24025
|
+
peakSessions: number(),
|
|
24026
|
+
/** Sessions a share election handed elsewhere because this node was full or drowning. */
|
|
24027
|
+
yieldsAway: number(),
|
|
24028
|
+
devices: array(PlacementDeviceStatsSchema).readonly()
|
|
24029
|
+
});
|
|
24030
|
+
/** A camera's device pin that the session path cannot honour. */
|
|
24031
|
+
var StaleDevicePinSchema = object({
|
|
24032
|
+
deviceId: number(),
|
|
24033
|
+
deviceKey: string(),
|
|
24034
|
+
/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
|
|
24035
|
+
reason: _enum(["disabled", "absent"])
|
|
24036
|
+
});
|
|
24037
|
+
var PlacementStatsSchema = object({
|
|
24038
|
+
policy: SessionPlacementPolicySchema,
|
|
24039
|
+
windowMs: number(),
|
|
24040
|
+
/** How much of the window was actually observed (the hub keeps it in memory). */
|
|
24041
|
+
observedForMs: number(),
|
|
24042
|
+
sessionsNow: number(),
|
|
24043
|
+
/** Most parallel sessions across the cluster inside the window. */
|
|
24044
|
+
clusterPeakSessions: number(),
|
|
24045
|
+
nodes: array(PlacementNodeStatsSchema).readonly(),
|
|
24046
|
+
stalePins: array(StaleDevicePinSchema).readonly()
|
|
24047
|
+
});
|
|
24048
|
+
/**
|
|
24049
|
+
* Where an automatic share's capacity comes from (D755).
|
|
24050
|
+
* - `hardware` — the static capacity of each device at its Auto tune model:
|
|
24051
|
+
* the measured latency table for the node's hardware class.
|
|
24052
|
+
* - `benchmark` — the node's own measured capacity (node benchmark results).
|
|
24053
|
+
* A node with no results falls back to `hardware`, and says so.
|
|
24054
|
+
*/
|
|
24055
|
+
var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
|
|
24056
|
+
/** Why a node under the `benchmark` source was sized from hardware instead. */
|
|
24057
|
+
var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
|
|
24058
|
+
var SuggestSharesInputSchema = object({
|
|
24059
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24060
|
+
/** Default `hardware`. */
|
|
24061
|
+
source: CapacitySourceSchema.default("hardware")
|
|
24062
|
+
});
|
|
24063
|
+
var SuggestedDeviceShareSchema = object({
|
|
24064
|
+
deviceKey: string(),
|
|
24065
|
+
/** Share of the node (0–100, rounded). */
|
|
24066
|
+
share: number(),
|
|
24067
|
+
modelId: string().nullable(),
|
|
24068
|
+
/** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
|
|
24069
|
+
fps: number().nullable(),
|
|
24070
|
+
/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
|
|
24071
|
+
measured: boolean(),
|
|
24072
|
+
/**
|
|
24073
|
+
* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
|
|
24074
|
+
* or the benchmark's measured max sessions. Never enforced.
|
|
24075
|
+
*/
|
|
24076
|
+
suggestedMaxSessions: number().nullable()
|
|
24077
|
+
});
|
|
24078
|
+
var SuggestedNodeShareSchema = object({
|
|
24079
|
+
nodeId: string(),
|
|
24080
|
+
/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
|
|
24081
|
+
share: number().nullable(),
|
|
24082
|
+
/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
|
|
24083
|
+
capacitySessions: number(),
|
|
24084
|
+
devices: array(SuggestedDeviceShareSchema).readonly(),
|
|
24085
|
+
skippedReason: string().nullable(),
|
|
24086
|
+
/** What this node's capacity was read from; null when the node is skipped. */
|
|
24087
|
+
capacitySource: CapacitySourceSchema.nullable(),
|
|
24088
|
+
/** Set when the `benchmark` source was asked for and this node used `hardware`. */
|
|
24089
|
+
capacityFallback: CapacityFallbackSchema.nullable()
|
|
24090
|
+
});
|
|
24091
|
+
var SuggestSharesResultSchema = object({
|
|
24092
|
+
headroom: number(),
|
|
24093
|
+
/** The source asked for; each node says what it actually used. */
|
|
24094
|
+
source: CapacitySourceSchema,
|
|
24095
|
+
/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
|
|
24096
|
+
cameraFps: number(),
|
|
24097
|
+
/** The Auto tune capacity floor the models were picked at. */
|
|
24098
|
+
minSessionsPerDevice: number(),
|
|
24099
|
+
nodes: array(SuggestedNodeShareSchema).readonly()
|
|
24100
|
+
});
|
|
24101
|
+
/**
|
|
24102
|
+
* Where the node and device shares come from (D750, D755).
|
|
24103
|
+
* - `hardware` (default) — computed by the system from each node's static
|
|
24104
|
+
* capacity (its accelerators at their Auto tune models, from the measured
|
|
24105
|
+
* latency table), recomputed whenever a node or device joins, leaves, is
|
|
24106
|
+
* switched on or off, or changes model. No load input.
|
|
24107
|
+
* - `benchmark` — the same, from each node's measured capacity (node
|
|
24108
|
+
* benchmark results); a node without results falls back to `hardware`.
|
|
24109
|
+
* - `manual` — the operator's stored sliders.
|
|
24110
|
+
* Either way a node or device that cannot take sessions gives its share to
|
|
24111
|
+
* the others in proportion; the stored values are never rewritten for that.
|
|
24112
|
+
*/
|
|
24113
|
+
var ShareSourceSchema = _enum([
|
|
24114
|
+
"hardware",
|
|
24115
|
+
"benchmark",
|
|
24116
|
+
"manual"
|
|
24117
|
+
]);
|
|
24118
|
+
var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
|
|
24119
|
+
object({
|
|
24120
|
+
nodes: record(string(), number()),
|
|
24121
|
+
devices: record(string(), record(string(), number()))
|
|
24122
|
+
});
|
|
24123
|
+
var EffectiveDeviceShareSchema = object({
|
|
24124
|
+
deviceKey: string(),
|
|
24125
|
+
/** Can take sessions now (enabled, available, can run the root). */
|
|
24126
|
+
eligible: boolean(),
|
|
24127
|
+
/** The share the source assigns, as a percentage of the node's devices. */
|
|
24128
|
+
configuredPct: number(),
|
|
24129
|
+
/** The share actually used, after an ineligible device's share went to the others. */
|
|
24130
|
+
effectivePct: number()
|
|
24131
|
+
});
|
|
24132
|
+
var EffectiveNodeShareSchema = object({
|
|
24133
|
+
nodeId: string(),
|
|
24134
|
+
eligible: boolean(),
|
|
24135
|
+
configuredPct: number(),
|
|
24136
|
+
effectivePct: number(),
|
|
24137
|
+
/** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
|
|
24138
|
+
capacitySource: CapacitySourceSchema.nullable(),
|
|
24139
|
+
/** Automatic `benchmark`: why this node used `hardware` instead. */
|
|
24140
|
+
capacityFallback: CapacityFallbackSchema.nullable(),
|
|
24141
|
+
devices: array(EffectiveDeviceShareSchema).readonly()
|
|
24142
|
+
});
|
|
24143
|
+
var EffectiveSharesSchema = object({
|
|
24144
|
+
source: ShareSourceSchema,
|
|
24145
|
+
policy: SessionPlacementPolicySchema,
|
|
24146
|
+
/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
|
|
24147
|
+
autoPending: boolean(),
|
|
24148
|
+
/** When the automatic shares were last computed (ms epoch); null = never. */
|
|
24149
|
+
computedAt: number().nullable(),
|
|
24150
|
+
/** What made the system recompute them last. */
|
|
24151
|
+
trigger: string().nullable(),
|
|
24152
|
+
nodes: array(EffectiveNodeShareSchema).readonly(),
|
|
24153
|
+
/** The relative weights the election reads (before eligibility). */
|
|
24154
|
+
nodeWeights: record(string(), number()),
|
|
24155
|
+
deviceWeights: record(string(), record(string(), number()))
|
|
24156
|
+
});
|
|
23808
24157
|
object({
|
|
23809
24158
|
activeCameras: number(),
|
|
23810
24159
|
throttledCameras: number(),
|
|
@@ -24682,14 +25031,15 @@ var RunnerLocalLoadSchema = object({
|
|
|
24682
25031
|
* Per-inference-device live load (multi-device C4). One entry per deviceKey
|
|
24683
25032
|
* this runner currently has attached cameras on, so the orchestrator's second
|
|
24684
25033
|
* `balance()` pass (over a node's devices) weights on real per-pool session
|
|
24685
|
-
* counts. Empty on single-device / pre-multi-device runners.
|
|
24686
|
-
* per
|
|
25034
|
+
* counts. Empty on single-device / pre-multi-device runners. There is no
|
|
25035
|
+
* per-device queue depth: the inference pool's backlog has no accessor, and
|
|
25036
|
+
* a field that always read 0 was removed rather than shown as a measurement
|
|
25037
|
+
* (D762).
|
|
24687
25038
|
*/
|
|
24688
25039
|
devices: array(object({
|
|
24689
25040
|
deviceKey: string(),
|
|
24690
25041
|
backend: string(),
|
|
24691
|
-
attachedCameras: number()
|
|
24692
|
-
queueDepthTotal: number()
|
|
25042
|
+
attachedCameras: number()
|
|
24693
25043
|
})).default([]),
|
|
24694
25044
|
/** Hardware capability flags reported by this node. */
|
|
24695
25045
|
hardware: object({
|
|
@@ -24903,14 +25253,6 @@ var CameraPipelineConfigSchema = object({
|
|
|
24903
25253
|
settings: record(string(), unknown()).readonly().optional()
|
|
24904
25254
|
}).nullable().optional()
|
|
24905
25255
|
});
|
|
24906
|
-
var PipelineTemplateSchema = object({
|
|
24907
|
-
id: string(),
|
|
24908
|
-
name: string(),
|
|
24909
|
-
description: string().optional(),
|
|
24910
|
-
config: CameraPipelineConfigSchema,
|
|
24911
|
-
createdAt: string(),
|
|
24912
|
-
updatedAt: string()
|
|
24913
|
-
});
|
|
24914
25256
|
var DeviceStepConfigSchema = object({
|
|
24915
25257
|
modelId: string().optional(),
|
|
24916
25258
|
settings: record(string(), unknown()).optional(),
|
|
@@ -24984,9 +25326,10 @@ var CameraStepOverridePatchSchema = object({
|
|
|
24984
25326
|
modelId: string().optional(),
|
|
24985
25327
|
settings: record(string(), unknown()).readonly().optional()
|
|
24986
25328
|
});
|
|
25329
|
+
var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
|
|
24987
25330
|
var CameraPipelineSettingsSchema = object({
|
|
24988
|
-
pinnedAgentNodeId: string().optional(),
|
|
24989
25331
|
stepToggles: record(string(), boolean()).optional(),
|
|
25332
|
+
stepSettings: CameraStepSettingsSchema.optional(),
|
|
24990
25333
|
stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
|
|
24991
25334
|
pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
|
|
24992
25335
|
});
|
|
@@ -25019,7 +25362,10 @@ var PipelineAssignmentSchema = object({
|
|
|
25019
25362
|
});
|
|
25020
25363
|
/**
|
|
25021
25364
|
* Per-agent load summary surfaced to the load balancer + dashboards.
|
|
25022
|
-
* Aggregated from each runner's `getLocalLoad` cap call.
|
|
25365
|
+
* Aggregated from each runner's `getLocalLoad` cap call. In the
|
|
25366
|
+
* `getAgentLoad` report, a single-device node's default-pool sessions (no
|
|
25367
|
+
* `deviceKey`) are credited to its one eligible device in `load.devices` —
|
|
25368
|
+
* the default pool IS that device (D745); the balancer's census stays raw.
|
|
25023
25369
|
*/
|
|
25024
25370
|
var AgentLoadSummarySchema = object({
|
|
25025
25371
|
nodeId: string(),
|
|
@@ -25108,26 +25454,27 @@ var CameraBrokerStatusSchema = object({
|
|
|
25108
25454
|
width: number(),
|
|
25109
25455
|
height: number(),
|
|
25110
25456
|
subscribers: number(),
|
|
25111
|
-
|
|
25112
|
-
|
|
25457
|
+
/**
|
|
25458
|
+
* Encoded packets/s the broker receives from the camera. null when the
|
|
25459
|
+
* broker's stats read failed — unknown, never 0 (a 0 here reads as a stall).
|
|
25460
|
+
* There is no output rate: decoding runs in the session decode workers, not
|
|
25461
|
+
* in the broker, so the broker's own decoded-frame rate is 0 on every live
|
|
25462
|
+
* camera and is not served (D758).
|
|
25463
|
+
*/
|
|
25464
|
+
inFps: number().nullable()
|
|
25113
25465
|
})).readonly(),
|
|
25114
25466
|
webrtcSessions: number(),
|
|
25115
25467
|
rtspRestream: boolean()
|
|
25116
25468
|
});
|
|
25117
|
-
/**
|
|
25118
|
-
|
|
25119
|
-
|
|
25120
|
-
|
|
25121
|
-
|
|
25122
|
-
|
|
25123
|
-
|
|
25124
|
-
|
|
25125
|
-
var CameraDecoderStatusSchema = object({
|
|
25126
|
-
nodeId: string(),
|
|
25127
|
-
formats: array(string()).readonly(),
|
|
25128
|
-
sessionCount: number(),
|
|
25129
|
-
shm: CameraDecoderShmSchema
|
|
25130
|
-
});
|
|
25469
|
+
/**
|
|
25470
|
+
* Decoder block — WHERE decode runs (co-located with the detection node by
|
|
25471
|
+
* construction); null when the camera has no detection node. It carries no
|
|
25472
|
+
* frame counter: the shared-memory plane whose counters it used to serve is
|
|
25473
|
+
* gone, and those fields read 0 forever. Whether frames actually flow is read
|
|
25474
|
+
* from `detection.actualFps` (frames delivered to and processed by the
|
|
25475
|
+
* detector), never from a counter nothing feeds.
|
|
25476
|
+
*/
|
|
25477
|
+
var CameraDecoderStatusSchema = object({ nodeId: string() });
|
|
25131
25478
|
/** Motion block — null when motion detection is not active for this device. */
|
|
25132
25479
|
var CameraMotionStatusSchema = object({
|
|
25133
25480
|
enabled: boolean(),
|
|
@@ -25484,12 +25831,6 @@ method(object({
|
|
|
25484
25831
|
}), object({ success: literal(true) }), {
|
|
25485
25832
|
kind: "mutation",
|
|
25486
25833
|
auth: "admin"
|
|
25487
|
-
}), method(object({
|
|
25488
|
-
agentNodeId: string(),
|
|
25489
|
-
detectWeight: number().positive().nullable()
|
|
25490
|
-
}), object({ success: literal(true) }), {
|
|
25491
|
-
kind: "mutation",
|
|
25492
|
-
auth: "admin"
|
|
25493
25834
|
}), method(object({
|
|
25494
25835
|
agentNodeId: string(),
|
|
25495
25836
|
detect: boolean().nullable().optional(),
|
|
@@ -25531,6 +25872,15 @@ method(object({
|
|
|
25531
25872
|
}), {
|
|
25532
25873
|
kind: "mutation",
|
|
25533
25874
|
auth: "admin"
|
|
25875
|
+
}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
|
|
25876
|
+
kind: "mutation",
|
|
25877
|
+
auth: "admin"
|
|
25878
|
+
}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
|
|
25879
|
+
kind: "mutation",
|
|
25880
|
+
auth: "admin"
|
|
25881
|
+
}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
|
|
25882
|
+
kind: "mutation",
|
|
25883
|
+
auth: "admin"
|
|
25534
25884
|
}), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
|
|
25535
25885
|
deviceId: number(),
|
|
25536
25886
|
addonId: string(),
|
|
@@ -25547,6 +25897,13 @@ method(object({
|
|
|
25547
25897
|
}), object({ success: literal(true) }), {
|
|
25548
25898
|
kind: "mutation",
|
|
25549
25899
|
auth: "admin"
|
|
25900
|
+
}), method(object({
|
|
25901
|
+
deviceId: number(),
|
|
25902
|
+
addonId: string(),
|
|
25903
|
+
settings: record(string(), unknown()).nullable()
|
|
25904
|
+
}), object({ success: literal(true) }), {
|
|
25905
|
+
kind: "mutation",
|
|
25906
|
+
auth: "admin"
|
|
25550
25907
|
}), method(object({
|
|
25551
25908
|
deviceId: number(),
|
|
25552
25909
|
agentNodeId: string(),
|
|
@@ -25570,25 +25927,7 @@ method(object({
|
|
|
25570
25927
|
}), method(_void(), DiskReconcileJobSchema, {
|
|
25571
25928
|
kind: "mutation",
|
|
25572
25929
|
auth: "admin"
|
|
25573
|
-
}), method(_void(), DiskReconcileJobSchema, { auth: "admin" })
|
|
25574
|
-
name: string(),
|
|
25575
|
-
description: string().optional(),
|
|
25576
|
-
config: CameraPipelineConfigSchema
|
|
25577
|
-
}), PipelineTemplateSchema, {
|
|
25578
|
-
kind: "mutation",
|
|
25579
|
-
auth: "admin"
|
|
25580
|
-
}), method(object({
|
|
25581
|
-
id: string(),
|
|
25582
|
-
name: string().optional(),
|
|
25583
|
-
description: string().optional(),
|
|
25584
|
-
config: CameraPipelineConfigSchema.optional()
|
|
25585
|
-
}), PipelineTemplateSchema, {
|
|
25586
|
-
kind: "mutation",
|
|
25587
|
-
auth: "admin"
|
|
25588
|
-
}), method(object({ id: string() }), object({ success: literal(true) }), {
|
|
25589
|
-
kind: "mutation",
|
|
25590
|
-
auth: "admin"
|
|
25591
|
-
});
|
|
25930
|
+
}), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
|
|
25592
25931
|
/**
|
|
25593
25932
|
* Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
|
|
25594
25933
|
* `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
|
|
@@ -26178,7 +26517,19 @@ var SsoBridgeClaimsSchema = object({
|
|
|
26178
26517
|
* editing a descriptor must not retroactively extend or shorten a link the
|
|
26179
26518
|
* operator already consented to.
|
|
26180
26519
|
*/
|
|
26181
|
-
refreshTtl: union([number().int().positive(), literal("never")]).optional()
|
|
26520
|
+
refreshTtl: union([number().int().positive(), literal("never")]).optional(),
|
|
26521
|
+
/**
|
|
26522
|
+
* Opaque handle of a hub-side LINK intent (D782). Set by an OIDC callback
|
|
26523
|
+
* that was started from a signed-in user's "Link" button: the finish then
|
|
26524
|
+
* links this identity to the intent's user instead of signing anyone in.
|
|
26525
|
+
* The handle carries no user id — the hub resolves it, single-use.
|
|
26526
|
+
*/
|
|
26527
|
+
linkIntent: string().optional(),
|
|
26528
|
+
/**
|
|
26529
|
+
* Verified `iss` of the id_token behind an OIDC login bridge (D782). A
|
|
26530
|
+
* subject is unique only per issuer, so a link is bound to it.
|
|
26531
|
+
*/
|
|
26532
|
+
issuer: string().optional()
|
|
26182
26533
|
});
|
|
26183
26534
|
method(object({
|
|
26184
26535
|
claims: SsoBridgeClaimsSchema,
|
|
@@ -27808,8 +28159,6 @@ var WebrtcStreamChoiceSchema = object({
|
|
|
27808
28159
|
]).nullable(),
|
|
27809
28160
|
/** Input FPS from the camera (null for adaptive). */
|
|
27810
28161
|
inputFps: number().nullable(),
|
|
27811
|
-
/** Decoded FPS (null for adaptive). */
|
|
27812
|
-
decodeFps: number().nullable(),
|
|
27813
28162
|
/** Bitrate in kbps (null for adaptive). */
|
|
27814
28163
|
bitrateKbps: number().nullable()
|
|
27815
28164
|
});
|
|
@@ -28086,7 +28435,22 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
|
|
|
28086
28435
|
* field their hints were silently stripped by the schema and the
|
|
28087
28436
|
* adaptive ladder started blind on the client's display size.
|
|
28088
28437
|
*/
|
|
28089
|
-
hints: webrtcClientHintsSchema.optional()
|
|
28438
|
+
hints: webrtcClientHintsSchema.optional(),
|
|
28439
|
+
/**
|
|
28440
|
+
* Talk-back (D771): relay the PEER's audio to the device's speaker
|
|
28441
|
+
* through the `intercom` cap's push-talk triple. When `true` and the
|
|
28442
|
+
* offer lets the peer send audio, the answer's audio is `sendrecv`
|
|
28443
|
+
* and every inbound frame goes to `intercom.pushTalkAudio` for this
|
|
28444
|
+
* `deviceId`; absent/false answers `sendonly`, as for every viewer.
|
|
28445
|
+
*
|
|
28446
|
+
* TRUSTED-CALLER ONLY. Set by the Alexa export for an Echo on a camera
|
|
28447
|
+
* with `intercom`, when the linked user may control that camera. The
|
|
28448
|
+
* hub STRIPS it from every request-bound call (a browser), exactly as
|
|
28449
|
+
* it overwrites `relayOnly` — a viewer's talk permission is the
|
|
28450
|
+
* intercom cap's own surface (share tokens gate it there), and this
|
|
28451
|
+
* flag must not become a second door to the camera's speaker.
|
|
28452
|
+
*/
|
|
28453
|
+
talkback: boolean().optional()
|
|
28090
28454
|
}), object({
|
|
28091
28455
|
sessionId: string(),
|
|
28092
28456
|
sdpAnswer: string()
|
|
@@ -28141,6 +28505,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
|
|
|
28141
28505
|
*/
|
|
28142
28506
|
alive: boolean()
|
|
28143
28507
|
})), method(object({
|
|
28508
|
+
deviceId: number().int().nonnegative(),
|
|
28509
|
+
sessionId: string(),
|
|
28510
|
+
downlinkMbps: number().nonnegative()
|
|
28511
|
+
}), object({
|
|
28512
|
+
outcome: _enum(["switching", "held"]),
|
|
28513
|
+
tier: CamProfileSchema.nullable(),
|
|
28514
|
+
reason: string()
|
|
28515
|
+
}), { kind: "mutation" }), method(object({
|
|
28144
28516
|
deviceId: number().int().nonnegative(),
|
|
28145
28517
|
sessionId: string()
|
|
28146
28518
|
}), WebrtcSessionDebugSchema, { kind: "query" });
|
|
@@ -28380,6 +28752,59 @@ var AddonAutoUpdateSchema = ChannelWithInheritSchema;
|
|
|
28380
28752
|
var RestartAddonResultSchema = unknown();
|
|
28381
28753
|
var InstallPackageResultSchema = unknown();
|
|
28382
28754
|
var ReloadPackagesResultSchema = unknown();
|
|
28755
|
+
/**
|
|
28756
|
+
* What an uninstall did on ONE node.
|
|
28757
|
+
* - `uninstalled` — removed: runner(s) stopped, caps gone, code deleted.
|
|
28758
|
+
* - `not-installed` — the node did not have it (nothing to do).
|
|
28759
|
+
* - `refused` — protected / bootstrap package; nothing touched.
|
|
28760
|
+
* - `failed` — attempted and did not complete; `error` says why.
|
|
28761
|
+
* - `pending-reconnect` — the node is OFFLINE: its record was pruned so the
|
|
28762
|
+
* back-fill never returns the package, and the stale-addon sweep removes the
|
|
28763
|
+
* copy when the node registers again (only once the hub no longer has it).
|
|
28764
|
+
*/
|
|
28765
|
+
var UninstallNodeOutcomeSchema = _enum([
|
|
28766
|
+
"uninstalled",
|
|
28767
|
+
"not-installed",
|
|
28768
|
+
"refused",
|
|
28769
|
+
"failed",
|
|
28770
|
+
"pending-reconnect"
|
|
28771
|
+
]);
|
|
28772
|
+
var UninstallNodeResultSchema = object({
|
|
28773
|
+
nodeId: string(),
|
|
28774
|
+
outcome: UninstallNodeOutcomeSchema,
|
|
28775
|
+
error: string().optional(),
|
|
28776
|
+
addonIds: array(string()).readonly(),
|
|
28777
|
+
runnersStopped: array(string()).readonly(),
|
|
28778
|
+
warnings: array(string()).readonly()
|
|
28779
|
+
});
|
|
28780
|
+
var UninstallPackageResultSchema = object({
|
|
28781
|
+
/** Every targeted node ended `uninstalled`, `not-installed` or `pending-reconnect`. */
|
|
28782
|
+
success: boolean(),
|
|
28783
|
+
packageName: string(),
|
|
28784
|
+
results: array(UninstallNodeResultSchema).readonly()
|
|
28785
|
+
});
|
|
28786
|
+
/**
|
|
28787
|
+
* `unreachable` lists online agents whose status read FAILED — absence from
|
|
28788
|
+
* `installations` is only "not installed" for a node that answered (D315).
|
|
28789
|
+
*/
|
|
28790
|
+
var PackageInstallationsSchema = object({
|
|
28791
|
+
installations: array(object({
|
|
28792
|
+
packageName: string(),
|
|
28793
|
+
nodeId: string(),
|
|
28794
|
+
nodeName: string(),
|
|
28795
|
+
isHub: boolean(),
|
|
28796
|
+
isOnline: boolean(),
|
|
28797
|
+
version: string().nullable(),
|
|
28798
|
+
addonIds: array(string()).readonly(),
|
|
28799
|
+
source: _enum(["live", "recorded"]),
|
|
28800
|
+
/** The hub installs this package too. `false` on an agent row = an orphan. */
|
|
28801
|
+
onHub: boolean()
|
|
28802
|
+
})).readonly(),
|
|
28803
|
+
unreachable: array(object({
|
|
28804
|
+
nodeId: string(),
|
|
28805
|
+
error: string()
|
|
28806
|
+
})).readonly()
|
|
28807
|
+
});
|
|
28383
28808
|
var BulkUpdateItemStatusSchema = _enum([
|
|
28384
28809
|
"queued",
|
|
28385
28810
|
"updating",
|
|
@@ -28462,10 +28887,14 @@ method(_void(), array(AddonListItemSchema).readonly()), method(object({
|
|
|
28462
28887
|
}), method(object({ packageName: string() }), InstallPackageResultSchema, {
|
|
28463
28888
|
kind: "mutation",
|
|
28464
28889
|
auth: "admin"
|
|
28465
|
-
}), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({
|
|
28890
|
+
}), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({
|
|
28891
|
+
packageName: string().min(1),
|
|
28892
|
+
nodeId: string().optional(),
|
|
28893
|
+
everywhere: boolean().optional()
|
|
28894
|
+
}), UninstallPackageResultSchema, {
|
|
28466
28895
|
kind: "mutation",
|
|
28467
28896
|
auth: "admin"
|
|
28468
|
-
}), method(_void(), ReloadPackagesResultSchema, {
|
|
28897
|
+
}), method(object({ packageName: string().optional() }), PackageInstallationsSchema, { auth: "admin" }), method(_void(), ReloadPackagesResultSchema, {
|
|
28469
28898
|
kind: "mutation",
|
|
28470
28899
|
auth: "admin"
|
|
28471
28900
|
}), method(object({ query: string().optional() }), array(SearchResultSchema)), method(object({ nodeId: string().optional() }), array(PackageUpdateSchema).readonly(), { auth: "admin" }), method(object({
|
|
@@ -30828,7 +31257,8 @@ var ConnectionEndpointSchema = object({
|
|
|
30828
31257
|
"lan-ipv6",
|
|
30829
31258
|
"public",
|
|
30830
31259
|
"loopback",
|
|
30831
|
-
"app-link"
|
|
31260
|
+
"app-link",
|
|
31261
|
+
"custom"
|
|
30832
31262
|
]),
|
|
30833
31263
|
/**
|
|
30834
31264
|
* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
|
|
@@ -30897,7 +31327,7 @@ var GetConnectionEndpointsResultSchema = object({
|
|
|
30897
31327
|
localPort: AdvertisedLocalPortSchema
|
|
30898
31328
|
});
|
|
30899
31329
|
/**
|
|
30900
|
-
* The address flagged for notification
|
|
31330
|
+
* The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
|
|
30901
31331
|
* since D709 is the CamStack app link; `resolved` reports the effective value,
|
|
30902
31332
|
* so the UI can show it either way.
|
|
30903
31333
|
*/
|
|
@@ -30931,13 +31361,12 @@ var ViewerEndpointsSchema = object({
|
|
|
30931
31361
|
resolved: array(string()).readonly()
|
|
30932
31362
|
});
|
|
30933
31363
|
/**
|
|
30934
|
-
*
|
|
30935
|
-
*
|
|
31364
|
+
* DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
|
|
31365
|
+
* for addons built against it): `cluster` is the `internal` role, `browser`
|
|
31366
|
+
* the `publicEndpoint` role; `override` is the flagged address.
|
|
30936
31367
|
*/
|
|
30937
31368
|
var HubAddressSnapshotSchema = object({
|
|
30938
|
-
/** The operator's override, or null for automatic. */
|
|
30939
31369
|
override: string().nullable(),
|
|
30940
|
-
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
30941
31370
|
resolved: string().nullable(),
|
|
30942
31371
|
source: _enum([
|
|
30943
31372
|
"override",
|
|
@@ -30946,11 +31375,57 @@ var HubAddressSnapshotSchema = object({
|
|
|
30946
31375
|
])
|
|
30947
31376
|
});
|
|
30948
31377
|
var HubAddressesSchema = object({
|
|
30949
|
-
/** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
|
|
30950
31378
|
cluster: HubAddressSnapshotSchema,
|
|
30951
|
-
/** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
|
|
30952
31379
|
browser: HubAddressSnapshotSchema
|
|
30953
31380
|
});
|
|
31381
|
+
/**
|
|
31382
|
+
* What an address is used for (`hub-address.ts`, D734). `appConnections` is
|
|
31383
|
+
* many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
|
|
31384
|
+
* by at most one address.
|
|
31385
|
+
*/
|
|
31386
|
+
var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
|
|
31387
|
+
var RoleSourceSchema = _enum([
|
|
31388
|
+
"flagged",
|
|
31389
|
+
"auto",
|
|
31390
|
+
"none"
|
|
31391
|
+
]);
|
|
31392
|
+
/** One single-valued role: the flagged address, the one in use, and why. */
|
|
31393
|
+
var HubAddressRoleResolutionSchema = object({
|
|
31394
|
+
/** The address carrying the flag, or null = automatic. */
|
|
31395
|
+
flagged: string().nullable(),
|
|
31396
|
+
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
31397
|
+
resolved: string().nullable(),
|
|
31398
|
+
source: RoleSourceSchema
|
|
31399
|
+
});
|
|
31400
|
+
var HubAppConnectionsResolutionSchema = object({
|
|
31401
|
+
/** The addresses flagged `appConnections`, or empty = automatic. */
|
|
31402
|
+
flagged: array(string()).readonly(),
|
|
31403
|
+
/** What the apps race right now. */
|
|
31404
|
+
resolved: array(string()).readonly(),
|
|
31405
|
+
source: RoleSourceSchema
|
|
31406
|
+
});
|
|
31407
|
+
var HubAddressBookSchema = object({
|
|
31408
|
+
rows: array(ConnectionEndpointSchema.extend({
|
|
31409
|
+
/** In the hub's detected palette right now. */
|
|
31410
|
+
detected: boolean(),
|
|
31411
|
+
/** Entered by the operator (removable). */
|
|
31412
|
+
custom: boolean(),
|
|
31413
|
+
/** The roles explicitly flagged on this address. */
|
|
31414
|
+
flags: array(HubAddressRoleSchema).readonly(),
|
|
31415
|
+
/** The roles this address serves right now — flagged or automatic. */
|
|
31416
|
+
inUse: array(HubAddressRoleSchema).readonly(),
|
|
31417
|
+
/** The roles this address may be flagged with. */
|
|
31418
|
+
eligible: array(HubAddressRoleSchema).readonly()
|
|
31419
|
+
})).readonly(),
|
|
31420
|
+
roles: object({
|
|
31421
|
+
appConnections: HubAppConnectionsResolutionSchema,
|
|
31422
|
+
notificationTaps: HubAddressRoleResolutionSchema,
|
|
31423
|
+
internal: HubAddressRoleResolutionSchema,
|
|
31424
|
+
publicEndpoint: HubAddressRoleResolutionSchema
|
|
31425
|
+
}),
|
|
31426
|
+
/** The `hub=` an app link carries (D709), or null. */
|
|
31427
|
+
appLinkHub: string().nullable()
|
|
31428
|
+
});
|
|
30954
31429
|
var AllowedAddressesSchema = object({
|
|
30955
31430
|
/**
|
|
30956
31431
|
* Allowlist of interface addresses operators have explicitly opted
|
|
@@ -30994,16 +31469,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
|
|
|
30994
31469
|
* tunnel always emits `https://` regardless. */
|
|
30995
31470
|
scheme: _enum(["http", "https"]).optional(),
|
|
30996
31471
|
/** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
|
|
30997
|
-
* an address notification
|
|
31472
|
+
* an address notification taps can be flagged with, not a hub
|
|
30998
31473
|
* route. Default `false`: racers and rankers never see it. */
|
|
30999
31474
|
includeAppLink: boolean().optional()
|
|
31000
|
-
}), 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(
|
|
31001
|
-
|
|
31002
|
-
|
|
31003
|
-
}),
|
|
31475
|
+
}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(object({ scheme: _enum(["http", "https"]).optional() }).optional(), HubAddressBookSchema), method(object({
|
|
31476
|
+
baseUrl: string(),
|
|
31477
|
+
label: string().max(80)
|
|
31478
|
+
}), HubAddressBookSchema, {
|
|
31004
31479
|
kind: "mutation",
|
|
31005
31480
|
auth: "admin"
|
|
31006
|
-
}), method(
|
|
31481
|
+
}), method(object({ baseUrl: string() }), HubAddressBookSchema, {
|
|
31482
|
+
kind: "mutation",
|
|
31483
|
+
auth: "admin"
|
|
31484
|
+
}), method(object({
|
|
31485
|
+
role: HubAddressRoleSchema,
|
|
31486
|
+
baseUrl: string().nullable(),
|
|
31487
|
+
enabled: boolean(),
|
|
31488
|
+
acceptInsecureHttp: boolean().optional()
|
|
31489
|
+
}), HubAddressBookSchema, {
|
|
31490
|
+
kind: "mutation",
|
|
31491
|
+
auth: "admin"
|
|
31492
|
+
}), 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, {
|
|
31007
31493
|
kind: "mutation",
|
|
31008
31494
|
auth: "admin"
|
|
31009
31495
|
}), method(object({
|
|
@@ -36027,6 +36513,32 @@ var TotpStatusSchema = object({
|
|
|
36027
36513
|
/** Null when no row exists OR the row is still pending confirmation. */
|
|
36028
36514
|
confirmedAt: number().nullable()
|
|
36029
36515
|
});
|
|
36516
|
+
/**
|
|
36517
|
+
* user-management — singleton capability for user accounts, API keys,
|
|
36518
|
+
* and scoped tokens.
|
|
36519
|
+
*
|
|
36520
|
+
* v2 model: every method gated by `auth: 'admin'`. Admin-only delegation
|
|
36521
|
+
* — the subset check on `setUserScopes` / `createScopedToken` is moot
|
|
36522
|
+
* because non-admins never reach these. If/when we open non-admin
|
|
36523
|
+
* delegation, structural caller-scope subset check goes inside the
|
|
36524
|
+
* provider.
|
|
36525
|
+
*/
|
|
36526
|
+
var ExternalIdentitySchema = object({
|
|
36527
|
+
/** Login-method id of the provider instance, e.g. `auth-oidc/authentik`. */
|
|
36528
|
+
provider: string(),
|
|
36529
|
+
/** The IdP's stable subject (`sub`) for this account. */
|
|
36530
|
+
subject: string(),
|
|
36531
|
+
/** The verified `iss` of the IdP the identity was linked under — `sub` is unique only per issuer. */
|
|
36532
|
+
issuer: string(),
|
|
36533
|
+
userId: string(),
|
|
36534
|
+
/** What the IdP called the account at link time (username / email) — display only. */
|
|
36535
|
+
label: string().optional(),
|
|
36536
|
+
linkedAt: number()
|
|
36537
|
+
});
|
|
36538
|
+
var ExternalIdentityKeySchema = object({
|
|
36539
|
+
provider: string().min(1),
|
|
36540
|
+
subject: string().min(1)
|
|
36541
|
+
});
|
|
36030
36542
|
method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserInputSchema, UserSummarySchema, {
|
|
36031
36543
|
kind: "mutation",
|
|
36032
36544
|
auth: "admin",
|
|
@@ -36140,7 +36652,22 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserI
|
|
|
36140
36652
|
userId: string(),
|
|
36141
36653
|
username: string(),
|
|
36142
36654
|
scopes: array(TokenScopeSchema)
|
|
36143
|
-
}).nullable(), { access: "view" }), method(
|
|
36655
|
+
}).nullable(), { access: "view" }), method(object({ userId: string() }), array(ExternalIdentitySchema), { auth: "admin" }), method(ExternalIdentityKeySchema, object({
|
|
36656
|
+
userId: string(),
|
|
36657
|
+
issuer: string()
|
|
36658
|
+
}).nullable(), { auth: "admin" }), method(ExternalIdentityKeySchema.extend({
|
|
36659
|
+
userId: string(),
|
|
36660
|
+
issuer: string().min(1),
|
|
36661
|
+
label: string().optional()
|
|
36662
|
+
}), object({ success: literal(true) }), {
|
|
36663
|
+
kind: "mutation",
|
|
36664
|
+
auth: "admin",
|
|
36665
|
+
access: "create"
|
|
36666
|
+
}), method(ExternalIdentityKeySchema.extend({ userId: string() }), object({ success: boolean() }), {
|
|
36667
|
+
kind: "mutation",
|
|
36668
|
+
auth: "admin",
|
|
36669
|
+
access: "delete"
|
|
36670
|
+
}), method(_void(), array(OauthSessionSummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: boolean() }), {
|
|
36144
36671
|
kind: "mutation",
|
|
36145
36672
|
auth: "admin",
|
|
36146
36673
|
access: "delete"
|
|
@@ -36532,6 +37059,16 @@ DeviceType.Camera, method(object({
|
|
|
36532
37059
|
package: array(ZoneRuleSchema).readonly()
|
|
36533
37060
|
});
|
|
36534
37061
|
SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
|
|
37062
|
+
Object.freeze({
|
|
37063
|
+
person: .5,
|
|
37064
|
+
vehicle: .5,
|
|
37065
|
+
animal: .5
|
|
37066
|
+
});
|
|
37067
|
+
Object.freeze({
|
|
37068
|
+
person: .65,
|
|
37069
|
+
vehicle: .65,
|
|
37070
|
+
animal: .65
|
|
37071
|
+
});
|
|
36535
37072
|
/**
|
|
36536
37073
|
* Accessory device helpers — shared across drivers.
|
|
36537
37074
|
*
|
|
@@ -36706,6 +37243,12 @@ Object.freeze({
|
|
|
36706
37243
|
addonId: null,
|
|
36707
37244
|
access: "view"
|
|
36708
37245
|
},
|
|
37246
|
+
"addons.listInstallations": {
|
|
37247
|
+
capName: "addons",
|
|
37248
|
+
capScope: "system",
|
|
37249
|
+
addonId: null,
|
|
37250
|
+
access: "view"
|
|
37251
|
+
},
|
|
36709
37252
|
"addons.listJobs": {
|
|
36710
37253
|
capName: "addons",
|
|
36711
37254
|
capScope: "system",
|
|
@@ -37888,90 +38431,18 @@ Object.freeze({
|
|
|
37888
38431
|
addonId: null,
|
|
37889
38432
|
access: "create"
|
|
37890
38433
|
},
|
|
37891
|
-
"decoder.createSession": {
|
|
37892
|
-
capName: "decoder",
|
|
37893
|
-
capScope: "system",
|
|
37894
|
-
addonId: null,
|
|
37895
|
-
access: "view"
|
|
37896
|
-
},
|
|
37897
|
-
"decoder.destroySession": {
|
|
37898
|
-
capName: "decoder",
|
|
37899
|
-
capScope: "system",
|
|
37900
|
-
addonId: null,
|
|
37901
|
-
access: "delete"
|
|
37902
|
-
},
|
|
37903
|
-
"decoder.getFrame": {
|
|
37904
|
-
capName: "decoder",
|
|
37905
|
-
capScope: "system",
|
|
37906
|
-
addonId: null,
|
|
37907
|
-
access: "view"
|
|
37908
|
-
},
|
|
37909
38434
|
"decoder.getInfo": {
|
|
37910
38435
|
capName: "decoder",
|
|
37911
38436
|
capScope: "system",
|
|
37912
38437
|
addonId: null,
|
|
37913
38438
|
access: "view"
|
|
37914
38439
|
},
|
|
37915
|
-
"decoder.getShmStats": {
|
|
37916
|
-
capName: "decoder",
|
|
37917
|
-
capScope: "system",
|
|
37918
|
-
addonId: null,
|
|
37919
|
-
access: "view"
|
|
37920
|
-
},
|
|
37921
|
-
"decoder.getStats": {
|
|
37922
|
-
capName: "decoder",
|
|
37923
|
-
capScope: "system",
|
|
37924
|
-
addonId: null,
|
|
37925
|
-
access: "view"
|
|
37926
|
-
},
|
|
37927
|
-
"decoder.listActiveSessions": {
|
|
37928
|
-
capName: "decoder",
|
|
37929
|
-
capScope: "system",
|
|
37930
|
-
addonId: null,
|
|
37931
|
-
access: "view"
|
|
37932
|
-
},
|
|
37933
|
-
"decoder.openStream": {
|
|
37934
|
-
capName: "decoder",
|
|
37935
|
-
capScope: "system",
|
|
37936
|
-
addonId: null,
|
|
37937
|
-
access: "view"
|
|
37938
|
-
},
|
|
37939
|
-
"decoder.pullFrames": {
|
|
37940
|
-
capName: "decoder",
|
|
37941
|
-
capScope: "system",
|
|
37942
|
-
addonId: null,
|
|
37943
|
-
access: "view"
|
|
37944
|
-
},
|
|
37945
|
-
"decoder.pullHandles": {
|
|
37946
|
-
capName: "decoder",
|
|
37947
|
-
capScope: "system",
|
|
37948
|
-
addonId: null,
|
|
37949
|
-
access: "view"
|
|
37950
|
-
},
|
|
37951
|
-
"decoder.pushPacket": {
|
|
37952
|
-
capName: "decoder",
|
|
37953
|
-
capScope: "system",
|
|
37954
|
-
addonId: null,
|
|
37955
|
-
access: "view"
|
|
37956
|
-
},
|
|
37957
38440
|
"decoder.reprobeHwaccel": {
|
|
37958
38441
|
capName: "decoder",
|
|
37959
38442
|
capScope: "system",
|
|
37960
38443
|
addonId: null,
|
|
37961
38444
|
access: "create"
|
|
37962
38445
|
},
|
|
37963
|
-
"decoder.supportsCodec": {
|
|
37964
|
-
capName: "decoder",
|
|
37965
|
-
capScope: "system",
|
|
37966
|
-
addonId: null,
|
|
37967
|
-
access: "view"
|
|
37968
|
-
},
|
|
37969
|
-
"decoder.updateConfig": {
|
|
37970
|
-
capName: "decoder",
|
|
37971
|
-
capScope: "system",
|
|
37972
|
-
addonId: null,
|
|
37973
|
-
access: "view"
|
|
37974
|
-
},
|
|
37975
38446
|
"detectionPipeline.applyDeviceSettingsPatch": {
|
|
37976
38447
|
capName: "detection-pipeline",
|
|
37977
38448
|
capScope: "device",
|
|
@@ -39460,12 +39931,24 @@ Object.freeze({
|
|
|
39460
39931
|
addonId: null,
|
|
39461
39932
|
access: "view"
|
|
39462
39933
|
},
|
|
39934
|
+
"localNetwork.addCustomAddress": {
|
|
39935
|
+
capName: "local-network",
|
|
39936
|
+
capScope: "system",
|
|
39937
|
+
addonId: null,
|
|
39938
|
+
access: "create"
|
|
39939
|
+
},
|
|
39463
39940
|
"localNetwork.downloadCa": {
|
|
39464
39941
|
capName: "local-network",
|
|
39465
39942
|
capScope: "system",
|
|
39466
39943
|
addonId: null,
|
|
39467
39944
|
access: "view"
|
|
39468
39945
|
},
|
|
39946
|
+
"localNetwork.getAddresses": {
|
|
39947
|
+
capName: "local-network",
|
|
39948
|
+
capScope: "system",
|
|
39949
|
+
addonId: null,
|
|
39950
|
+
access: "view"
|
|
39951
|
+
},
|
|
39469
39952
|
"localNetwork.getAllowedAddresses": {
|
|
39470
39953
|
capName: "local-network",
|
|
39471
39954
|
capScope: "system",
|
|
@@ -39520,6 +40003,12 @@ Object.freeze({
|
|
|
39520
40003
|
addonId: null,
|
|
39521
40004
|
access: "create"
|
|
39522
40005
|
},
|
|
40006
|
+
"localNetwork.removeCustomAddress": {
|
|
40007
|
+
capName: "local-network",
|
|
40008
|
+
capScope: "system",
|
|
40009
|
+
addonId: null,
|
|
40010
|
+
access: "delete"
|
|
40011
|
+
},
|
|
39523
40012
|
"localNetwork.resetAllowlistToBestMatch": {
|
|
39524
40013
|
capName: "local-network",
|
|
39525
40014
|
capScope: "system",
|
|
@@ -39532,13 +40021,13 @@ Object.freeze({
|
|
|
39532
40021
|
addonId: null,
|
|
39533
40022
|
access: "create"
|
|
39534
40023
|
},
|
|
39535
|
-
"localNetwork.
|
|
40024
|
+
"localNetwork.setAddressRole": {
|
|
39536
40025
|
capName: "local-network",
|
|
39537
40026
|
capScope: "system",
|
|
39538
40027
|
addonId: null,
|
|
39539
40028
|
access: "create"
|
|
39540
40029
|
},
|
|
39541
|
-
"localNetwork.
|
|
40030
|
+
"localNetwork.setAllowedAddresses": {
|
|
39542
40031
|
capName: "local-network",
|
|
39543
40032
|
capScope: "system",
|
|
39544
40033
|
addonId: null,
|
|
@@ -40984,6 +41473,12 @@ Object.freeze({
|
|
|
40984
41473
|
addonId: null,
|
|
40985
41474
|
access: "create"
|
|
40986
41475
|
},
|
|
41476
|
+
"pipelineAnalytics.setRetrainFrameComplete": {
|
|
41477
|
+
capName: "pipeline-analytics",
|
|
41478
|
+
capScope: "device",
|
|
41479
|
+
addonId: null,
|
|
41480
|
+
access: "create"
|
|
41481
|
+
},
|
|
40987
41482
|
"pipelineAnalytics.setTrackFlags": {
|
|
40988
41483
|
capName: "pipeline-analytics",
|
|
40989
41484
|
capScope: "device",
|
|
@@ -41020,6 +41515,12 @@ Object.freeze({
|
|
|
41020
41515
|
addonId: null,
|
|
41021
41516
|
access: "delete"
|
|
41022
41517
|
},
|
|
41518
|
+
"pipelineAnalytics.writeRetrainArchive": {
|
|
41519
|
+
capName: "pipeline-analytics",
|
|
41520
|
+
capScope: "device",
|
|
41521
|
+
addonId: null,
|
|
41522
|
+
access: "create"
|
|
41523
|
+
},
|
|
41023
41524
|
"pipelineExecutor.cacheFrameInPool": {
|
|
41024
41525
|
capName: "pipeline-executor",
|
|
41025
41526
|
capScope: "system",
|
|
@@ -41032,13 +41533,13 @@ Object.freeze({
|
|
|
41032
41533
|
addonId: null,
|
|
41033
41534
|
access: "delete"
|
|
41034
41535
|
},
|
|
41035
|
-
"pipelineExecutor.
|
|
41536
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": {
|
|
41036
41537
|
capName: "pipeline-executor",
|
|
41037
41538
|
capScope: "system",
|
|
41038
41539
|
addonId: null,
|
|
41039
41540
|
access: "delete"
|
|
41040
41541
|
},
|
|
41041
|
-
"pipelineExecutor.
|
|
41542
|
+
"pipelineExecutor.deleteModel": {
|
|
41042
41543
|
capName: "pipeline-executor",
|
|
41043
41544
|
capScope: "system",
|
|
41044
41545
|
addonId: null,
|
|
@@ -41182,12 +41683,6 @@ Object.freeze({
|
|
|
41182
41683
|
addonId: null,
|
|
41183
41684
|
access: "view"
|
|
41184
41685
|
},
|
|
41185
|
-
"pipelineExecutor.listTemplates": {
|
|
41186
|
-
capName: "pipeline-executor",
|
|
41187
|
-
capScope: "system",
|
|
41188
|
-
addonId: null,
|
|
41189
|
-
access: "view"
|
|
41190
|
-
},
|
|
41191
41686
|
"pipelineExecutor.rearmInferenceDevice": {
|
|
41192
41687
|
capName: "pipeline-executor",
|
|
41193
41688
|
capScope: "system",
|
|
@@ -41212,12 +41707,6 @@ Object.freeze({
|
|
|
41212
41707
|
addonId: null,
|
|
41213
41708
|
access: "create"
|
|
41214
41709
|
},
|
|
41215
|
-
"pipelineExecutor.saveTemplate": {
|
|
41216
|
-
capName: "pipeline-executor",
|
|
41217
|
-
capScope: "system",
|
|
41218
|
-
addonId: null,
|
|
41219
|
-
access: "create"
|
|
41220
|
-
},
|
|
41221
41710
|
"pipelineExecutor.setVideoPipelineSteps": {
|
|
41222
41711
|
capName: "pipeline-executor",
|
|
41223
41712
|
capScope: "system",
|
|
@@ -41236,41 +41725,35 @@ Object.freeze({
|
|
|
41236
41725
|
addonId: null,
|
|
41237
41726
|
access: "create"
|
|
41238
41727
|
},
|
|
41239
|
-
"pipelineExecutor.updateTemplate": {
|
|
41240
|
-
capName: "pipeline-executor",
|
|
41241
|
-
capScope: "system",
|
|
41242
|
-
addonId: null,
|
|
41243
|
-
access: "create"
|
|
41244
|
-
},
|
|
41245
41728
|
"pipelineExecutor.validatePipeline": {
|
|
41246
41729
|
capName: "pipeline-executor",
|
|
41247
41730
|
capScope: "system",
|
|
41248
41731
|
addonId: null,
|
|
41249
41732
|
access: "view"
|
|
41250
41733
|
},
|
|
41251
|
-
"pipelineOrchestrator.
|
|
41734
|
+
"pipelineOrchestrator.applyAutoTune": {
|
|
41252
41735
|
capName: "pipeline-orchestrator",
|
|
41253
41736
|
capScope: "system",
|
|
41254
41737
|
addonId: null,
|
|
41255
41738
|
access: "create"
|
|
41256
41739
|
},
|
|
41257
|
-
"pipelineOrchestrator.
|
|
41740
|
+
"pipelineOrchestrator.applyDeviceSettingsPatch": {
|
|
41258
41741
|
capName: "pipeline-orchestrator",
|
|
41259
41742
|
capScope: "system",
|
|
41260
41743
|
addonId: null,
|
|
41261
41744
|
access: "create"
|
|
41262
41745
|
},
|
|
41263
|
-
"pipelineOrchestrator.
|
|
41746
|
+
"pipelineOrchestrator.assignAudio": {
|
|
41264
41747
|
capName: "pipeline-orchestrator",
|
|
41265
41748
|
capScope: "system",
|
|
41266
41749
|
addonId: null,
|
|
41267
41750
|
access: "create"
|
|
41268
41751
|
},
|
|
41269
|
-
"pipelineOrchestrator.
|
|
41752
|
+
"pipelineOrchestrator.assignPipeline": {
|
|
41270
41753
|
capName: "pipeline-orchestrator",
|
|
41271
41754
|
capScope: "system",
|
|
41272
41755
|
addonId: null,
|
|
41273
|
-
access: "
|
|
41756
|
+
access: "create"
|
|
41274
41757
|
},
|
|
41275
41758
|
"pipelineOrchestrator.getAgentLoad": {
|
|
41276
41759
|
capName: "pipeline-orchestrator",
|
|
@@ -41362,6 +41845,12 @@ Object.freeze({
|
|
|
41362
41845
|
addonId: null,
|
|
41363
41846
|
access: "view"
|
|
41364
41847
|
},
|
|
41848
|
+
"pipelineOrchestrator.getEffectiveShares": {
|
|
41849
|
+
capName: "pipeline-orchestrator",
|
|
41850
|
+
capScope: "system",
|
|
41851
|
+
addonId: null,
|
|
41852
|
+
access: "view"
|
|
41853
|
+
},
|
|
41365
41854
|
"pipelineOrchestrator.getGlobalMetrics": {
|
|
41366
41855
|
capName: "pipeline-orchestrator",
|
|
41367
41856
|
capScope: "system",
|
|
@@ -41398,19 +41887,19 @@ Object.freeze({
|
|
|
41398
41887
|
addonId: null,
|
|
41399
41888
|
access: "view"
|
|
41400
41889
|
},
|
|
41401
|
-
"pipelineOrchestrator.
|
|
41890
|
+
"pipelineOrchestrator.getPlacementStats": {
|
|
41402
41891
|
capName: "pipeline-orchestrator",
|
|
41403
41892
|
capScope: "system",
|
|
41404
41893
|
addonId: null,
|
|
41405
41894
|
access: "view"
|
|
41406
41895
|
},
|
|
41407
|
-
"pipelineOrchestrator.
|
|
41896
|
+
"pipelineOrchestrator.getReconcileFromDiskStatus": {
|
|
41408
41897
|
capName: "pipeline-orchestrator",
|
|
41409
41898
|
capScope: "system",
|
|
41410
41899
|
addonId: null,
|
|
41411
41900
|
access: "view"
|
|
41412
41901
|
},
|
|
41413
|
-
"pipelineOrchestrator.
|
|
41902
|
+
"pipelineOrchestrator.listAgentSettings": {
|
|
41414
41903
|
capName: "pipeline-orchestrator",
|
|
41415
41904
|
capScope: "system",
|
|
41416
41905
|
addonId: null,
|
|
@@ -41422,6 +41911,12 @@ Object.freeze({
|
|
|
41422
41911
|
addonId: null,
|
|
41423
41912
|
access: "create"
|
|
41424
41913
|
},
|
|
41914
|
+
"pipelineOrchestrator.planAutoTune": {
|
|
41915
|
+
capName: "pipeline-orchestrator",
|
|
41916
|
+
capScope: "system",
|
|
41917
|
+
addonId: null,
|
|
41918
|
+
access: "view"
|
|
41919
|
+
},
|
|
41425
41920
|
"pipelineOrchestrator.rebalance": {
|
|
41426
41921
|
capName: "pipeline-orchestrator",
|
|
41427
41922
|
capScope: "system",
|
|
@@ -41464,12 +41959,6 @@ Object.freeze({
|
|
|
41464
41959
|
addonId: null,
|
|
41465
41960
|
access: "create"
|
|
41466
41961
|
},
|
|
41467
|
-
"pipelineOrchestrator.saveTemplate": {
|
|
41468
|
-
capName: "pipeline-orchestrator",
|
|
41469
|
-
capScope: "system",
|
|
41470
|
-
addonId: null,
|
|
41471
|
-
access: "create"
|
|
41472
|
-
},
|
|
41473
41962
|
"pipelineOrchestrator.setAgentCapabilities": {
|
|
41474
41963
|
capName: "pipeline-orchestrator",
|
|
41475
41964
|
capScope: "system",
|
|
@@ -41482,12 +41971,6 @@ Object.freeze({
|
|
|
41482
41971
|
addonId: null,
|
|
41483
41972
|
access: "create"
|
|
41484
41973
|
},
|
|
41485
|
-
"pipelineOrchestrator.setAgentDetectWeight": {
|
|
41486
|
-
capName: "pipeline-orchestrator",
|
|
41487
|
-
capScope: "system",
|
|
41488
|
-
addonId: null,
|
|
41489
|
-
access: "create"
|
|
41490
|
-
},
|
|
41491
41974
|
"pipelineOrchestrator.setAgentInferenceDevices": {
|
|
41492
41975
|
capName: "pipeline-orchestrator",
|
|
41493
41976
|
capScope: "system",
|
|
@@ -41524,6 +42007,12 @@ Object.freeze({
|
|
|
41524
42007
|
addonId: null,
|
|
41525
42008
|
access: "create"
|
|
41526
42009
|
},
|
|
42010
|
+
"pipelineOrchestrator.setCameraStepSettings": {
|
|
42011
|
+
capName: "pipeline-orchestrator",
|
|
42012
|
+
capScope: "system",
|
|
42013
|
+
addonId: null,
|
|
42014
|
+
access: "create"
|
|
42015
|
+
},
|
|
41527
42016
|
"pipelineOrchestrator.setCameraStepToggle": {
|
|
41528
42017
|
capName: "pipeline-orchestrator",
|
|
41529
42018
|
capScope: "system",
|
|
@@ -41542,25 +42031,37 @@ Object.freeze({
|
|
|
41542
42031
|
addonId: null,
|
|
41543
42032
|
access: "create"
|
|
41544
42033
|
},
|
|
42034
|
+
"pipelineOrchestrator.setLoadBalancingShares": {
|
|
42035
|
+
capName: "pipeline-orchestrator",
|
|
42036
|
+
capScope: "system",
|
|
42037
|
+
addonId: null,
|
|
42038
|
+
access: "create"
|
|
42039
|
+
},
|
|
41545
42040
|
"pipelineOrchestrator.setPipelineDevicePin": {
|
|
41546
42041
|
capName: "pipeline-orchestrator",
|
|
41547
42042
|
capScope: "system",
|
|
41548
42043
|
addonId: null,
|
|
41549
42044
|
access: "create"
|
|
41550
42045
|
},
|
|
41551
|
-
"pipelineOrchestrator.
|
|
42046
|
+
"pipelineOrchestrator.setShareSource": {
|
|
41552
42047
|
capName: "pipeline-orchestrator",
|
|
41553
42048
|
capScope: "system",
|
|
41554
42049
|
addonId: null,
|
|
41555
42050
|
access: "create"
|
|
41556
42051
|
},
|
|
41557
|
-
"pipelineOrchestrator.
|
|
42052
|
+
"pipelineOrchestrator.suggestShares": {
|
|
42053
|
+
capName: "pipeline-orchestrator",
|
|
42054
|
+
capScope: "system",
|
|
42055
|
+
addonId: null,
|
|
42056
|
+
access: "view"
|
|
42057
|
+
},
|
|
42058
|
+
"pipelineOrchestrator.unassignAudio": {
|
|
41558
42059
|
capName: "pipeline-orchestrator",
|
|
41559
42060
|
capScope: "system",
|
|
41560
42061
|
addonId: null,
|
|
41561
42062
|
access: "create"
|
|
41562
42063
|
},
|
|
41563
|
-
"pipelineOrchestrator.
|
|
42064
|
+
"pipelineOrchestrator.unassignPipeline": {
|
|
41564
42065
|
capName: "pipeline-orchestrator",
|
|
41565
42066
|
capScope: "system",
|
|
41566
42067
|
addonId: null,
|
|
@@ -43000,12 +43501,6 @@ Object.freeze({
|
|
|
43000
43501
|
addonId: null,
|
|
43001
43502
|
access: "view"
|
|
43002
43503
|
},
|
|
43003
|
-
"streamBroker.pullFrameHandles": {
|
|
43004
|
-
capName: "stream-broker",
|
|
43005
|
-
capScope: "system",
|
|
43006
|
-
addonId: null,
|
|
43007
|
-
access: "view"
|
|
43008
|
-
},
|
|
43009
43504
|
"streamBroker.regenerateRtspToken": {
|
|
43010
43505
|
capName: "stream-broker",
|
|
43011
43506
|
capScope: "system",
|
|
@@ -43072,12 +43567,6 @@ Object.freeze({
|
|
|
43072
43567
|
addonId: null,
|
|
43073
43568
|
access: "create"
|
|
43074
43569
|
},
|
|
43075
|
-
"streamBroker.subscribeFrames": {
|
|
43076
|
-
capName: "stream-broker",
|
|
43077
|
-
capScope: "system",
|
|
43078
|
-
addonId: null,
|
|
43079
|
-
access: "create"
|
|
43080
|
-
},
|
|
43081
43570
|
"streamBroker.unassignProfile": {
|
|
43082
43571
|
capName: "stream-broker",
|
|
43083
43572
|
capScope: "system",
|
|
@@ -43090,12 +43579,6 @@ Object.freeze({
|
|
|
43090
43579
|
addonId: null,
|
|
43091
43580
|
access: "create"
|
|
43092
43581
|
},
|
|
43093
|
-
"streamBroker.unsubscribeFrames": {
|
|
43094
|
-
capName: "stream-broker",
|
|
43095
|
-
capScope: "system",
|
|
43096
|
-
addonId: null,
|
|
43097
|
-
access: "create"
|
|
43098
|
-
},
|
|
43099
43582
|
"streamCatalog.getCatalog": {
|
|
43100
43583
|
capName: "stream-catalog",
|
|
43101
43584
|
capScope: "device",
|
|
@@ -43390,18 +43873,36 @@ Object.freeze({
|
|
|
43390
43873
|
addonId: null,
|
|
43391
43874
|
access: "delete"
|
|
43392
43875
|
},
|
|
43876
|
+
"userManagement.findUserByExternalIdentity": {
|
|
43877
|
+
capName: "user-management",
|
|
43878
|
+
capScope: "system",
|
|
43879
|
+
addonId: null,
|
|
43880
|
+
access: "view"
|
|
43881
|
+
},
|
|
43393
43882
|
"userManagement.getTotpStatus": {
|
|
43394
43883
|
capName: "user-management",
|
|
43395
43884
|
capScope: "system",
|
|
43396
43885
|
addonId: null,
|
|
43397
43886
|
access: "view"
|
|
43398
43887
|
},
|
|
43888
|
+
"userManagement.linkExternalIdentity": {
|
|
43889
|
+
capName: "user-management",
|
|
43890
|
+
capScope: "system",
|
|
43891
|
+
addonId: null,
|
|
43892
|
+
access: "create"
|
|
43893
|
+
},
|
|
43399
43894
|
"userManagement.listApiKeys": {
|
|
43400
43895
|
capName: "user-management",
|
|
43401
43896
|
capScope: "system",
|
|
43402
43897
|
addonId: null,
|
|
43403
43898
|
access: "view"
|
|
43404
43899
|
},
|
|
43900
|
+
"userManagement.listExternalIdentities": {
|
|
43901
|
+
capName: "user-management",
|
|
43902
|
+
capScope: "system",
|
|
43903
|
+
addonId: null,
|
|
43904
|
+
access: "view"
|
|
43905
|
+
},
|
|
43405
43906
|
"userManagement.listOauthSessions": {
|
|
43406
43907
|
capName: "user-management",
|
|
43407
43908
|
capScope: "system",
|
|
@@ -43480,6 +43981,12 @@ Object.freeze({
|
|
|
43480
43981
|
addonId: null,
|
|
43481
43982
|
access: "create"
|
|
43482
43983
|
},
|
|
43984
|
+
"userManagement.unlinkExternalIdentity": {
|
|
43985
|
+
capName: "user-management",
|
|
43986
|
+
capScope: "system",
|
|
43987
|
+
addonId: null,
|
|
43988
|
+
access: "delete"
|
|
43989
|
+
},
|
|
43483
43990
|
"userManagement.updateUser": {
|
|
43484
43991
|
capName: "user-management",
|
|
43485
43992
|
capScope: "system",
|
|
@@ -43792,6 +44299,12 @@ Object.freeze({
|
|
|
43792
44299
|
addonId: null,
|
|
43793
44300
|
access: "create"
|
|
43794
44301
|
},
|
|
44302
|
+
"webrtcSession.applyDownlinkProbe": {
|
|
44303
|
+
capName: "webrtc-session",
|
|
44304
|
+
capScope: "device",
|
|
44305
|
+
addonId: null,
|
|
44306
|
+
access: "create"
|
|
44307
|
+
},
|
|
43795
44308
|
"webrtcSession.closeSession": {
|
|
43796
44309
|
capName: "webrtc-session",
|
|
43797
44310
|
capScope: "device",
|
|
@@ -45603,11 +46116,6 @@ Object.freeze({
|
|
|
45603
46116
|
form: "single",
|
|
45604
46117
|
optional: false
|
|
45605
46118
|
}],
|
|
45606
|
-
"decoder.createSession": [{
|
|
45607
|
-
name: "deviceId",
|
|
45608
|
-
form: "single",
|
|
45609
|
-
optional: true
|
|
45610
|
-
}],
|
|
45611
46119
|
"detectionPipeline.applyDeviceSettingsPatch": [{
|
|
45612
46120
|
name: "deviceId",
|
|
45613
46121
|
form: "single",
|
|
@@ -46818,6 +47326,11 @@ Object.freeze({
|
|
|
46818
47326
|
form: "single",
|
|
46819
47327
|
optional: false
|
|
46820
47328
|
}],
|
|
47329
|
+
"pipelineAnalytics.setRetrainFrameComplete": [{
|
|
47330
|
+
name: "deviceId",
|
|
47331
|
+
form: "single",
|
|
47332
|
+
optional: false
|
|
47333
|
+
}],
|
|
46821
47334
|
"pipelineAnalytics.setTrackFlags": [{
|
|
46822
47335
|
name: "deviceId",
|
|
46823
47336
|
form: "single",
|
|
@@ -46838,6 +47351,11 @@ Object.freeze({
|
|
|
46838
47351
|
form: "single",
|
|
46839
47352
|
optional: false
|
|
46840
47353
|
}],
|
|
47354
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": [{
|
|
47355
|
+
name: "deviceIds",
|
|
47356
|
+
form: "array",
|
|
47357
|
+
optional: true
|
|
47358
|
+
}],
|
|
46841
47359
|
"pipelineExecutor.runPipeline": [{
|
|
46842
47360
|
name: "deviceId",
|
|
46843
47361
|
form: "single",
|
|
@@ -46943,6 +47461,11 @@ Object.freeze({
|
|
|
46943
47461
|
form: "single",
|
|
46944
47462
|
optional: false
|
|
46945
47463
|
}],
|
|
47464
|
+
"pipelineOrchestrator.setCameraStepSettings": [{
|
|
47465
|
+
name: "deviceId",
|
|
47466
|
+
form: "single",
|
|
47467
|
+
optional: false
|
|
47468
|
+
}],
|
|
46946
47469
|
"pipelineOrchestrator.setCameraStepToggle": [{
|
|
46947
47470
|
name: "deviceId",
|
|
46948
47471
|
form: "single",
|
|
@@ -47714,6 +48237,11 @@ Object.freeze({
|
|
|
47714
48237
|
form: "single",
|
|
47715
48238
|
optional: false
|
|
47716
48239
|
}],
|
|
48240
|
+
"webrtcSession.applyDownlinkProbe": [{
|
|
48241
|
+
name: "deviceId",
|
|
48242
|
+
form: "single",
|
|
48243
|
+
optional: false
|
|
48244
|
+
}],
|
|
47717
48245
|
"webrtcSession.closeSession": [{
|
|
47718
48246
|
name: "deviceId",
|
|
47719
48247
|
form: "single",
|
|
@@ -48858,10 +49386,11 @@ var MB = 1024 * 1024;
|
|
|
48858
49386
|
/**
|
|
48859
49387
|
* Google Home export — customActions catalog.
|
|
48860
49388
|
*
|
|
48861
|
-
* One entry. The settings form's `
|
|
48862
|
-
* generic `api.addons.custom.mutate({ addonId, action, input })` channel
|
|
48863
|
-
*
|
|
48864
|
-
* the catalog travels inside this
|
|
49389
|
+
* One entry. The settings form's `addon-action-button` dispatches through the
|
|
49390
|
+
* generic `api.addons.custom.mutate({ addonId, action, input })` channel and
|
|
49391
|
+
* shows the result under the button, so a button here costs no capability, no
|
|
49392
|
+
* codegen and no framework publish train — the catalog travels inside this
|
|
49393
|
+
* addon's own bundle. Admin-only: it writes this addon's settings.
|
|
48865
49394
|
*/
|
|
48866
49395
|
var exportGoogleActions = defineCustomActions({
|
|
48867
49396
|
/**
|
|
@@ -48877,8 +49406,13 @@ var exportGoogleActions = defineCustomActions({
|
|
|
48877
49406
|
detectPublicHubUrl: customAction(object({}).optional(), object({
|
|
48878
49407
|
publicHubUrl: string(),
|
|
48879
49408
|
detectedPublicHubUrl: string(),
|
|
48880
|
-
filled: boolean()
|
|
48881
|
-
|
|
49409
|
+
filled: boolean(),
|
|
49410
|
+
/** One sentence saying what happened, for the button. */
|
|
49411
|
+
summary: string()
|
|
49412
|
+
}), {
|
|
49413
|
+
kind: "mutation",
|
|
49414
|
+
auth: "admin"
|
|
49415
|
+
}) });
|
|
48882
49416
|
//#endregion
|
|
48883
49417
|
//#region src/google-home/trait-catalog.ts
|
|
48884
49418
|
/**
|
|
@@ -49675,7 +50209,7 @@ function buildGoogleOauthIntegration() {
|
|
|
49675
50209
|
* cross-process through `ctx.api` — unlike the `addons` core router, which a
|
|
49676
50210
|
* forked addon calling `ctx.api.addons.*` would wait on forever.
|
|
49677
50211
|
*
|
|
49678
|
-
* **Not** the hub's own address from `local-network` (`
|
|
50212
|
+
* **Not** the hub's own address from `local-network` (`getAddresses().roles`). That
|
|
49679
50213
|
* answers a different question — which address an agent or a browser on the
|
|
49680
50214
|
* LAN reaches — and it is routinely a LAN address; the backend's
|
|
49681
50215
|
* `publicHubUrl()` fallback is localhost in dev. Google calls from its own
|
|
@@ -49907,6 +50441,14 @@ var refreshPublicHubUrl = async (deps) => {
|
|
|
49907
50441
|
else if (resolution.publicHubUrl.length === 0) deps.logger.warn("export-google: public hub URL still unset after detection — the Google console URLs cannot be rendered until one is available", { meta: { detectedCount: detected.length } });
|
|
49908
50442
|
return resolution;
|
|
49909
50443
|
};
|
|
50444
|
+
/** What "Detect external address" did, in one sentence for the button. */
|
|
50445
|
+
function describeDetectResult(result) {
|
|
50446
|
+
const { publicHubUrl, detectedPublicHubUrl, filled } = result;
|
|
50447
|
+
if (filled) return `Filled in ${publicHubUrl}.`;
|
|
50448
|
+
if (detectedPublicHubUrl.length === 0) return publicHubUrl.length > 0 ? `No public HTTPS address detected; your value ${publicHubUrl} was kept.` : "No public HTTPS address detected. Set up remote access first.";
|
|
50449
|
+
if (detectedPublicHubUrl === publicHubUrl) return `Detected ${publicHubUrl}, already in use.`;
|
|
50450
|
+
return `Detected ${detectedPublicHubUrl}; your value ${publicHubUrl} was kept.`;
|
|
50451
|
+
}
|
|
49910
50452
|
//#endregion
|
|
49911
50453
|
//#region src/types.ts
|
|
49912
50454
|
var DEFAULT_SETTINGS = {
|
|
@@ -50089,11 +50631,15 @@ var ExportGoogleAddon = class extends BaseAddon {
|
|
|
50089
50631
|
persist: (patch) => this.updateGlobalSettings(patch),
|
|
50090
50632
|
logger: this.ctx.logger
|
|
50091
50633
|
});
|
|
50092
|
-
|
|
50634
|
+
const result = {
|
|
50093
50635
|
publicHubUrl: resolution.publicHubUrl,
|
|
50094
50636
|
detectedPublicHubUrl: resolution.detectedPublicHubUrl,
|
|
50095
50637
|
filled: resolution.defaulted
|
|
50096
50638
|
};
|
|
50639
|
+
return {
|
|
50640
|
+
...result,
|
|
50641
|
+
summary: describeDetectResult(result)
|
|
50642
|
+
};
|
|
50097
50643
|
}
|
|
50098
50644
|
async onShutdown() {
|
|
50099
50645
|
this.gateway = null;
|
|
@@ -50172,7 +50718,7 @@ var ExportGoogleAddon = class extends BaseAddon {
|
|
|
50172
50718
|
globalSettingsSchema() {
|
|
50173
50719
|
return this.schema({ sections: [{
|
|
50174
50720
|
id: ADDON_ID,
|
|
50175
|
-
title: "
|
|
50721
|
+
title: "Connection",
|
|
50176
50722
|
description: "Publishes switches, dimmable lights, locks and covers to Google Home. The hub answers Google directly — no cloud function, and no Google credential is stored here.",
|
|
50177
50723
|
columns: 1,
|
|
50178
50724
|
fields: [
|
|
@@ -50202,13 +50748,15 @@ var ExportGoogleAddon = class extends BaseAddon {
|
|
|
50202
50748
|
...buildPublicHubUrlNotice(this.publicHubUrlState())
|
|
50203
50749
|
},
|
|
50204
50750
|
{
|
|
50205
|
-
type: "button",
|
|
50751
|
+
type: "addon-action-button",
|
|
50752
|
+
addonId: ADDON_ID,
|
|
50206
50753
|
key: "__detect-public-hub-url",
|
|
50207
50754
|
label: "External address",
|
|
50208
50755
|
description: "Re-scan the connected remote-access providers. Fills the field above when it is empty; a value you set is left exactly as it is.",
|
|
50209
50756
|
buttonLabel: "Detect external address",
|
|
50210
50757
|
action: "detectPublicHubUrl",
|
|
50211
|
-
variant: "default"
|
|
50758
|
+
variant: "default",
|
|
50759
|
+
successMessage: "{summary}"
|
|
50212
50760
|
}
|
|
50213
50761
|
]
|
|
50214
50762
|
}] });
|