@camstack/addon-export-hap 1.2.151 → 1.2.152
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/hap-export.addon.js +258 -609
- package/dist/hap-export.addon.mjs +258 -609
- package/package.json +1 -1
package/dist/hap-export.addon.js
CHANGED
|
@@ -48,7 +48,7 @@ node_fs_promises = __toESM(node_fs_promises, 1);
|
|
|
48
48
|
let node_events = require("node:events");
|
|
49
49
|
let node_dgram = require("node:dgram");
|
|
50
50
|
let node_os = require("node:os");
|
|
51
|
-
//#region ../types/dist/event-category-
|
|
51
|
+
//#region ../types/dist/event-category-B_0XEcLF.mjs
|
|
52
52
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
53
53
|
EventCategory["SystemBoot"] = "system.boot";
|
|
54
54
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -549,15 +549,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
549
549
|
EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
|
|
550
550
|
EventCategory["AgentBackupActivated"] = "agent.backup.activated";
|
|
551
551
|
EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
|
|
552
|
-
/**
|
|
553
|
-
* Per-agent hwaccel preference changed (user override set, cleared, or
|
|
554
|
-
* re-probed). Observability event — decoders pull the current pref at
|
|
555
|
-
* `createSession`, so running sessions keep their current backend until
|
|
556
|
-
* they rotate naturally (camera add/remove, stream restart). Future
|
|
557
|
-
* work can wire a listener in stream-broker that force-rotates live
|
|
558
|
-
* sessions; for now this event powers logs + admin-UI toast feedback.
|
|
559
|
-
*/
|
|
560
|
-
EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
|
|
561
552
|
EventCategory["MotionAnalysis"] = "detection.motion-analysis";
|
|
562
553
|
/** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
|
|
563
554
|
EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
|
|
@@ -5428,7 +5419,7 @@ var ZodIssueCode = {
|
|
|
5428
5419
|
var ZodFirstPartyTypeKind;
|
|
5429
5420
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5430
5421
|
//#endregion
|
|
5431
|
-
//#region ../types/dist/sleep-
|
|
5422
|
+
//#region ../types/dist/sleep-BNeXenvr.mjs
|
|
5432
5423
|
/**
|
|
5433
5424
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5434
5425
|
* window to float samples (D455).
|
|
@@ -6794,32 +6785,12 @@ object({
|
|
|
6794
6785
|
audioCodec: string().optional(),
|
|
6795
6786
|
metadata: record(string(), unknown()).readonly().optional()
|
|
6796
6787
|
});
|
|
6797
|
-
var EncodedPacketSchema = object({
|
|
6798
|
-
type: _enum(["video", "audio"]),
|
|
6799
|
-
data: _instanceof(Uint8Array),
|
|
6800
|
-
pts: number(),
|
|
6801
|
-
dts: number(),
|
|
6802
|
-
keyframe: boolean(),
|
|
6803
|
-
codec: string()
|
|
6804
|
-
});
|
|
6805
|
-
var DecodedFrameSchema = object({
|
|
6806
|
-
data: _instanceof(Uint8Array),
|
|
6807
|
-
width: number(),
|
|
6808
|
-
height: number(),
|
|
6809
|
-
format: _enum([
|
|
6810
|
-
"jpeg",
|
|
6811
|
-
"rgb",
|
|
6812
|
-
"bgr",
|
|
6813
|
-
"yuv420",
|
|
6814
|
-
"gray"
|
|
6815
|
-
]),
|
|
6816
|
-
timestamp: number()
|
|
6817
|
-
});
|
|
6818
6788
|
/**
|
|
6819
6789
|
* Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
|
|
6820
6790
|
* frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
|
|
6821
|
-
* interface in `interfaces/frame-handle.ts` field-for-field so a
|
|
6822
|
-
*
|
|
6791
|
+
* interface in `interfaces/frame-handle.ts` field-for-field so a cap method
|
|
6792
|
+
* (the runner's native-crop and pipeline-executor inputs) can carry handles
|
|
6793
|
+
* over tRPC / Moleculer.
|
|
6823
6794
|
*
|
|
6824
6795
|
* The `satisfies` assertion below pins this schema to the interface: if a
|
|
6825
6796
|
* field is added to / removed from `FrameHandle` without a matching schema
|
|
@@ -6845,50 +6816,6 @@ var FrameHandleSchema = object({
|
|
|
6845
6816
|
slotCount: number().int().positive()
|
|
6846
6817
|
});
|
|
6847
6818
|
/**
|
|
6848
|
-
* Pixel format a frame-handle subscriber can request from the broker
|
|
6849
|
-
* (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
|
|
6850
|
-
* `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
|
|
6851
|
-
* `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
|
|
6852
|
-
* payload, and no decoded-frame consumer requests it over the shm plane.
|
|
6853
|
-
*/
|
|
6854
|
-
var FrameHandleFormatSchema = _enum([
|
|
6855
|
-
"rgb",
|
|
6856
|
-
"bgr",
|
|
6857
|
-
"yuv420",
|
|
6858
|
-
"gray"
|
|
6859
|
-
]);
|
|
6860
|
-
/**
|
|
6861
|
-
* Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
|
|
6862
|
-
* broker for a `FrameHandle` stream of one `format`; the broker maintains one
|
|
6863
|
-
* shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
|
|
6864
|
-
* subscriber (motion) and an `rgb` subscriber (detection) each read the format
|
|
6865
|
-
* they asked for with no broker-side conversion.
|
|
6866
|
-
*/
|
|
6867
|
-
var SubscribeFramesInputSchema = object({
|
|
6868
|
-
brokerId: string(),
|
|
6869
|
-
format: FrameHandleFormatSchema,
|
|
6870
|
-
/**
|
|
6871
|
-
* Optional reader-side cadence hint in frames per second. The broker does
|
|
6872
|
-
* NOT throttle — latest-wins ring reads drop frames implicitly for a slow
|
|
6873
|
-
* consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
|
|
6874
|
-
* the consumer can pace its own `pullFrameHandles` polling.
|
|
6875
|
-
*/
|
|
6876
|
-
maxFps: number().positive().optional(),
|
|
6877
|
-
/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
|
|
6878
|
-
tag: string().optional()
|
|
6879
|
-
});
|
|
6880
|
-
/**
|
|
6881
|
-
* Result of `stream-broker.subscribeFrames`. The consumer then polls
|
|
6882
|
-
* `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
|
|
6883
|
-
* `FrameHandle` to a `FrameRingReader`.
|
|
6884
|
-
*/
|
|
6885
|
-
var SubscribeFramesResultSchema = object({
|
|
6886
|
-
/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
|
|
6887
|
-
subscriptionId: string(),
|
|
6888
|
-
/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
|
|
6889
|
-
maxFps: number().nonnegative()
|
|
6890
|
-
});
|
|
6891
|
-
/**
|
|
6892
6819
|
* Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
|
|
6893
6820
|
* `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
|
|
6894
6821
|
* sample bytes plus the track parameters a consumer needs to interpret them.
|
|
@@ -6896,8 +6823,8 @@ var SubscribeFramesResultSchema = object({
|
|
|
6896
6823
|
* Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
|
|
6897
6824
|
* Float32 PCM), so unlike video frames they ship their bytes INLINE over
|
|
6898
6825
|
* tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
|
|
6899
|
-
* (the wire-serialisable supertype of `Buffer`)
|
|
6900
|
-
*
|
|
6826
|
+
* (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
|
|
6827
|
+
* it.
|
|
6901
6828
|
*/
|
|
6902
6829
|
var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
|
|
6903
6830
|
var DecodedAudioChunkSchema = object({
|
|
@@ -6915,11 +6842,10 @@ var DecodedAudioChunkSchema = object({
|
|
|
6915
6842
|
format: AudioChunkFormatSchema.optional()
|
|
6916
6843
|
});
|
|
6917
6844
|
/**
|
|
6918
|
-
* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9).
|
|
6919
|
-
*
|
|
6920
|
-
*
|
|
6921
|
-
*
|
|
6922
|
-
* `pullAudioChunks`.
|
|
6845
|
+
* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
|
|
6846
|
+
* its bytes inline: a consumer asks the broker for the decoded audio-chunk
|
|
6847
|
+
* stream of one broker; the broker keeps a per-subscription bounded FIFO queue
|
|
6848
|
+
* the consumer drains via `pullAudioChunks`.
|
|
6923
6849
|
*/
|
|
6924
6850
|
var SubscribeAudioChunksInputSchema = object({
|
|
6925
6851
|
brokerId: string(),
|
|
@@ -6950,9 +6876,7 @@ var BrokerStatsSchema = object({
|
|
|
6950
6876
|
"stopped"
|
|
6951
6877
|
]),
|
|
6952
6878
|
inputFps: number(),
|
|
6953
|
-
decodeFps: number(),
|
|
6954
6879
|
encodedSubscribers: number(),
|
|
6955
|
-
decodedSubscribers: number(),
|
|
6956
6880
|
uptimeMs: number(),
|
|
6957
6881
|
bitrateKbps: number(),
|
|
6958
6882
|
idrIntervalMs: number(),
|
|
@@ -6965,14 +6889,6 @@ var BrokerStatsSchema = object({
|
|
|
6965
6889
|
preBufferMs: number(),
|
|
6966
6890
|
preBufferPackets: number(),
|
|
6967
6891
|
/**
|
|
6968
|
-
* Moleculer node id of the decoder provider currently servicing this
|
|
6969
|
-
* stream's decoded subscribers. `null` until the deferred decoder is
|
|
6970
|
-
* created (no decoded clients yet, or codec not detected). Surfaces the
|
|
6971
|
-
* runtime decoder placement so the UI can show "Decoder: <agent>" without
|
|
6972
|
-
* a separate cap call per broker.
|
|
6973
|
-
*/
|
|
6974
|
-
decoderNodeId: string().nullable(),
|
|
6975
|
-
/**
|
|
6976
6892
|
* Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
|
|
6977
6893
|
* when the stream has no audio track or the broker is in cold start.
|
|
6978
6894
|
* `supported = false` means the codec was detected but the local
|
|
@@ -11094,70 +11010,6 @@ var StorageLocationDeclarationSchema = object({
|
|
|
11094
11010
|
"backup"
|
|
11095
11011
|
]).optional()
|
|
11096
11012
|
});
|
|
11097
|
-
var DecoderStatsSchema = object({
|
|
11098
|
-
inputFps: number(),
|
|
11099
|
-
outputFps: number(),
|
|
11100
|
-
avgDecodeTimeMs: number(),
|
|
11101
|
-
droppedFrames: number(),
|
|
11102
|
-
/**
|
|
11103
|
-
* Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
|
|
11104
|
-
* lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
|
|
11105
|
-
* the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
|
|
11106
|
-
* is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
|
|
11107
|
-
*/
|
|
11108
|
-
lagMs: number().optional(),
|
|
11109
|
-
effectiveFps: number().optional(),
|
|
11110
|
-
adaptiveFps: number().optional()
|
|
11111
|
-
});
|
|
11112
|
-
var DecoderSessionConfigSchema = object({
|
|
11113
|
-
codec: string(),
|
|
11114
|
-
maxFps: number().default(0),
|
|
11115
|
-
outputFormat: _enum([
|
|
11116
|
-
"jpeg",
|
|
11117
|
-
"rgb",
|
|
11118
|
-
"bgr",
|
|
11119
|
-
"yuv420",
|
|
11120
|
-
"gray"
|
|
11121
|
-
]).default("jpeg"),
|
|
11122
|
-
scale: number().default(1),
|
|
11123
|
-
width: number().optional(),
|
|
11124
|
-
height: number().optional(),
|
|
11125
|
-
/**
|
|
11126
|
-
* Identifier of the camera this decoder session serves. Optional
|
|
11127
|
-
* because the cap is generic (any caller could request decode), but
|
|
11128
|
-
* stream-broker passes it so decoder logs include `deviceId` for
|
|
11129
|
-
* per-camera filtering when diagnosing failures (e.g. node-av
|
|
11130
|
-
* sendPacket errors on a single hung camera).
|
|
11131
|
-
*/
|
|
11132
|
-
deviceId: number().int().nonnegative().optional(),
|
|
11133
|
-
/**
|
|
11134
|
-
* Free-form tag for log scoping. Stream-broker uses
|
|
11135
|
-
* `broker:<deviceId>/<profile>`. Decoder session logger surfaces it
|
|
11136
|
-
* on every line so `grep tag=broker:5/high` filters one camera
|
|
11137
|
-
* profile cleanly.
|
|
11138
|
-
*/
|
|
11139
|
-
tag: string().optional(),
|
|
11140
|
-
/**
|
|
11141
|
-
* Where the session delivers decoded frames (Phase 5 / D9):
|
|
11142
|
-
*
|
|
11143
|
-
* - `'callback'` (default) — the legacy pixel path: decoded frames are
|
|
11144
|
-
* buffered as `DecodedFrame`s and drained via `pullFrames`.
|
|
11145
|
-
* - `'shm'` — the shared-memory frame plane: decoded frames are written
|
|
11146
|
-
* into an OS shared-memory ring and drained as zero-pixel
|
|
11147
|
-
* `FrameHandle`s via `pullHandles`. A session is one mode or the
|
|
11148
|
-
* other — `pullFrames` returns nothing for an `'shm'` session and
|
|
11149
|
-
* `pullHandles` returns nothing for a `'callback'` session.
|
|
11150
|
-
*/
|
|
11151
|
-
frameSink: _enum(["callback", "shm"]).default("callback"),
|
|
11152
|
-
/**
|
|
11153
|
-
* Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
|
|
11154
|
-
* a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
|
|
11155
|
-
* real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
|
|
11156
|
-
* stream-broker's `streamingDebug` gate — off by default so production logs
|
|
11157
|
-
* stay quiet and the emit path pays zero per-frame cost when disabled.
|
|
11158
|
-
*/
|
|
11159
|
-
debug: boolean().optional()
|
|
11160
|
-
});
|
|
11161
11013
|
/**
|
|
11162
11014
|
* Per-component log CHANNELS — the gate a hot path consults, and the registry
|
|
11163
11015
|
* an addon declares its channels in.
|
|
@@ -13392,13 +13244,6 @@ var BrokerRtspClientSchema = object({
|
|
|
13392
13244
|
lastRtpAt: number(),
|
|
13393
13245
|
bytesSent: number()
|
|
13394
13246
|
});
|
|
13395
|
-
var BrokerDecodedClientSchema = object({
|
|
13396
|
-
tag: string(),
|
|
13397
|
-
subscribedAt: number(),
|
|
13398
|
-
maxFps: number(),
|
|
13399
|
-
framesDelivered: number(),
|
|
13400
|
-
framesDropped: number()
|
|
13401
|
-
});
|
|
13402
13247
|
var BrokerAudioClientSchema = object({
|
|
13403
13248
|
tag: string(),
|
|
13404
13249
|
subscribedAt: number(),
|
|
@@ -13490,7 +13335,6 @@ var BrokerEncodedClientSchema = object({
|
|
|
13490
13335
|
});
|
|
13491
13336
|
var BrokerClientsSchema = object({
|
|
13492
13337
|
rtsp: array(BrokerRtspClientSchema).readonly(),
|
|
13493
|
-
decoded: array(BrokerDecodedClientSchema).readonly(),
|
|
13494
13338
|
audio: array(BrokerAudioClientSchema).readonly(),
|
|
13495
13339
|
encoded: array(BrokerEncodedClientSchema).readonly(),
|
|
13496
13340
|
pipeClients: number(),
|
|
@@ -13859,11 +13703,7 @@ method(object({
|
|
|
13859
13703
|
auth: "admin"
|
|
13860
13704
|
}), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
|
|
13861
13705
|
brokerId: string(),
|
|
13862
|
-
channel: _enum([
|
|
13863
|
-
"rtsp",
|
|
13864
|
-
"decoded",
|
|
13865
|
-
"audio"
|
|
13866
|
-
]),
|
|
13706
|
+
channel: _enum(["rtsp", "audio"]),
|
|
13867
13707
|
handle: string()
|
|
13868
13708
|
}), object({ killed: boolean() }), {
|
|
13869
13709
|
kind: "mutation",
|
|
@@ -13898,10 +13738,7 @@ method(object({
|
|
|
13898
13738
|
}), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
|
|
13899
13739
|
subscriptionId: string(),
|
|
13900
13740
|
maxCount: number().int().positive().default(8)
|
|
13901
|
-
}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(
|
|
13902
|
-
subscriptionId: string(),
|
|
13903
|
-
maxCount: number().int().positive().default(4)
|
|
13904
|
-
}), array(FrameHandleSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
|
|
13741
|
+
}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
|
|
13905
13742
|
brokerId: string(),
|
|
13906
13743
|
seconds: number().min(0).max(30)
|
|
13907
13744
|
}), _void(), {
|
|
@@ -15114,54 +14951,12 @@ var HWACCEL_OPTIONS = [
|
|
|
15114
14951
|
label: "DRM (Linux generic)"
|
|
15115
14952
|
}
|
|
15116
14953
|
];
|
|
15117
|
-
|
|
15118
|
-
* shm ring usage stats for a `frameSink: 'shm'` decoder session —
|
|
15119
|
-
* exposed via `decoder.getShmStats` so downstream consumers can
|
|
15120
|
-
* observe ring pressure (slot count, byte budget, hit/miss ratio).
|
|
15121
|
-
*/
|
|
15122
|
-
var ShmRingStatsSchema = object({
|
|
15123
|
-
sessionId: string(),
|
|
15124
|
-
slotCount: number().int(),
|
|
15125
|
-
slotByteLength: number().int(),
|
|
15126
|
-
segmentBytes: number().int(),
|
|
15127
|
-
budgetMb: number().int(),
|
|
15128
|
-
framesWritten: number().int(),
|
|
15129
|
-
getFrameHits: number().int(),
|
|
15130
|
-
getFrameMisses: number().int()
|
|
15131
|
-
});
|
|
15132
|
-
method(object({ codec: string() }), boolean()), method(_void(), object({
|
|
14954
|
+
method(_void(), object({
|
|
15133
14955
|
id: string(),
|
|
15134
14956
|
name: string(),
|
|
15135
|
-
isPullMode: boolean().optional(),
|
|
15136
|
-
priority: number().optional(),
|
|
15137
14957
|
hwaccel: string().optional(),
|
|
15138
14958
|
probedBestHwaccel: string().optional()
|
|
15139
|
-
})), method(
|
|
15140
|
-
sessionId: string(),
|
|
15141
|
-
nodeId: string()
|
|
15142
|
-
})), method(object({ sessionId: string() }), _void()), method(object({
|
|
15143
|
-
sessionId: string(),
|
|
15144
|
-
packet: EncodedPacketSchema
|
|
15145
|
-
}), _void()), method(object({
|
|
15146
|
-
sessionId: string(),
|
|
15147
|
-
url: string()
|
|
15148
|
-
}), _void()), method(object({
|
|
15149
|
-
sessionId: string(),
|
|
15150
|
-
maxCount: number().default(1),
|
|
15151
|
-
waitMs: number().optional()
|
|
15152
|
-
}), array(DecodedFrameSchema)), method(object({
|
|
15153
|
-
sessionId: string(),
|
|
15154
|
-
maxCount: number().default(1),
|
|
15155
|
-
waitMs: number().optional()
|
|
15156
|
-
}), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
|
|
15157
|
-
sessionId: string(),
|
|
15158
|
-
config: DecoderSessionConfigSchema.partial()
|
|
15159
|
-
}), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
|
|
15160
|
-
sessionId: string(),
|
|
15161
|
-
codec: string(),
|
|
15162
|
-
outputFormat: string(),
|
|
15163
|
-
createdAtMs: number()
|
|
15164
|
-
})).readonly()), method(_void(), object({ backend: string() }), {
|
|
14959
|
+
})), method(_void(), object({ backend: string() }), {
|
|
15165
14960
|
kind: "mutation",
|
|
15166
14961
|
auth: "admin"
|
|
15167
14962
|
});
|
|
@@ -22206,8 +22001,8 @@ Object.freeze(Object.fromEntries([{
|
|
|
22206
22001
|
var CLUSTER_STEP_SETTING_FIELDS = [{
|
|
22207
22002
|
stepId: "face-embedding",
|
|
22208
22003
|
key: "minLandmarkFaceSize",
|
|
22209
|
-
label: "Min face size
|
|
22210
|
-
description: "
|
|
22004
|
+
label: "Min face size to embed (detection-frame px)",
|
|
22005
|
+
description: "Faces smaller than this in the small frame the detector sees are not embedded, so they can never be recognised. Below it the face cannot be aligned reliably and a bad embedding matches everyone. Same value on every node. 0 = no limit.",
|
|
22211
22006
|
type: "slider",
|
|
22212
22007
|
min: 0,
|
|
22213
22008
|
max: 64,
|
|
@@ -24259,21 +24054,6 @@ var PipelineDefaultStepSchema = lazy(() => object({
|
|
|
24259
24054
|
group: string().optional(),
|
|
24260
24055
|
settings: record(string(), unknown()).optional()
|
|
24261
24056
|
}));
|
|
24262
|
-
var PipelineTemplateStepSchema = lazy(() => object({
|
|
24263
|
-
addonId: string(),
|
|
24264
|
-
enabled: boolean(),
|
|
24265
|
-
modelId: string(),
|
|
24266
|
-
children: array(PipelineTemplateStepSchema).readonly(),
|
|
24267
|
-
settings: record(string(), unknown()).optional()
|
|
24268
|
-
}));
|
|
24269
|
-
var PipelineTemplateSchema$1 = object({
|
|
24270
|
-
id: string(),
|
|
24271
|
-
name: string(),
|
|
24272
|
-
createdAt: string(),
|
|
24273
|
-
updatedAt: string(),
|
|
24274
|
-
engine: PipelineEngineChoiceSchema,
|
|
24275
|
-
steps: array(PipelineTemplateStepSchema).readonly()
|
|
24276
|
-
});
|
|
24277
24057
|
var PipelineModelOptionSchema = object({
|
|
24278
24058
|
id: string(),
|
|
24279
24059
|
name: string(),
|
|
@@ -24485,15 +24265,7 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24485
24265
|
}), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
|
|
24486
24266
|
steps: array(PipelineStepInputSchema),
|
|
24487
24267
|
deviceKey: string().optional()
|
|
24488
|
-
}), PipelineValidationResultSchema), method(_void(),
|
|
24489
|
-
name: string(),
|
|
24490
|
-
steps: array(PipelineTemplateStepSchema).readonly(),
|
|
24491
|
-
engine: PipelineEngineChoiceSchema
|
|
24492
|
-
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
|
|
24493
|
-
id: string(),
|
|
24494
|
-
name: string().optional(),
|
|
24495
|
-
steps: array(PipelineTemplateStepSchema).readonly().optional()
|
|
24496
|
-
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24268
|
+
}), PipelineValidationResultSchema), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24497
24269
|
addonId: string(),
|
|
24498
24270
|
modelId: string(),
|
|
24499
24271
|
format: ModelFormatSchema$2
|
|
@@ -24658,148 +24430,17 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24658
24430
|
settings: record(string(), unknown()).optional()
|
|
24659
24431
|
}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
|
|
24660
24432
|
/**
|
|
24661
|
-
* Wire shapes of the Load balancing surface (D748): the session placement
|
|
24662
|
-
* policy, the atomic share write, the observed placement statistics, the
|
|
24663
|
-
* hardware share suggestion and the stale device pins.
|
|
24664
|
-
*/
|
|
24665
|
-
/**
|
|
24666
|
-
* How a new detection session picks its node and device.
|
|
24667
|
-
* - `least-loaded` — the historical rule: lowest `attached / weight`, a
|
|
24668
|
-
* constant node order at a tie (D37). An idle node always ties at 0, so a
|
|
24669
|
-
* weight only bites once a node already holds a session.
|
|
24670
|
-
* - `share` — the share of PARALLEL sessions is held to the weights, and a
|
|
24671
|
-
* full or drowning node yields to a free one (D748).
|
|
24672
|
-
*/
|
|
24673
|
-
var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
|
|
24674
|
-
var LoadBalancingSharesInputSchema = object({
|
|
24675
|
-
/** nodeId → share (> 0). A node left out keeps its weight. */
|
|
24676
|
-
nodes: record(string(), number().positive()).default({}),
|
|
24677
|
-
/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
|
|
24678
|
-
devices: record(string(), record(string(), number().positive())).default({})
|
|
24679
|
-
});
|
|
24680
|
-
var PlacementStatsInputSchema = object({
|
|
24681
|
-
/** Window the observed shares are averaged over (default 1 h, max 24 h). */
|
|
24682
|
-
windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
|
|
24683
|
-
var PlacementDeviceStatsSchema = object({
|
|
24684
|
-
deviceKey: string(),
|
|
24685
|
-
/** Sessions running on this device now. */
|
|
24686
|
-
sessionsNow: number(),
|
|
24687
|
-
/** Sessions started on this device inside the window. */
|
|
24688
|
-
sessionsStarted: number(),
|
|
24689
|
-
/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
|
|
24690
|
-
observedShare: number().nullable()
|
|
24691
|
-
});
|
|
24692
|
-
var PlacementNodeStatsSchema = object({
|
|
24693
|
-
nodeId: string(),
|
|
24694
|
-
sessionsNow: number(),
|
|
24695
|
-
sessionsStarted: number(),
|
|
24696
|
-
/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
|
|
24697
|
-
observedShare: number().nullable(),
|
|
24698
|
-
/** Most sessions this node ran at once inside the window. */
|
|
24699
|
-
peakSessions: number(),
|
|
24700
|
-
/** Sessions a share election handed elsewhere because this node was full or drowning. */
|
|
24701
|
-
yieldsAway: number(),
|
|
24702
|
-
devices: array(PlacementDeviceStatsSchema).readonly()
|
|
24703
|
-
});
|
|
24704
|
-
/** A camera's device pin that the session path cannot honour. */
|
|
24705
|
-
var StaleDevicePinSchema = object({
|
|
24706
|
-
deviceId: number(),
|
|
24707
|
-
deviceKey: string(),
|
|
24708
|
-
/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
|
|
24709
|
-
reason: _enum(["disabled", "absent"])
|
|
24710
|
-
});
|
|
24711
|
-
var PlacementStatsSchema = object({
|
|
24712
|
-
policy: SessionPlacementPolicySchema,
|
|
24713
|
-
windowMs: number(),
|
|
24714
|
-
/** How much of the window was actually observed (the hub keeps it in memory). */
|
|
24715
|
-
observedForMs: number(),
|
|
24716
|
-
sessionsNow: number(),
|
|
24717
|
-
/** Most parallel sessions across the cluster inside the window. */
|
|
24718
|
-
clusterPeakSessions: number(),
|
|
24719
|
-
nodes: array(PlacementNodeStatsSchema).readonly(),
|
|
24720
|
-
stalePins: array(StaleDevicePinSchema).readonly()
|
|
24721
|
-
});
|
|
24722
|
-
var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
|
|
24723
|
-
var SuggestedDeviceShareSchema = object({
|
|
24724
|
-
deviceKey: string(),
|
|
24725
|
-
/** Share of the node (0–100, rounded). */
|
|
24726
|
-
share: number(),
|
|
24727
|
-
modelId: string().nullable(),
|
|
24728
|
-
/** Inferences per second at that model, from the measured table. */
|
|
24729
|
-
fps: number().nullable(),
|
|
24730
|
-
measured: boolean(),
|
|
24731
|
-
/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
|
|
24732
|
-
suggestedMaxSessions: number().nullable()
|
|
24733
|
-
});
|
|
24734
|
-
var SuggestedNodeShareSchema = object({
|
|
24735
|
-
nodeId: string(),
|
|
24736
|
-
/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
|
|
24737
|
-
share: number().nullable(),
|
|
24738
|
-
/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
|
|
24739
|
-
capacitySessions: number(),
|
|
24740
|
-
devices: array(SuggestedDeviceShareSchema).readonly(),
|
|
24741
|
-
skippedReason: string().nullable()
|
|
24742
|
-
});
|
|
24743
|
-
var SuggestSharesResultSchema = object({
|
|
24744
|
-
headroom: number(),
|
|
24745
|
-
/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
|
|
24746
|
-
cameraFps: number(),
|
|
24747
|
-
/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
|
|
24748
|
-
iterations: number(),
|
|
24749
|
-
nodes: array(SuggestedNodeShareSchema).readonly()
|
|
24750
|
-
});
|
|
24751
|
-
/**
|
|
24752
|
-
* Where the node and device shares come from (D750).
|
|
24753
|
-
* - `auto` — computed by the system from the cluster's measured capacity at
|
|
24754
|
-
* the Auto tune models, and recomputed whenever a node or device joins,
|
|
24755
|
-
* leaves, is switched on or off, or changes model.
|
|
24756
|
-
* - `manual` — the operator's stored sliders. A node or device that cannot
|
|
24757
|
-
* take sessions gives its share to the others in proportion; the stored
|
|
24758
|
-
* values are never rewritten for that.
|
|
24759
|
-
*/
|
|
24760
|
-
var ShareSourceSchema = _enum(["auto", "manual"]);
|
|
24761
|
-
var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
|
|
24762
|
-
object({
|
|
24763
|
-
nodes: record(string(), number()),
|
|
24764
|
-
devices: record(string(), record(string(), number()))
|
|
24765
|
-
});
|
|
24766
|
-
var EffectiveDeviceShareSchema = object({
|
|
24767
|
-
deviceKey: string(),
|
|
24768
|
-
/** Can take sessions now (enabled, available, can run the root). */
|
|
24769
|
-
eligible: boolean(),
|
|
24770
|
-
/** The share the source assigns, as a percentage of the node's devices. */
|
|
24771
|
-
configuredPct: number(),
|
|
24772
|
-
/** The share actually used, after an ineligible device's share went to the others. */
|
|
24773
|
-
effectivePct: number()
|
|
24774
|
-
});
|
|
24775
|
-
var EffectiveNodeShareSchema = object({
|
|
24776
|
-
nodeId: string(),
|
|
24777
|
-
eligible: boolean(),
|
|
24778
|
-
configuredPct: number(),
|
|
24779
|
-
effectivePct: number(),
|
|
24780
|
-
devices: array(EffectiveDeviceShareSchema).readonly()
|
|
24781
|
-
});
|
|
24782
|
-
var EffectiveSharesSchema = object({
|
|
24783
|
-
source: ShareSourceSchema,
|
|
24784
|
-
policy: SessionPlacementPolicySchema,
|
|
24785
|
-
/** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
|
|
24786
|
-
autoPending: boolean(),
|
|
24787
|
-
/** When the automatic shares were last computed (ms epoch); null = never. */
|
|
24788
|
-
computedAt: number().nullable(),
|
|
24789
|
-
/** What made the system recompute them last. */
|
|
24790
|
-
trigger: string().nullable(),
|
|
24791
|
-
nodes: array(EffectiveNodeShareSchema).readonly(),
|
|
24792
|
-
/** The relative weights the election reads (before eligibility). */
|
|
24793
|
-
nodeWeights: record(string(), number()),
|
|
24794
|
-
deviceWeights: record(string(), record(string(), number()))
|
|
24795
|
-
});
|
|
24796
|
-
/**
|
|
24797
24433
|
* The wire shapes of the Auto tune plan and apply (D745), used by the
|
|
24798
24434
|
* `pipeline-orchestrator` cap. The recommender's own types
|
|
24799
|
-
* (`recommend.ts
|
|
24435
|
+
* (`recommend.ts`) are the TS face of the same data; these
|
|
24800
24436
|
* schemas are what crosses the cap boundary.
|
|
24801
24437
|
*/
|
|
24802
24438
|
var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
|
|
24439
|
+
/** The operator's range for it. */
|
|
24440
|
+
var MIN_SESSIONS_PER_DEVICE_RANGE = {
|
|
24441
|
+
min: 1,
|
|
24442
|
+
max: 8
|
|
24443
|
+
};
|
|
24803
24444
|
var HardwareClassIdSchema = _enum([
|
|
24804
24445
|
"intel-core-ultra",
|
|
24805
24446
|
"intel-n-series",
|
|
@@ -24817,8 +24458,9 @@ var AcceleratorKindSchema = _enum([
|
|
|
24817
24458
|
]);
|
|
24818
24459
|
var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
24819
24460
|
object({
|
|
24820
|
-
kind: literal("
|
|
24821
|
-
|
|
24461
|
+
kind: literal("capacity"),
|
|
24462
|
+
sessions: number(),
|
|
24463
|
+
minSessions: number()
|
|
24822
24464
|
}),
|
|
24823
24465
|
object({
|
|
24824
24466
|
kind: literal("tie-faster"),
|
|
@@ -24833,16 +24475,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
|
24833
24475
|
}),
|
|
24834
24476
|
object({
|
|
24835
24477
|
kind: literal("no-fit-lightest"),
|
|
24836
|
-
|
|
24478
|
+
sessions: number(),
|
|
24479
|
+
minSessions: number()
|
|
24837
24480
|
}),
|
|
24838
24481
|
object({
|
|
24839
24482
|
kind: literal("derived-latency"),
|
|
24840
24483
|
modelId: string()
|
|
24841
24484
|
}),
|
|
24842
|
-
object({
|
|
24843
|
-
kind: literal("estimated-load"),
|
|
24844
|
-
observedForMs: number().nullable()
|
|
24845
|
-
}),
|
|
24846
24485
|
object({ kind: literal("cpu-device") }),
|
|
24847
24486
|
object({ kind: literal("coral-untouched") }),
|
|
24848
24487
|
object({ kind: literal("device-disabled") }),
|
|
@@ -24858,28 +24497,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
|
24858
24497
|
format: ModelFormatSchema$1
|
|
24859
24498
|
})
|
|
24860
24499
|
]);
|
|
24861
|
-
var DeviceDemandSchema = object({
|
|
24862
|
-
nodeId: string(),
|
|
24863
|
-
deviceKey: string(),
|
|
24864
|
-
demandFps: number(),
|
|
24865
|
-
maxCameraFps: number(),
|
|
24866
|
-
alwaysOnCameras: number(),
|
|
24867
|
-
onMotionSessions: number(),
|
|
24868
|
-
onMotionSource: _enum([
|
|
24869
|
-
"observed-24h",
|
|
24870
|
-
"estimate",
|
|
24871
|
-
"none"
|
|
24872
|
-
]),
|
|
24873
|
-
observedForMs: number().nullable(),
|
|
24874
|
-
/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
|
|
24875
|
-
placement: SessionPlacementPolicySchema
|
|
24876
|
-
});
|
|
24877
24500
|
var DeviceModelChoiceSchema = object({
|
|
24878
24501
|
modelId: string(),
|
|
24879
24502
|
p50Ms: number(),
|
|
24880
24503
|
fps: number(),
|
|
24881
24504
|
measured: boolean(),
|
|
24882
|
-
|
|
24505
|
+
/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
|
|
24506
|
+
capacitySessions: number(),
|
|
24883
24507
|
personRecall: number()
|
|
24884
24508
|
});
|
|
24885
24509
|
var DeviceRecommendationSchema = object({
|
|
@@ -24887,7 +24511,6 @@ var DeviceRecommendationSchema = object({
|
|
|
24887
24511
|
accelerator: AcceleratorKindSchema.nullable(),
|
|
24888
24512
|
enabled: boolean(),
|
|
24889
24513
|
available: boolean(),
|
|
24890
|
-
demand: DeviceDemandSchema.nullable(),
|
|
24891
24514
|
chosen: DeviceModelChoiceSchema.nullable(),
|
|
24892
24515
|
reasons: array(RecommendationReasonSchema).readonly()
|
|
24893
24516
|
});
|
|
@@ -24948,20 +24571,20 @@ var AutoTuneOptionsSchema = object({
|
|
|
24948
24571
|
/** Share of each accelerator's throughput kept free (0.3–0.5). */
|
|
24949
24572
|
headroom: number().min(.3).max(.5).default(.4),
|
|
24950
24573
|
/**
|
|
24951
|
-
*
|
|
24952
|
-
*
|
|
24953
|
-
*
|
|
24954
|
-
* is stored.
|
|
24574
|
+
* The least number of parallel sessions every device must sustain at the
|
|
24575
|
+
* camera rate with the headroom kept free (D755). The most accurate model
|
|
24576
|
+
* that reaches it wins.
|
|
24955
24577
|
*/
|
|
24956
|
-
|
|
24578
|
+
minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
|
|
24957
24579
|
});
|
|
24958
24580
|
var AutoTunePlanSchema = object({
|
|
24959
24581
|
/** Hash of everything the apply will write — the apply refuses a different one. */
|
|
24960
24582
|
planHash: string(),
|
|
24961
24583
|
family: literal("yolov9"),
|
|
24962
24584
|
headroom: number(),
|
|
24963
|
-
|
|
24964
|
-
|
|
24585
|
+
minSessionsPerDevice: number(),
|
|
24586
|
+
/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
|
|
24587
|
+
cameraFps: number(),
|
|
24965
24588
|
generatedAt: number(),
|
|
24966
24589
|
nodes: array(NodeRecommendationSchema).readonly(),
|
|
24967
24590
|
nodeChanges: array(NodeDeviceChangeSchema).readonly(),
|
|
@@ -24971,7 +24594,8 @@ var AutoTunePlanSchema = object({
|
|
|
24971
24594
|
});
|
|
24972
24595
|
var AutoTuneApplyInputSchema = object({
|
|
24973
24596
|
planHash: string(),
|
|
24974
|
-
headroom: number().min(.3).max(.5).default(.4)
|
|
24597
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24598
|
+
minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
|
|
24975
24599
|
});
|
|
24976
24600
|
var AutoTunePhaseResultSchema = object({
|
|
24977
24601
|
phase: _enum([
|
|
@@ -25003,6 +24627,177 @@ var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
|
|
|
25003
24627
|
reason: _enum(["apply-in-progress"])
|
|
25004
24628
|
})
|
|
25005
24629
|
]);
|
|
24630
|
+
/**
|
|
24631
|
+
* Wire shapes of the Load balancing surface (D748): the session placement
|
|
24632
|
+
* policy, the atomic share write, the observed placement statistics, the
|
|
24633
|
+
* hardware share suggestion and the stale device pins.
|
|
24634
|
+
*/
|
|
24635
|
+
/**
|
|
24636
|
+
* How a new detection session picks its node and device.
|
|
24637
|
+
* - `least-loaded` — the historical rule: lowest `attached / weight`, a
|
|
24638
|
+
* constant node order at a tie (D37). An idle node always ties at 0, so a
|
|
24639
|
+
* weight only bites once a node already holds a session.
|
|
24640
|
+
* - `share` — the share of PARALLEL sessions is held to the weights, and a
|
|
24641
|
+
* full or drowning node yields to a free one (D748).
|
|
24642
|
+
*/
|
|
24643
|
+
var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
|
|
24644
|
+
var LoadBalancingSharesInputSchema = object({
|
|
24645
|
+
/** nodeId → share (> 0). A node left out keeps its weight. */
|
|
24646
|
+
nodes: record(string(), number().positive()).default({}),
|
|
24647
|
+
/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
|
|
24648
|
+
devices: record(string(), record(string(), number().positive())).default({})
|
|
24649
|
+
});
|
|
24650
|
+
var PlacementStatsInputSchema = object({
|
|
24651
|
+
/** Window the observed shares are averaged over (default 1 h, max 24 h). */
|
|
24652
|
+
windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
|
|
24653
|
+
var PlacementDeviceStatsSchema = object({
|
|
24654
|
+
deviceKey: string(),
|
|
24655
|
+
/** Sessions running on this device now. */
|
|
24656
|
+
sessionsNow: number(),
|
|
24657
|
+
/** Sessions started on this device inside the window. */
|
|
24658
|
+
sessionsStarted: number(),
|
|
24659
|
+
/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
|
|
24660
|
+
observedShare: number().nullable()
|
|
24661
|
+
});
|
|
24662
|
+
var PlacementNodeStatsSchema = object({
|
|
24663
|
+
nodeId: string(),
|
|
24664
|
+
sessionsNow: number(),
|
|
24665
|
+
sessionsStarted: number(),
|
|
24666
|
+
/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
|
|
24667
|
+
observedShare: number().nullable(),
|
|
24668
|
+
/** Most sessions this node ran at once inside the window. */
|
|
24669
|
+
peakSessions: number(),
|
|
24670
|
+
/** Sessions a share election handed elsewhere because this node was full or drowning. */
|
|
24671
|
+
yieldsAway: number(),
|
|
24672
|
+
devices: array(PlacementDeviceStatsSchema).readonly()
|
|
24673
|
+
});
|
|
24674
|
+
/** A camera's device pin that the session path cannot honour. */
|
|
24675
|
+
var StaleDevicePinSchema = object({
|
|
24676
|
+
deviceId: number(),
|
|
24677
|
+
deviceKey: string(),
|
|
24678
|
+
/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
|
|
24679
|
+
reason: _enum(["disabled", "absent"])
|
|
24680
|
+
});
|
|
24681
|
+
var PlacementStatsSchema = object({
|
|
24682
|
+
policy: SessionPlacementPolicySchema,
|
|
24683
|
+
windowMs: number(),
|
|
24684
|
+
/** How much of the window was actually observed (the hub keeps it in memory). */
|
|
24685
|
+
observedForMs: number(),
|
|
24686
|
+
sessionsNow: number(),
|
|
24687
|
+
/** Most parallel sessions across the cluster inside the window. */
|
|
24688
|
+
clusterPeakSessions: number(),
|
|
24689
|
+
nodes: array(PlacementNodeStatsSchema).readonly(),
|
|
24690
|
+
stalePins: array(StaleDevicePinSchema).readonly()
|
|
24691
|
+
});
|
|
24692
|
+
/**
|
|
24693
|
+
* Where an automatic share's capacity comes from (D755).
|
|
24694
|
+
* - `hardware` — the static capacity of each device at its Auto tune model:
|
|
24695
|
+
* the measured latency table for the node's hardware class.
|
|
24696
|
+
* - `benchmark` — the node's own measured capacity (node benchmark results).
|
|
24697
|
+
* A node with no results falls back to `hardware`, and says so.
|
|
24698
|
+
*/
|
|
24699
|
+
var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
|
|
24700
|
+
/** Why a node under the `benchmark` source was sized from hardware instead. */
|
|
24701
|
+
var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
|
|
24702
|
+
var SuggestSharesInputSchema = object({
|
|
24703
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24704
|
+
/** Default `hardware`. */
|
|
24705
|
+
source: CapacitySourceSchema.default("hardware")
|
|
24706
|
+
});
|
|
24707
|
+
var SuggestedDeviceShareSchema = object({
|
|
24708
|
+
deviceKey: string(),
|
|
24709
|
+
/** Share of the node (0–100, rounded). */
|
|
24710
|
+
share: number(),
|
|
24711
|
+
modelId: string().nullable(),
|
|
24712
|
+
/** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
|
|
24713
|
+
fps: number().nullable(),
|
|
24714
|
+
/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
|
|
24715
|
+
measured: boolean(),
|
|
24716
|
+
/**
|
|
24717
|
+
* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
|
|
24718
|
+
* or the benchmark's measured max sessions. Never enforced.
|
|
24719
|
+
*/
|
|
24720
|
+
suggestedMaxSessions: number().nullable()
|
|
24721
|
+
});
|
|
24722
|
+
var SuggestedNodeShareSchema = object({
|
|
24723
|
+
nodeId: string(),
|
|
24724
|
+
/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
|
|
24725
|
+
share: number().nullable(),
|
|
24726
|
+
/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
|
|
24727
|
+
capacitySessions: number(),
|
|
24728
|
+
devices: array(SuggestedDeviceShareSchema).readonly(),
|
|
24729
|
+
skippedReason: string().nullable(),
|
|
24730
|
+
/** What this node's capacity was read from; null when the node is skipped. */
|
|
24731
|
+
capacitySource: CapacitySourceSchema.nullable(),
|
|
24732
|
+
/** Set when the `benchmark` source was asked for and this node used `hardware`. */
|
|
24733
|
+
capacityFallback: CapacityFallbackSchema.nullable()
|
|
24734
|
+
});
|
|
24735
|
+
var SuggestSharesResultSchema = object({
|
|
24736
|
+
headroom: number(),
|
|
24737
|
+
/** The source asked for; each node says what it actually used. */
|
|
24738
|
+
source: CapacitySourceSchema,
|
|
24739
|
+
/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
|
|
24740
|
+
cameraFps: number(),
|
|
24741
|
+
/** The Auto tune capacity floor the models were picked at. */
|
|
24742
|
+
minSessionsPerDevice: number(),
|
|
24743
|
+
nodes: array(SuggestedNodeShareSchema).readonly()
|
|
24744
|
+
});
|
|
24745
|
+
/**
|
|
24746
|
+
* Where the node and device shares come from (D750, D755).
|
|
24747
|
+
* - `hardware` (default) — computed by the system from each node's static
|
|
24748
|
+
* capacity (its accelerators at their Auto tune models, from the measured
|
|
24749
|
+
* latency table), recomputed whenever a node or device joins, leaves, is
|
|
24750
|
+
* switched on or off, or changes model. No load input.
|
|
24751
|
+
* - `benchmark` — the same, from each node's measured capacity (node
|
|
24752
|
+
* benchmark results); a node without results falls back to `hardware`.
|
|
24753
|
+
* - `manual` — the operator's stored sliders.
|
|
24754
|
+
* Either way a node or device that cannot take sessions gives its share to
|
|
24755
|
+
* the others in proportion; the stored values are never rewritten for that.
|
|
24756
|
+
*/
|
|
24757
|
+
var ShareSourceSchema = _enum([
|
|
24758
|
+
"hardware",
|
|
24759
|
+
"benchmark",
|
|
24760
|
+
"manual"
|
|
24761
|
+
]);
|
|
24762
|
+
var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
|
|
24763
|
+
object({
|
|
24764
|
+
nodes: record(string(), number()),
|
|
24765
|
+
devices: record(string(), record(string(), number()))
|
|
24766
|
+
});
|
|
24767
|
+
var EffectiveDeviceShareSchema = object({
|
|
24768
|
+
deviceKey: string(),
|
|
24769
|
+
/** Can take sessions now (enabled, available, can run the root). */
|
|
24770
|
+
eligible: boolean(),
|
|
24771
|
+
/** The share the source assigns, as a percentage of the node's devices. */
|
|
24772
|
+
configuredPct: number(),
|
|
24773
|
+
/** The share actually used, after an ineligible device's share went to the others. */
|
|
24774
|
+
effectivePct: number()
|
|
24775
|
+
});
|
|
24776
|
+
var EffectiveNodeShareSchema = object({
|
|
24777
|
+
nodeId: string(),
|
|
24778
|
+
eligible: boolean(),
|
|
24779
|
+
configuredPct: number(),
|
|
24780
|
+
effectivePct: number(),
|
|
24781
|
+
/** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
|
|
24782
|
+
capacitySource: CapacitySourceSchema.nullable(),
|
|
24783
|
+
/** Automatic `benchmark`: why this node used `hardware` instead. */
|
|
24784
|
+
capacityFallback: CapacityFallbackSchema.nullable(),
|
|
24785
|
+
devices: array(EffectiveDeviceShareSchema).readonly()
|
|
24786
|
+
});
|
|
24787
|
+
var EffectiveSharesSchema = object({
|
|
24788
|
+
source: ShareSourceSchema,
|
|
24789
|
+
policy: SessionPlacementPolicySchema,
|
|
24790
|
+
/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
|
|
24791
|
+
autoPending: boolean(),
|
|
24792
|
+
/** When the automatic shares were last computed (ms epoch); null = never. */
|
|
24793
|
+
computedAt: number().nullable(),
|
|
24794
|
+
/** What made the system recompute them last. */
|
|
24795
|
+
trigger: string().nullable(),
|
|
24796
|
+
nodes: array(EffectiveNodeShareSchema).readonly(),
|
|
24797
|
+
/** The relative weights the election reads (before eligibility). */
|
|
24798
|
+
nodeWeights: record(string(), number()),
|
|
24799
|
+
deviceWeights: record(string(), record(string(), number()))
|
|
24800
|
+
});
|
|
25006
24801
|
object({
|
|
25007
24802
|
activeCameras: number(),
|
|
25008
24803
|
throttledCameras: number(),
|
|
@@ -25880,14 +25675,15 @@ var RunnerLocalLoadSchema = object({
|
|
|
25880
25675
|
* Per-inference-device live load (multi-device C4). One entry per deviceKey
|
|
25881
25676
|
* this runner currently has attached cameras on, so the orchestrator's second
|
|
25882
25677
|
* `balance()` pass (over a node's devices) weights on real per-pool session
|
|
25883
|
-
* counts. Empty on single-device / pre-multi-device runners.
|
|
25884
|
-
* per
|
|
25678
|
+
* counts. Empty on single-device / pre-multi-device runners. There is no
|
|
25679
|
+
* per-device queue depth: the inference pool's backlog has no accessor, and
|
|
25680
|
+
* a field that always read 0 was removed rather than shown as a measurement
|
|
25681
|
+
* (D762).
|
|
25885
25682
|
*/
|
|
25886
25683
|
devices: array(object({
|
|
25887
25684
|
deviceKey: string(),
|
|
25888
25685
|
backend: string(),
|
|
25889
|
-
attachedCameras: number()
|
|
25890
|
-
queueDepthTotal: number()
|
|
25686
|
+
attachedCameras: number()
|
|
25891
25687
|
})).default([]),
|
|
25892
25688
|
/** Hardware capability flags reported by this node. */
|
|
25893
25689
|
hardware: object({
|
|
@@ -26101,14 +25897,6 @@ var CameraPipelineConfigSchema = object({
|
|
|
26101
25897
|
settings: record(string(), unknown()).readonly().optional()
|
|
26102
25898
|
}).nullable().optional()
|
|
26103
25899
|
});
|
|
26104
|
-
var PipelineTemplateSchema = object({
|
|
26105
|
-
id: string(),
|
|
26106
|
-
name: string(),
|
|
26107
|
-
description: string().optional(),
|
|
26108
|
-
config: CameraPipelineConfigSchema,
|
|
26109
|
-
createdAt: string(),
|
|
26110
|
-
updatedAt: string()
|
|
26111
|
-
});
|
|
26112
25900
|
var DeviceStepConfigSchema = object({
|
|
26113
25901
|
modelId: string().optional(),
|
|
26114
25902
|
settings: record(string(), unknown()).optional(),
|
|
@@ -26182,8 +25970,10 @@ var CameraStepOverridePatchSchema = object({
|
|
|
26182
25970
|
modelId: string().optional(),
|
|
26183
25971
|
settings: record(string(), unknown()).readonly().optional()
|
|
26184
25972
|
});
|
|
25973
|
+
var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
|
|
26185
25974
|
var CameraPipelineSettingsSchema = object({
|
|
26186
25975
|
stepToggles: record(string(), boolean()).optional(),
|
|
25976
|
+
stepSettings: CameraStepSettingsSchema.optional(),
|
|
26187
25977
|
stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
|
|
26188
25978
|
pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
|
|
26189
25979
|
});
|
|
@@ -26216,7 +26006,10 @@ var PipelineAssignmentSchema = object({
|
|
|
26216
26006
|
});
|
|
26217
26007
|
/**
|
|
26218
26008
|
* Per-agent load summary surfaced to the load balancer + dashboards.
|
|
26219
|
-
* Aggregated from each runner's `getLocalLoad` cap call.
|
|
26009
|
+
* Aggregated from each runner's `getLocalLoad` cap call. In the
|
|
26010
|
+
* `getAgentLoad` report, a single-device node's default-pool sessions (no
|
|
26011
|
+
* `deviceKey`) are credited to its one eligible device in `load.devices` —
|
|
26012
|
+
* the default pool IS that device (D745); the balancer's census stays raw.
|
|
26220
26013
|
*/
|
|
26221
26014
|
var AgentLoadSummarySchema = object({
|
|
26222
26015
|
nodeId: string(),
|
|
@@ -26305,26 +26098,27 @@ var CameraBrokerStatusSchema = object({
|
|
|
26305
26098
|
width: number(),
|
|
26306
26099
|
height: number(),
|
|
26307
26100
|
subscribers: number(),
|
|
26308
|
-
|
|
26309
|
-
|
|
26101
|
+
/**
|
|
26102
|
+
* Encoded packets/s the broker receives from the camera. null when the
|
|
26103
|
+
* broker's stats read failed — unknown, never 0 (a 0 here reads as a stall).
|
|
26104
|
+
* There is no output rate: decoding runs in the session decode workers, not
|
|
26105
|
+
* in the broker, so the broker's own decoded-frame rate is 0 on every live
|
|
26106
|
+
* camera and is not served (D758).
|
|
26107
|
+
*/
|
|
26108
|
+
inFps: number().nullable()
|
|
26310
26109
|
})).readonly(),
|
|
26311
26110
|
webrtcSessions: number(),
|
|
26312
26111
|
rtspRestream: boolean()
|
|
26313
26112
|
});
|
|
26314
|
-
/**
|
|
26315
|
-
|
|
26316
|
-
|
|
26317
|
-
|
|
26318
|
-
|
|
26319
|
-
|
|
26320
|
-
|
|
26321
|
-
|
|
26322
|
-
var CameraDecoderStatusSchema = object({
|
|
26323
|
-
nodeId: string(),
|
|
26324
|
-
formats: array(string()).readonly(),
|
|
26325
|
-
sessionCount: number(),
|
|
26326
|
-
shm: CameraDecoderShmSchema
|
|
26327
|
-
});
|
|
26113
|
+
/**
|
|
26114
|
+
* Decoder block — WHERE decode runs (co-located with the detection node by
|
|
26115
|
+
* construction); null when the camera has no detection node. It carries no
|
|
26116
|
+
* frame counter: the shared-memory plane whose counters it used to serve is
|
|
26117
|
+
* gone, and those fields read 0 forever. Whether frames actually flow is read
|
|
26118
|
+
* from `detection.actualFps` (frames delivered to and processed by the
|
|
26119
|
+
* detector), never from a counter nothing feeds.
|
|
26120
|
+
*/
|
|
26121
|
+
var CameraDecoderStatusSchema = object({ nodeId: string() });
|
|
26328
26122
|
/** Motion block — null when motion detection is not active for this device. */
|
|
26329
26123
|
var CameraMotionStatusSchema = object({
|
|
26330
26124
|
enabled: boolean(),
|
|
@@ -26747,6 +26541,13 @@ method(object({
|
|
|
26747
26541
|
}), object({ success: literal(true) }), {
|
|
26748
26542
|
kind: "mutation",
|
|
26749
26543
|
auth: "admin"
|
|
26544
|
+
}), method(object({
|
|
26545
|
+
deviceId: number(),
|
|
26546
|
+
addonId: string(),
|
|
26547
|
+
settings: record(string(), unknown()).nullable()
|
|
26548
|
+
}), object({ success: literal(true) }), {
|
|
26549
|
+
kind: "mutation",
|
|
26550
|
+
auth: "admin"
|
|
26750
26551
|
}), method(object({
|
|
26751
26552
|
deviceId: number(),
|
|
26752
26553
|
agentNodeId: string(),
|
|
@@ -26770,25 +26571,7 @@ method(object({
|
|
|
26770
26571
|
}), method(_void(), DiskReconcileJobSchema, {
|
|
26771
26572
|
kind: "mutation",
|
|
26772
26573
|
auth: "admin"
|
|
26773
|
-
}), method(_void(), DiskReconcileJobSchema, { auth: "admin" })
|
|
26774
|
-
name: string(),
|
|
26775
|
-
description: string().optional(),
|
|
26776
|
-
config: CameraPipelineConfigSchema
|
|
26777
|
-
}), PipelineTemplateSchema, {
|
|
26778
|
-
kind: "mutation",
|
|
26779
|
-
auth: "admin"
|
|
26780
|
-
}), method(object({
|
|
26781
|
-
id: string(),
|
|
26782
|
-
name: string().optional(),
|
|
26783
|
-
description: string().optional(),
|
|
26784
|
-
config: CameraPipelineConfigSchema.optional()
|
|
26785
|
-
}), PipelineTemplateSchema, {
|
|
26786
|
-
kind: "mutation",
|
|
26787
|
-
auth: "admin"
|
|
26788
|
-
}), method(object({ id: string() }), object({ success: literal(true) }), {
|
|
26789
|
-
kind: "mutation",
|
|
26790
|
-
auth: "admin"
|
|
26791
|
-
});
|
|
26574
|
+
}), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
|
|
26792
26575
|
/**
|
|
26793
26576
|
* Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
|
|
26794
26577
|
* `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
|
|
@@ -29201,8 +28984,6 @@ var WebrtcStreamChoiceSchema = object({
|
|
|
29201
28984
|
]).nullable(),
|
|
29202
28985
|
/** Input FPS from the camera (null for adaptive). */
|
|
29203
28986
|
inputFps: number().nullable(),
|
|
29204
|
-
/** Decoded FPS (null for adaptive). */
|
|
29205
|
-
decodeFps: number().nullable(),
|
|
29206
28987
|
/** Bitrate in kbps (null for adaptive). */
|
|
29207
28988
|
bitrateKbps: number().nullable()
|
|
29208
28989
|
});
|
|
@@ -39398,90 +39179,18 @@ Object.freeze({
|
|
|
39398
39179
|
addonId: null,
|
|
39399
39180
|
access: "create"
|
|
39400
39181
|
},
|
|
39401
|
-
"decoder.createSession": {
|
|
39402
|
-
capName: "decoder",
|
|
39403
|
-
capScope: "system",
|
|
39404
|
-
addonId: null,
|
|
39405
|
-
access: "view"
|
|
39406
|
-
},
|
|
39407
|
-
"decoder.destroySession": {
|
|
39408
|
-
capName: "decoder",
|
|
39409
|
-
capScope: "system",
|
|
39410
|
-
addonId: null,
|
|
39411
|
-
access: "delete"
|
|
39412
|
-
},
|
|
39413
|
-
"decoder.getFrame": {
|
|
39414
|
-
capName: "decoder",
|
|
39415
|
-
capScope: "system",
|
|
39416
|
-
addonId: null,
|
|
39417
|
-
access: "view"
|
|
39418
|
-
},
|
|
39419
39182
|
"decoder.getInfo": {
|
|
39420
39183
|
capName: "decoder",
|
|
39421
39184
|
capScope: "system",
|
|
39422
39185
|
addonId: null,
|
|
39423
39186
|
access: "view"
|
|
39424
39187
|
},
|
|
39425
|
-
"decoder.getShmStats": {
|
|
39426
|
-
capName: "decoder",
|
|
39427
|
-
capScope: "system",
|
|
39428
|
-
addonId: null,
|
|
39429
|
-
access: "view"
|
|
39430
|
-
},
|
|
39431
|
-
"decoder.getStats": {
|
|
39432
|
-
capName: "decoder",
|
|
39433
|
-
capScope: "system",
|
|
39434
|
-
addonId: null,
|
|
39435
|
-
access: "view"
|
|
39436
|
-
},
|
|
39437
|
-
"decoder.listActiveSessions": {
|
|
39438
|
-
capName: "decoder",
|
|
39439
|
-
capScope: "system",
|
|
39440
|
-
addonId: null,
|
|
39441
|
-
access: "view"
|
|
39442
|
-
},
|
|
39443
|
-
"decoder.openStream": {
|
|
39444
|
-
capName: "decoder",
|
|
39445
|
-
capScope: "system",
|
|
39446
|
-
addonId: null,
|
|
39447
|
-
access: "view"
|
|
39448
|
-
},
|
|
39449
|
-
"decoder.pullFrames": {
|
|
39450
|
-
capName: "decoder",
|
|
39451
|
-
capScope: "system",
|
|
39452
|
-
addonId: null,
|
|
39453
|
-
access: "view"
|
|
39454
|
-
},
|
|
39455
|
-
"decoder.pullHandles": {
|
|
39456
|
-
capName: "decoder",
|
|
39457
|
-
capScope: "system",
|
|
39458
|
-
addonId: null,
|
|
39459
|
-
access: "view"
|
|
39460
|
-
},
|
|
39461
|
-
"decoder.pushPacket": {
|
|
39462
|
-
capName: "decoder",
|
|
39463
|
-
capScope: "system",
|
|
39464
|
-
addonId: null,
|
|
39465
|
-
access: "view"
|
|
39466
|
-
},
|
|
39467
39188
|
"decoder.reprobeHwaccel": {
|
|
39468
39189
|
capName: "decoder",
|
|
39469
39190
|
capScope: "system",
|
|
39470
39191
|
addonId: null,
|
|
39471
39192
|
access: "create"
|
|
39472
39193
|
},
|
|
39473
|
-
"decoder.supportsCodec": {
|
|
39474
|
-
capName: "decoder",
|
|
39475
|
-
capScope: "system",
|
|
39476
|
-
addonId: null,
|
|
39477
|
-
access: "view"
|
|
39478
|
-
},
|
|
39479
|
-
"decoder.updateConfig": {
|
|
39480
|
-
capName: "decoder",
|
|
39481
|
-
capScope: "system",
|
|
39482
|
-
addonId: null,
|
|
39483
|
-
access: "view"
|
|
39484
|
-
},
|
|
39485
39194
|
"detectionPipeline.applyDeviceSettingsPatch": {
|
|
39486
39195
|
capName: "detection-pipeline",
|
|
39487
39196
|
capScope: "device",
|
|
@@ -42572,12 +42281,6 @@ Object.freeze({
|
|
|
42572
42281
|
addonId: null,
|
|
42573
42282
|
access: "delete"
|
|
42574
42283
|
},
|
|
42575
|
-
"pipelineExecutor.deleteTemplate": {
|
|
42576
|
-
capName: "pipeline-executor",
|
|
42577
|
-
capScope: "system",
|
|
42578
|
-
addonId: null,
|
|
42579
|
-
access: "delete"
|
|
42580
|
-
},
|
|
42581
42284
|
"pipelineExecutor.downloadModel": {
|
|
42582
42285
|
capName: "pipeline-executor",
|
|
42583
42286
|
capScope: "system",
|
|
@@ -42716,12 +42419,6 @@ Object.freeze({
|
|
|
42716
42419
|
addonId: null,
|
|
42717
42420
|
access: "view"
|
|
42718
42421
|
},
|
|
42719
|
-
"pipelineExecutor.listTemplates": {
|
|
42720
|
-
capName: "pipeline-executor",
|
|
42721
|
-
capScope: "system",
|
|
42722
|
-
addonId: null,
|
|
42723
|
-
access: "view"
|
|
42724
|
-
},
|
|
42725
42422
|
"pipelineExecutor.rearmInferenceDevice": {
|
|
42726
42423
|
capName: "pipeline-executor",
|
|
42727
42424
|
capScope: "system",
|
|
@@ -42746,12 +42443,6 @@ Object.freeze({
|
|
|
42746
42443
|
addonId: null,
|
|
42747
42444
|
access: "create"
|
|
42748
42445
|
},
|
|
42749
|
-
"pipelineExecutor.saveTemplate": {
|
|
42750
|
-
capName: "pipeline-executor",
|
|
42751
|
-
capScope: "system",
|
|
42752
|
-
addonId: null,
|
|
42753
|
-
access: "create"
|
|
42754
|
-
},
|
|
42755
42446
|
"pipelineExecutor.setVideoPipelineSteps": {
|
|
42756
42447
|
capName: "pipeline-executor",
|
|
42757
42448
|
capScope: "system",
|
|
@@ -42770,12 +42461,6 @@ Object.freeze({
|
|
|
42770
42461
|
addonId: null,
|
|
42771
42462
|
access: "create"
|
|
42772
42463
|
},
|
|
42773
|
-
"pipelineExecutor.updateTemplate": {
|
|
42774
|
-
capName: "pipeline-executor",
|
|
42775
|
-
capScope: "system",
|
|
42776
|
-
addonId: null,
|
|
42777
|
-
access: "create"
|
|
42778
|
-
},
|
|
42779
42464
|
"pipelineExecutor.validatePipeline": {
|
|
42780
42465
|
capName: "pipeline-executor",
|
|
42781
42466
|
capScope: "system",
|
|
@@ -42806,12 +42491,6 @@ Object.freeze({
|
|
|
42806
42491
|
addonId: null,
|
|
42807
42492
|
access: "create"
|
|
42808
42493
|
},
|
|
42809
|
-
"pipelineOrchestrator.deleteTemplate": {
|
|
42810
|
-
capName: "pipeline-orchestrator",
|
|
42811
|
-
capScope: "system",
|
|
42812
|
-
addonId: null,
|
|
42813
|
-
access: "delete"
|
|
42814
|
-
},
|
|
42815
42494
|
"pipelineOrchestrator.getAgentLoad": {
|
|
42816
42495
|
capName: "pipeline-orchestrator",
|
|
42817
42496
|
capScope: "system",
|
|
@@ -42962,12 +42641,6 @@ Object.freeze({
|
|
|
42962
42641
|
addonId: null,
|
|
42963
42642
|
access: "view"
|
|
42964
42643
|
},
|
|
42965
|
-
"pipelineOrchestrator.listTemplates": {
|
|
42966
|
-
capName: "pipeline-orchestrator",
|
|
42967
|
-
capScope: "system",
|
|
42968
|
-
addonId: null,
|
|
42969
|
-
access: "view"
|
|
42970
|
-
},
|
|
42971
42644
|
"pipelineOrchestrator.pauseForStorageMigration": {
|
|
42972
42645
|
capName: "pipeline-orchestrator",
|
|
42973
42646
|
capScope: "system",
|
|
@@ -43022,12 +42695,6 @@ Object.freeze({
|
|
|
43022
42695
|
addonId: null,
|
|
43023
42696
|
access: "create"
|
|
43024
42697
|
},
|
|
43025
|
-
"pipelineOrchestrator.saveTemplate": {
|
|
43026
|
-
capName: "pipeline-orchestrator",
|
|
43027
|
-
capScope: "system",
|
|
43028
|
-
addonId: null,
|
|
43029
|
-
access: "create"
|
|
43030
|
-
},
|
|
43031
42698
|
"pipelineOrchestrator.setAgentCapabilities": {
|
|
43032
42699
|
capName: "pipeline-orchestrator",
|
|
43033
42700
|
capScope: "system",
|
|
@@ -43076,6 +42743,12 @@ Object.freeze({
|
|
|
43076
42743
|
addonId: null,
|
|
43077
42744
|
access: "create"
|
|
43078
42745
|
},
|
|
42746
|
+
"pipelineOrchestrator.setCameraStepSettings": {
|
|
42747
|
+
capName: "pipeline-orchestrator",
|
|
42748
|
+
capScope: "system",
|
|
42749
|
+
addonId: null,
|
|
42750
|
+
access: "create"
|
|
42751
|
+
},
|
|
43079
42752
|
"pipelineOrchestrator.setCameraStepToggle": {
|
|
43080
42753
|
capName: "pipeline-orchestrator",
|
|
43081
42754
|
capScope: "system",
|
|
@@ -43130,12 +42803,6 @@ Object.freeze({
|
|
|
43130
42803
|
addonId: null,
|
|
43131
42804
|
access: "create"
|
|
43132
42805
|
},
|
|
43133
|
-
"pipelineOrchestrator.updateTemplate": {
|
|
43134
|
-
capName: "pipeline-orchestrator",
|
|
43135
|
-
capScope: "system",
|
|
43136
|
-
addonId: null,
|
|
43137
|
-
access: "create"
|
|
43138
|
-
},
|
|
43139
42806
|
"pipelineRunner.attachCamera": {
|
|
43140
42807
|
capName: "pipeline-runner",
|
|
43141
42808
|
capScope: "system",
|
|
@@ -44570,12 +44237,6 @@ Object.freeze({
|
|
|
44570
44237
|
addonId: null,
|
|
44571
44238
|
access: "view"
|
|
44572
44239
|
},
|
|
44573
|
-
"streamBroker.pullFrameHandles": {
|
|
44574
|
-
capName: "stream-broker",
|
|
44575
|
-
capScope: "system",
|
|
44576
|
-
addonId: null,
|
|
44577
|
-
access: "view"
|
|
44578
|
-
},
|
|
44579
44240
|
"streamBroker.regenerateRtspToken": {
|
|
44580
44241
|
capName: "stream-broker",
|
|
44581
44242
|
capScope: "system",
|
|
@@ -44642,12 +44303,6 @@ Object.freeze({
|
|
|
44642
44303
|
addonId: null,
|
|
44643
44304
|
access: "create"
|
|
44644
44305
|
},
|
|
44645
|
-
"streamBroker.subscribeFrames": {
|
|
44646
|
-
capName: "stream-broker",
|
|
44647
|
-
capScope: "system",
|
|
44648
|
-
addonId: null,
|
|
44649
|
-
access: "create"
|
|
44650
|
-
},
|
|
44651
44306
|
"streamBroker.unassignProfile": {
|
|
44652
44307
|
capName: "stream-broker",
|
|
44653
44308
|
capScope: "system",
|
|
@@ -44660,12 +44315,6 @@ Object.freeze({
|
|
|
44660
44315
|
addonId: null,
|
|
44661
44316
|
access: "create"
|
|
44662
44317
|
},
|
|
44663
|
-
"streamBroker.unsubscribeFrames": {
|
|
44664
|
-
capName: "stream-broker",
|
|
44665
|
-
capScope: "system",
|
|
44666
|
-
addonId: null,
|
|
44667
|
-
access: "create"
|
|
44668
|
-
},
|
|
44669
44318
|
"streamCatalog.getCatalog": {
|
|
44670
44319
|
capName: "stream-catalog",
|
|
44671
44320
|
capScope: "device",
|
|
@@ -47179,11 +46828,6 @@ Object.freeze({
|
|
|
47179
46828
|
form: "single",
|
|
47180
46829
|
optional: false
|
|
47181
46830
|
}],
|
|
47182
|
-
"decoder.createSession": [{
|
|
47183
|
-
name: "deviceId",
|
|
47184
|
-
form: "single",
|
|
47185
|
-
optional: true
|
|
47186
|
-
}],
|
|
47187
46831
|
"detectionPipeline.applyDeviceSettingsPatch": [{
|
|
47188
46832
|
name: "deviceId",
|
|
47189
46833
|
form: "single",
|
|
@@ -48524,6 +48168,11 @@ Object.freeze({
|
|
|
48524
48168
|
form: "single",
|
|
48525
48169
|
optional: false
|
|
48526
48170
|
}],
|
|
48171
|
+
"pipelineOrchestrator.setCameraStepSettings": [{
|
|
48172
|
+
name: "deviceId",
|
|
48173
|
+
form: "single",
|
|
48174
|
+
optional: false
|
|
48175
|
+
}],
|
|
48527
48176
|
"pipelineOrchestrator.setCameraStepToggle": [{
|
|
48528
48177
|
name: "deviceId",
|
|
48529
48178
|
form: "single",
|