@camstack/addon-export-hap 1.2.150 → 1.2.151
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 +684 -71
- package/dist/hap-export.addon.mjs +684 -71
- package/package.json +1 -1
package/dist/hap-export.addon.js
CHANGED
|
@@ -5428,7 +5428,7 @@ var ZodIssueCode = {
|
|
|
5428
5428
|
var ZodFirstPartyTypeKind;
|
|
5429
5429
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5430
5430
|
//#endregion
|
|
5431
|
-
//#region ../types/dist/sleep-
|
|
5431
|
+
//#region ../types/dist/sleep-C16NCZR2.mjs
|
|
5432
5432
|
/**
|
|
5433
5433
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5434
5434
|
* window to float samples (D455).
|
|
@@ -11396,7 +11396,18 @@ var LABEL_SUPPLY_STEP_IDS = [
|
|
|
11396
11396
|
];
|
|
11397
11397
|
/** Steps whose box a root detection can BE. */
|
|
11398
11398
|
var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
|
|
11399
|
-
|
|
11399
|
+
/**
|
|
11400
|
+
* Steps whose per-detection MASK a root detection can carry (D737). The live
|
|
11401
|
+
* mask step is `segmentation` — a frame-plane refiner that runs its own model
|
|
11402
|
+
* once per detection crop. (`instance-segmentation` is a dormant step id that
|
|
11403
|
+
* no camera tree carries.)
|
|
11404
|
+
*/
|
|
11405
|
+
var MASK_SUPPLY_STEP_IDS = ["segmentation"];
|
|
11406
|
+
[
|
|
11407
|
+
...LABEL_SUPPLY_STEP_IDS,
|
|
11408
|
+
...CROP_SUPPLY_STEP_IDS,
|
|
11409
|
+
...MASK_SUPPLY_STEP_IDS
|
|
11410
|
+
];
|
|
11400
11411
|
var MODEL_FORMATS = [
|
|
11401
11412
|
"onnx",
|
|
11402
11413
|
"coreml",
|
|
@@ -11425,7 +11436,53 @@ var ModelFormatEntrySchema = object({
|
|
|
11425
11436
|
/** Multi-file payload (directory members or sibling files). */
|
|
11426
11437
|
files: array(string()).readonly().optional(),
|
|
11427
11438
|
/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
|
|
11428
|
-
runtimes: array(_enum(["python"])).readonly().optional()
|
|
11439
|
+
runtimes: array(_enum(["python"])).readonly().optional(),
|
|
11440
|
+
/**
|
|
11441
|
+
* Content revision of the artefact, for one hosted OFF the CamStack mirror.
|
|
11442
|
+
* A format on the mirror leaves it unset: its revision (the sha256 of its
|
|
11443
|
+
* weight file) comes from the downloader's generated table, kept in step
|
|
11444
|
+
* with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
|
|
11445
|
+
* node records the revision it downloaded next to the file
|
|
11446
|
+
* (`<file>.revision`); a copy with no record or a different one is stale
|
|
11447
|
+
* unless its weight file hashes to the revision, and a stale copy is
|
|
11448
|
+
* downloaded again, the old one serving until the new one is complete. No
|
|
11449
|
+
* revision at all ⇒ a file on disk is current, whatever it holds (D743).
|
|
11450
|
+
*/
|
|
11451
|
+
revision: string().min(1).optional()
|
|
11452
|
+
});
|
|
11453
|
+
/**
|
|
11454
|
+
* What a node holds for one (model, format) (D746). `current` is a complete
|
|
11455
|
+
* copy at its catalog revision — exactly what `downloaded: true` means.
|
|
11456
|
+
* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
|
|
11457
|
+
* no or a different revision record, or a missing sibling. `missing` is no
|
|
11458
|
+
* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
|
|
11459
|
+
* reclaimable bytes and a copy about to be replaced.
|
|
11460
|
+
*/
|
|
11461
|
+
var ModelOnDiskStateSchema = _enum([
|
|
11462
|
+
"current",
|
|
11463
|
+
"stale",
|
|
11464
|
+
"missing"
|
|
11465
|
+
]);
|
|
11466
|
+
/**
|
|
11467
|
+
* The numeric precision of one format's BUILD (D746) — reported only when the
|
|
11468
|
+
* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
|
|
11469
|
+
* CamStack Core ML export). Absent means "not stated", never "fp32".
|
|
11470
|
+
*/
|
|
11471
|
+
var ModelFormatPrecisionSchema = _enum([
|
|
11472
|
+
"fp32",
|
|
11473
|
+
"fp16",
|
|
11474
|
+
"int8"
|
|
11475
|
+
]);
|
|
11476
|
+
/**
|
|
11477
|
+
* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
|
|
11478
|
+
* `onDisk` / `precision` are optional for version skew: a runner that predates
|
|
11479
|
+
* them omits them, and a reader falls back to `downloaded`.
|
|
11480
|
+
*/
|
|
11481
|
+
var PipelineModelFormatStatusSchema = object({
|
|
11482
|
+
downloaded: boolean(),
|
|
11483
|
+
sizeMB: number(),
|
|
11484
|
+
onDisk: ModelOnDiskStateSchema.optional(),
|
|
11485
|
+
precision: ModelFormatPrecisionSchema.optional()
|
|
11429
11486
|
});
|
|
11430
11487
|
/**
|
|
11431
11488
|
* Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
|
|
@@ -11539,25 +11596,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
|
|
|
11539
11596
|
* - `crop`: the root draws the box the step would have found (`license_plate`
|
|
11540
11597
|
* for plate-detection, `face` for face-detection). The box becomes a detail
|
|
11541
11598
|
* child of the `parentMacro` detection that contains it — never a track.
|
|
11599
|
+
* - `mask`: the root's decode emits an instance mask with every detection (a
|
|
11600
|
+
* YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
|
|
11601
|
+
* detection in the shape that step produces. Derived from the model's
|
|
11602
|
+
* postprocessor on read, never stored by an import.
|
|
11542
11603
|
*/
|
|
11543
|
-
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
11544
|
-
|
|
11545
|
-
|
|
11546
|
-
|
|
11547
|
-
|
|
11548
|
-
|
|
11549
|
-
|
|
11550
|
-
|
|
11551
|
-
|
|
11552
|
-
|
|
11553
|
-
|
|
11554
|
-
|
|
11555
|
-
|
|
11556
|
-
|
|
11557
|
-
|
|
11558
|
-
|
|
11559
|
-
|
|
11560
|
-
|
|
11604
|
+
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
11605
|
+
object({
|
|
11606
|
+
kind: literal("label"),
|
|
11607
|
+
stepId: _enum(LABEL_SUPPLY_STEP_IDS),
|
|
11608
|
+
labelToEffect: record(string(), string()),
|
|
11609
|
+
uncovered: array(string()).readonly()
|
|
11610
|
+
}),
|
|
11611
|
+
object({
|
|
11612
|
+
kind: literal("crop"),
|
|
11613
|
+
stepId: _enum(CROP_SUPPLY_STEP_IDS),
|
|
11614
|
+
rootLabels: array(string()).readonly(),
|
|
11615
|
+
parentMacro: _enum(["vehicle", "person"]),
|
|
11616
|
+
childClass: _enum(["plate", "face"]),
|
|
11617
|
+
/**
|
|
11618
|
+
* The root's smaller input side, stamped on read by `rootSuppliesOf` from
|
|
11619
|
+
* the model entry — what a step's `minRootInputPx` gate judges. Never
|
|
11620
|
+
* stored by an import.
|
|
11621
|
+
*/
|
|
11622
|
+
rootInputPx: number().int().positive().optional()
|
|
11623
|
+
}),
|
|
11624
|
+
object({
|
|
11625
|
+
kind: literal("mask"),
|
|
11626
|
+
stepId: _enum(MASK_SUPPLY_STEP_IDS)
|
|
11627
|
+
})
|
|
11628
|
+
]);
|
|
11561
11629
|
var ModelCatalogEntrySchema = object({
|
|
11562
11630
|
id: string(),
|
|
11563
11631
|
name: string(),
|
|
@@ -11623,6 +11691,35 @@ var ModelCatalogEntrySchema = object({
|
|
|
11623
11691
|
*/
|
|
11624
11692
|
defaultConfidence: number().min(0).max(1).optional(),
|
|
11625
11693
|
/**
|
|
11694
|
+
* Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
|
|
11695
|
+
* on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
|
|
11696
|
+
* absent here runs at the step slider's global default. The same row shape
|
|
11697
|
+
* the floor measurement produces (`model-floors.json`: modelId → floors), so
|
|
11698
|
+
* a measured table is copied in as-is. An operator override is bound to the
|
|
11699
|
+
* model it was made for and does not survive a model change (D738). A custom
|
|
11700
|
+
* / imported model may declare it; without it, the global defaults apply.
|
|
11701
|
+
*/
|
|
11702
|
+
defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11703
|
+
/**
|
|
11704
|
+
* The inference precision this model's OpenVINO IR needs on an Intel GPU.
|
|
11705
|
+
* Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
|
|
11706
|
+
* that produces invalid output at f16 — measured 2026-10-07 for YOLO26
|
|
11707
|
+
* base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
|
|
11708
|
+
* scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
|
|
11709
|
+
* `PoolModelConfig.gpuInferencePrecision`; the pool sets
|
|
11710
|
+
* INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
|
|
11711
|
+
*/
|
|
11712
|
+
gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
|
|
11713
|
+
/**
|
|
11714
|
+
* ROOT detectors only: per supplied step (`animal-classifier`, …), the
|
|
11715
|
+
* minimum DETECTION score from which this root's own fine label (species,
|
|
11716
|
+
* vehicle type — D736 root supply) is taken (D741). Below it the detection
|
|
11717
|
+
* keeps its macro class without the fine label. `1` = never take it from
|
|
11718
|
+
* this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
|
|
11719
|
+
* `minConfidence` slider, bound to the ROOT model, overrides it.
|
|
11720
|
+
*/
|
|
11721
|
+
suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11722
|
+
/**
|
|
11626
11723
|
* When true, the executor produces a landmark-aligned crop (similarity warp
|
|
11627
11724
|
* onto the canonical template) before this step runs, instead of a plain
|
|
11628
11725
|
* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
|
|
@@ -16933,6 +17030,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
|
|
|
16933
17030
|
kind: "mutation",
|
|
16934
17031
|
auth: "admin"
|
|
16935
17032
|
});
|
|
17033
|
+
var HUB_ADDRESS_ROLES = [
|
|
17034
|
+
"appConnections",
|
|
17035
|
+
"notificationTaps",
|
|
17036
|
+
"internal",
|
|
17037
|
+
"publicEndpoint"
|
|
17038
|
+
];
|
|
16936
17039
|
/**
|
|
16937
17040
|
* Transport bounds for AI capability methods.
|
|
16938
17041
|
*
|
|
@@ -21104,7 +21207,13 @@ var NcAlarmModeDelaysListSchema = array(object({
|
|
|
21104
21207
|
* Absent = false (logged, not sent). Even when true it is not sent when that same sensor
|
|
21105
21208
|
* is the one that starts the entry delay — the entry-delay notification already names it.
|
|
21106
21209
|
*/
|
|
21107
|
-
notifySensorRewatched: boolean().optional()
|
|
21210
|
+
notifySensorRewatched: boolean().optional(),
|
|
21211
|
+
/**
|
|
21212
|
+
* D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
|
|
21213
|
+
* change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
|
|
21214
|
+
* re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
|
|
21215
|
+
*/
|
|
21216
|
+
notifySensorIgnored: boolean().optional()
|
|
21108
21217
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
|
|
21109
21218
|
var NcAlarmModeDelaysEditListSchema = array(object({
|
|
21110
21219
|
mode: AlarmArmModeSchema,
|
|
@@ -21117,7 +21226,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
|
|
|
21117
21226
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21118
21227
|
notifyDuringEntryDelay: boolean().nullable().optional(),
|
|
21119
21228
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21120
|
-
notifySensorRewatched: boolean().nullable().optional()
|
|
21229
|
+
notifySensorRewatched: boolean().nullable().optional(),
|
|
21230
|
+
/** D735: set the switch, or `null` to clear it (back to the default, false). */
|
|
21231
|
+
notifySensorIgnored: boolean().nullable().optional()
|
|
21121
21232
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
|
|
21122
21233
|
/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
|
|
21123
21234
|
var NcAlarmNonBlockingEditSchema = object({
|
|
@@ -24091,7 +24202,7 @@ var FrameRefSchema = object({
|
|
|
24091
24202
|
timestamp: number(),
|
|
24092
24203
|
capturedAt: number().optional()
|
|
24093
24204
|
});
|
|
24094
|
-
var ModelFormatSchema$
|
|
24205
|
+
var ModelFormatSchema$2 = _enum([
|
|
24095
24206
|
"onnx",
|
|
24096
24207
|
"coreml",
|
|
24097
24208
|
"openvino",
|
|
@@ -24109,7 +24220,7 @@ var PipelineSlotSchema = _enum([
|
|
|
24109
24220
|
var PipelineEngineChoiceSchema = object({
|
|
24110
24221
|
runtime: literal("python"),
|
|
24111
24222
|
backend: string(),
|
|
24112
|
-
format: ModelFormatSchema$
|
|
24223
|
+
format: ModelFormatSchema$2,
|
|
24113
24224
|
device: string().optional()
|
|
24114
24225
|
});
|
|
24115
24226
|
/**
|
|
@@ -24166,10 +24277,7 @@ var PipelineTemplateSchema$1 = object({
|
|
|
24166
24277
|
var PipelineModelOptionSchema = object({
|
|
24167
24278
|
id: string(),
|
|
24168
24279
|
name: string(),
|
|
24169
|
-
formats: record(string(),
|
|
24170
|
-
downloaded: boolean(),
|
|
24171
|
-
sizeMB: number()
|
|
24172
|
-
})),
|
|
24280
|
+
formats: record(string(), PipelineModelFormatStatusSchema),
|
|
24173
24281
|
group: ModelVariantGroupSchema.optional(),
|
|
24174
24282
|
legacy: boolean().optional(),
|
|
24175
24283
|
provider: ModelProviderIdSchema.optional(),
|
|
@@ -24336,6 +24444,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24336
24444
|
}), {
|
|
24337
24445
|
kind: "mutation",
|
|
24338
24446
|
auth: "admin"
|
|
24447
|
+
}), method(object({
|
|
24448
|
+
nodeId: string(),
|
|
24449
|
+
deviceIds: array(number()).readonly().optional(),
|
|
24450
|
+
dryRun: boolean()
|
|
24451
|
+
}), object({
|
|
24452
|
+
entries: array(object({
|
|
24453
|
+
deviceId: number(),
|
|
24454
|
+
keys: array(string()).readonly()
|
|
24455
|
+
})).readonly(),
|
|
24456
|
+
refused: array(object({
|
|
24457
|
+
deviceId: number(),
|
|
24458
|
+
reason: string()
|
|
24459
|
+
})).readonly()
|
|
24460
|
+
}), {
|
|
24461
|
+
kind: "mutation",
|
|
24462
|
+
auth: "admin"
|
|
24339
24463
|
}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
|
|
24340
24464
|
/** `<backend>:<device>`, e.g. `openvino:gpu`. */
|
|
24341
24465
|
deviceKey: string(),
|
|
@@ -24372,11 +24496,11 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24372
24496
|
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24373
24497
|
addonId: string(),
|
|
24374
24498
|
modelId: string(),
|
|
24375
|
-
format: ModelFormatSchema$
|
|
24499
|
+
format: ModelFormatSchema$2
|
|
24376
24500
|
}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
|
|
24377
24501
|
addonId: string(),
|
|
24378
24502
|
modelId: string(),
|
|
24379
|
-
format: ModelFormatSchema$
|
|
24503
|
+
format: ModelFormatSchema$2
|
|
24380
24504
|
}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
|
|
24381
24505
|
steps: array(PipelineStepInputSchema).min(1),
|
|
24382
24506
|
frame: FrameInputSchema.optional(),
|
|
@@ -24533,6 +24657,352 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24533
24657
|
filename: string().optional(),
|
|
24534
24658
|
settings: record(string(), unknown()).optional()
|
|
24535
24659
|
}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
|
|
24660
|
+
/**
|
|
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
|
+
* The wire shapes of the Auto tune plan and apply (D745), used by the
|
|
24798
|
+
* `pipeline-orchestrator` cap. The recommender's own types
|
|
24799
|
+
* (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
|
|
24800
|
+
* schemas are what crosses the cap boundary.
|
|
24801
|
+
*/
|
|
24802
|
+
var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
|
|
24803
|
+
var HardwareClassIdSchema = _enum([
|
|
24804
|
+
"intel-core-ultra",
|
|
24805
|
+
"intel-n-series",
|
|
24806
|
+
"apple-m-base",
|
|
24807
|
+
"apple-m-pro",
|
|
24808
|
+
"unknown"
|
|
24809
|
+
]);
|
|
24810
|
+
var AcceleratorKindSchema = _enum([
|
|
24811
|
+
"intel-npu",
|
|
24812
|
+
"intel-igpu",
|
|
24813
|
+
"x86-cpu",
|
|
24814
|
+
"arm-cpu",
|
|
24815
|
+
"apple-ane",
|
|
24816
|
+
"coral"
|
|
24817
|
+
]);
|
|
24818
|
+
var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
24819
|
+
object({
|
|
24820
|
+
kind: literal("fits"),
|
|
24821
|
+
utilisation: number()
|
|
24822
|
+
}),
|
|
24823
|
+
object({
|
|
24824
|
+
kind: literal("tie-faster"),
|
|
24825
|
+
over: string(),
|
|
24826
|
+
recallDelta: number()
|
|
24827
|
+
}),
|
|
24828
|
+
object({
|
|
24829
|
+
kind: literal("stepped-down"),
|
|
24830
|
+
from: string(),
|
|
24831
|
+
to: string(),
|
|
24832
|
+
limitedBy: string()
|
|
24833
|
+
}),
|
|
24834
|
+
object({
|
|
24835
|
+
kind: literal("no-fit-lightest"),
|
|
24836
|
+
utilisation: number()
|
|
24837
|
+
}),
|
|
24838
|
+
object({
|
|
24839
|
+
kind: literal("derived-latency"),
|
|
24840
|
+
modelId: string()
|
|
24841
|
+
}),
|
|
24842
|
+
object({
|
|
24843
|
+
kind: literal("estimated-load"),
|
|
24844
|
+
observedForMs: number().nullable()
|
|
24845
|
+
}),
|
|
24846
|
+
object({ kind: literal("cpu-device") }),
|
|
24847
|
+
object({ kind: literal("coral-untouched") }),
|
|
24848
|
+
object({ kind: literal("device-disabled") }),
|
|
24849
|
+
object({ kind: literal("device-unavailable") }),
|
|
24850
|
+
object({ kind: literal("node-offline") }),
|
|
24851
|
+
object({ kind: literal("no-hardware-facts") }),
|
|
24852
|
+
object({
|
|
24853
|
+
kind: literal("no-measured-data"),
|
|
24854
|
+
hardwareClass: HardwareClassIdSchema
|
|
24855
|
+
}),
|
|
24856
|
+
object({
|
|
24857
|
+
kind: literal("no-family-build"),
|
|
24858
|
+
format: ModelFormatSchema$1
|
|
24859
|
+
})
|
|
24860
|
+
]);
|
|
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
|
+
var DeviceModelChoiceSchema = object({
|
|
24878
|
+
modelId: string(),
|
|
24879
|
+
p50Ms: number(),
|
|
24880
|
+
fps: number(),
|
|
24881
|
+
measured: boolean(),
|
|
24882
|
+
utilisation: number(),
|
|
24883
|
+
personRecall: number()
|
|
24884
|
+
});
|
|
24885
|
+
var DeviceRecommendationSchema = object({
|
|
24886
|
+
deviceKey: string(),
|
|
24887
|
+
accelerator: AcceleratorKindSchema.nullable(),
|
|
24888
|
+
enabled: boolean(),
|
|
24889
|
+
available: boolean(),
|
|
24890
|
+
demand: DeviceDemandSchema.nullable(),
|
|
24891
|
+
chosen: DeviceModelChoiceSchema.nullable(),
|
|
24892
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24893
|
+
});
|
|
24894
|
+
var NodeRecommendationSchema = object({
|
|
24895
|
+
nodeId: string(),
|
|
24896
|
+
reachable: boolean(),
|
|
24897
|
+
hardwareClass: HardwareClassIdSchema.nullable(),
|
|
24898
|
+
cpuModel: string().nullable(),
|
|
24899
|
+
skipped: boolean(),
|
|
24900
|
+
acceleratorModelId: string().nullable(),
|
|
24901
|
+
devices: array(DeviceRecommendationSchema).readonly(),
|
|
24902
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24903
|
+
});
|
|
24904
|
+
var ModelPinChangeSchema = object({
|
|
24905
|
+
stepId: string(),
|
|
24906
|
+
before: string().nullable(),
|
|
24907
|
+
after: string().nullable()
|
|
24908
|
+
});
|
|
24909
|
+
var NodeDeviceChangeSchema = object({
|
|
24910
|
+
nodeId: string(),
|
|
24911
|
+
deviceKey: string(),
|
|
24912
|
+
madeExplicit: boolean(),
|
|
24913
|
+
modelPins: array(ModelPinChangeSchema).readonly(),
|
|
24914
|
+
thresholds: array(object({
|
|
24915
|
+
stepId: string(),
|
|
24916
|
+
keys: array(string()).readonly()
|
|
24917
|
+
})).readonly()
|
|
24918
|
+
});
|
|
24919
|
+
var CameraOverrideClearSchema = object({
|
|
24920
|
+
deviceId: number(),
|
|
24921
|
+
source: _enum(["step-override", "wholesale"]),
|
|
24922
|
+
nodeId: string(),
|
|
24923
|
+
deviceKey: string().nullable(),
|
|
24924
|
+
stepId: string(),
|
|
24925
|
+
modelIdBefore: string().nullable(),
|
|
24926
|
+
keys: array(string()).readonly()
|
|
24927
|
+
});
|
|
24928
|
+
var DetectorStoreClearSchema = object({
|
|
24929
|
+
deviceId: number(),
|
|
24930
|
+
keys: array(string()).readonly()
|
|
24931
|
+
});
|
|
24932
|
+
var AutoTuneWarningSchema = discriminatedUnion("kind", [
|
|
24933
|
+
object({
|
|
24934
|
+
kind: literal("detector-store-cluster-wide"),
|
|
24935
|
+
skippedNodes: array(string()).readonly()
|
|
24936
|
+
}),
|
|
24937
|
+
object({
|
|
24938
|
+
kind: literal("detector-store-unreadable"),
|
|
24939
|
+
error: string()
|
|
24940
|
+
}),
|
|
24941
|
+
object({
|
|
24942
|
+
kind: literal("coral-enabled"),
|
|
24943
|
+
nodeId: string(),
|
|
24944
|
+
deviceKey: string()
|
|
24945
|
+
})
|
|
24946
|
+
]);
|
|
24947
|
+
var AutoTuneOptionsSchema = object({
|
|
24948
|
+
/** Share of each accelerator's throughput kept free (0.3–0.5). */
|
|
24949
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24950
|
+
/**
|
|
24951
|
+
* What-if shares (D748): plan as if these node/device shares were stored
|
|
24952
|
+
* and the policy were `share`. Absent = the stored shares under the stored
|
|
24953
|
+
* policy. A what-if plan is for display; apply always re-plans from what
|
|
24954
|
+
* is stored.
|
|
24955
|
+
*/
|
|
24956
|
+
shares: LoadBalancingSharesInputSchema.optional()
|
|
24957
|
+
});
|
|
24958
|
+
var AutoTunePlanSchema = object({
|
|
24959
|
+
/** Hash of everything the apply will write — the apply refuses a different one. */
|
|
24960
|
+
planHash: string(),
|
|
24961
|
+
family: literal("yolov9"),
|
|
24962
|
+
headroom: number(),
|
|
24963
|
+
/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
|
|
24964
|
+
whatIf: boolean(),
|
|
24965
|
+
generatedAt: number(),
|
|
24966
|
+
nodes: array(NodeRecommendationSchema).readonly(),
|
|
24967
|
+
nodeChanges: array(NodeDeviceChangeSchema).readonly(),
|
|
24968
|
+
cameraClears: array(CameraOverrideClearSchema).readonly(),
|
|
24969
|
+
detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
|
|
24970
|
+
warnings: array(AutoTuneWarningSchema).readonly()
|
|
24971
|
+
});
|
|
24972
|
+
var AutoTuneApplyInputSchema = object({
|
|
24973
|
+
planHash: string(),
|
|
24974
|
+
headroom: number().min(.3).max(.5).default(.4)
|
|
24975
|
+
});
|
|
24976
|
+
var AutoTunePhaseResultSchema = object({
|
|
24977
|
+
phase: _enum([
|
|
24978
|
+
"download",
|
|
24979
|
+
"camera-overrides",
|
|
24980
|
+
"detector-thresholds",
|
|
24981
|
+
"node-models",
|
|
24982
|
+
"redispatch"
|
|
24983
|
+
]),
|
|
24984
|
+
ok: boolean(),
|
|
24985
|
+
detail: string()
|
|
24986
|
+
});
|
|
24987
|
+
var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
|
|
24988
|
+
object({
|
|
24989
|
+
kind: literal("applied"),
|
|
24990
|
+
planHash: string(),
|
|
24991
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24992
|
+
}),
|
|
24993
|
+
object({
|
|
24994
|
+
kind: literal("aborted"),
|
|
24995
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24996
|
+
}),
|
|
24997
|
+
object({
|
|
24998
|
+
kind: literal("stale"),
|
|
24999
|
+
plan: AutoTunePlanSchema
|
|
25000
|
+
}),
|
|
25001
|
+
object({
|
|
25002
|
+
kind: literal("refused"),
|
|
25003
|
+
reason: _enum(["apply-in-progress"])
|
|
25004
|
+
})
|
|
25005
|
+
]);
|
|
24536
25006
|
object({
|
|
24537
25007
|
activeCameras: number(),
|
|
24538
25008
|
throttledCameras: number(),
|
|
@@ -25713,7 +26183,6 @@ var CameraStepOverridePatchSchema = object({
|
|
|
25713
26183
|
settings: record(string(), unknown()).readonly().optional()
|
|
25714
26184
|
});
|
|
25715
26185
|
var CameraPipelineSettingsSchema = object({
|
|
25716
|
-
pinnedAgentNodeId: string().optional(),
|
|
25717
26186
|
stepToggles: record(string(), boolean()).optional(),
|
|
25718
26187
|
stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
|
|
25719
26188
|
pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
|
|
@@ -26212,12 +26681,6 @@ method(object({
|
|
|
26212
26681
|
}), object({ success: literal(true) }), {
|
|
26213
26682
|
kind: "mutation",
|
|
26214
26683
|
auth: "admin"
|
|
26215
|
-
}), method(object({
|
|
26216
|
-
agentNodeId: string(),
|
|
26217
|
-
detectWeight: number().positive().nullable()
|
|
26218
|
-
}), object({ success: literal(true) }), {
|
|
26219
|
-
kind: "mutation",
|
|
26220
|
-
auth: "admin"
|
|
26221
26684
|
}), method(object({
|
|
26222
26685
|
agentNodeId: string(),
|
|
26223
26686
|
detect: boolean().nullable().optional(),
|
|
@@ -26259,6 +26722,15 @@ method(object({
|
|
|
26259
26722
|
}), {
|
|
26260
26723
|
kind: "mutation",
|
|
26261
26724
|
auth: "admin"
|
|
26725
|
+
}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
|
|
26726
|
+
kind: "mutation",
|
|
26727
|
+
auth: "admin"
|
|
26728
|
+
}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
|
|
26729
|
+
kind: "mutation",
|
|
26730
|
+
auth: "admin"
|
|
26731
|
+
}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
|
|
26732
|
+
kind: "mutation",
|
|
26733
|
+
auth: "admin"
|
|
26262
26734
|
}), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
|
|
26263
26735
|
deviceId: number(),
|
|
26264
26736
|
addonId: string(),
|
|
@@ -29062,6 +29534,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
|
|
|
29062
29534
|
*/
|
|
29063
29535
|
alive: boolean()
|
|
29064
29536
|
})), method(object({
|
|
29537
|
+
deviceId: number().int().nonnegative(),
|
|
29538
|
+
sessionId: string(),
|
|
29539
|
+
downlinkMbps: number().nonnegative()
|
|
29540
|
+
}), object({
|
|
29541
|
+
outcome: _enum(["switching", "held"]),
|
|
29542
|
+
tier: CamProfileSchema.nullable(),
|
|
29543
|
+
reason: string()
|
|
29544
|
+
}), { kind: "mutation" }), method(object({
|
|
29065
29545
|
deviceId: number().int().nonnegative(),
|
|
29066
29546
|
sessionId: string()
|
|
29067
29547
|
}), WebrtcSessionDebugSchema, { kind: "query" });
|
|
@@ -31773,7 +32253,8 @@ var ConnectionEndpointSchema = object({
|
|
|
31773
32253
|
"lan-ipv6",
|
|
31774
32254
|
"public",
|
|
31775
32255
|
"loopback",
|
|
31776
|
-
"app-link"
|
|
32256
|
+
"app-link",
|
|
32257
|
+
"custom"
|
|
31777
32258
|
]),
|
|
31778
32259
|
/**
|
|
31779
32260
|
* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
|
|
@@ -31842,7 +32323,7 @@ var GetConnectionEndpointsResultSchema = object({
|
|
|
31842
32323
|
localPort: AdvertisedLocalPortSchema
|
|
31843
32324
|
});
|
|
31844
32325
|
/**
|
|
31845
|
-
* The address flagged for notification
|
|
32326
|
+
* The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
|
|
31846
32327
|
* since D709 is the CamStack app link; `resolved` reports the effective value,
|
|
31847
32328
|
* so the UI can show it either way.
|
|
31848
32329
|
*/
|
|
@@ -31876,13 +32357,12 @@ var ViewerEndpointsSchema = object({
|
|
|
31876
32357
|
resolved: array(string()).readonly()
|
|
31877
32358
|
});
|
|
31878
32359
|
/**
|
|
31879
|
-
*
|
|
31880
|
-
*
|
|
32360
|
+
* DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
|
|
32361
|
+
* for addons built against it): `cluster` is the `internal` role, `browser`
|
|
32362
|
+
* the `publicEndpoint` role; `override` is the flagged address.
|
|
31881
32363
|
*/
|
|
31882
32364
|
var HubAddressSnapshotSchema = object({
|
|
31883
|
-
/** The operator's override, or null for automatic. */
|
|
31884
32365
|
override: string().nullable(),
|
|
31885
|
-
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
31886
32366
|
resolved: string().nullable(),
|
|
31887
32367
|
source: _enum([
|
|
31888
32368
|
"override",
|
|
@@ -31891,11 +32371,57 @@ var HubAddressSnapshotSchema = object({
|
|
|
31891
32371
|
])
|
|
31892
32372
|
});
|
|
31893
32373
|
var HubAddressesSchema = object({
|
|
31894
|
-
/** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
|
|
31895
32374
|
cluster: HubAddressSnapshotSchema,
|
|
31896
|
-
/** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
|
|
31897
32375
|
browser: HubAddressSnapshotSchema
|
|
31898
32376
|
});
|
|
32377
|
+
/**
|
|
32378
|
+
* What an address is used for (`hub-address.ts`, D734). `appConnections` is
|
|
32379
|
+
* many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
|
|
32380
|
+
* by at most one address.
|
|
32381
|
+
*/
|
|
32382
|
+
var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
|
|
32383
|
+
var RoleSourceSchema = _enum([
|
|
32384
|
+
"flagged",
|
|
32385
|
+
"auto",
|
|
32386
|
+
"none"
|
|
32387
|
+
]);
|
|
32388
|
+
/** One single-valued role: the flagged address, the one in use, and why. */
|
|
32389
|
+
var HubAddressRoleResolutionSchema = object({
|
|
32390
|
+
/** The address carrying the flag, or null = automatic. */
|
|
32391
|
+
flagged: string().nullable(),
|
|
32392
|
+
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
32393
|
+
resolved: string().nullable(),
|
|
32394
|
+
source: RoleSourceSchema
|
|
32395
|
+
});
|
|
32396
|
+
var HubAppConnectionsResolutionSchema = object({
|
|
32397
|
+
/** The addresses flagged `appConnections`, or empty = automatic. */
|
|
32398
|
+
flagged: array(string()).readonly(),
|
|
32399
|
+
/** What the apps race right now. */
|
|
32400
|
+
resolved: array(string()).readonly(),
|
|
32401
|
+
source: RoleSourceSchema
|
|
32402
|
+
});
|
|
32403
|
+
var HubAddressBookSchema = object({
|
|
32404
|
+
rows: array(ConnectionEndpointSchema.extend({
|
|
32405
|
+
/** In the hub's detected palette right now. */
|
|
32406
|
+
detected: boolean(),
|
|
32407
|
+
/** Entered by the operator (removable). */
|
|
32408
|
+
custom: boolean(),
|
|
32409
|
+
/** The roles explicitly flagged on this address. */
|
|
32410
|
+
flags: array(HubAddressRoleSchema).readonly(),
|
|
32411
|
+
/** The roles this address serves right now — flagged or automatic. */
|
|
32412
|
+
inUse: array(HubAddressRoleSchema).readonly(),
|
|
32413
|
+
/** The roles this address may be flagged with. */
|
|
32414
|
+
eligible: array(HubAddressRoleSchema).readonly()
|
|
32415
|
+
})).readonly(),
|
|
32416
|
+
roles: object({
|
|
32417
|
+
appConnections: HubAppConnectionsResolutionSchema,
|
|
32418
|
+
notificationTaps: HubAddressRoleResolutionSchema,
|
|
32419
|
+
internal: HubAddressRoleResolutionSchema,
|
|
32420
|
+
publicEndpoint: HubAddressRoleResolutionSchema
|
|
32421
|
+
}),
|
|
32422
|
+
/** The `hub=` an app link carries (D709), or null. */
|
|
32423
|
+
appLinkHub: string().nullable()
|
|
32424
|
+
});
|
|
31899
32425
|
var AllowedAddressesSchema = object({
|
|
31900
32426
|
/**
|
|
31901
32427
|
* Allowlist of interface addresses operators have explicitly opted
|
|
@@ -31939,16 +32465,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
|
|
|
31939
32465
|
* tunnel always emits `https://` regardless. */
|
|
31940
32466
|
scheme: _enum(["http", "https"]).optional(),
|
|
31941
32467
|
/** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
|
|
31942
|
-
* an address notification
|
|
32468
|
+
* an address notification taps can be flagged with, not a hub
|
|
31943
32469
|
* route. Default `false`: racers and rankers never see it. */
|
|
31944
32470
|
includeAppLink: boolean().optional()
|
|
31945
|
-
}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(
|
|
31946
|
-
|
|
31947
|
-
|
|
31948
|
-
}),
|
|
32471
|
+
}), 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({
|
|
32472
|
+
baseUrl: string(),
|
|
32473
|
+
label: string().max(80)
|
|
32474
|
+
}), HubAddressBookSchema, {
|
|
31949
32475
|
kind: "mutation",
|
|
31950
32476
|
auth: "admin"
|
|
31951
|
-
}), method(
|
|
32477
|
+
}), method(object({ baseUrl: string() }), HubAddressBookSchema, {
|
|
32478
|
+
kind: "mutation",
|
|
32479
|
+
auth: "admin"
|
|
32480
|
+
}), method(object({
|
|
32481
|
+
role: HubAddressRoleSchema,
|
|
32482
|
+
baseUrl: string().nullable(),
|
|
32483
|
+
enabled: boolean(),
|
|
32484
|
+
acceptInsecureHttp: boolean().optional()
|
|
32485
|
+
}), HubAddressBookSchema, {
|
|
32486
|
+
kind: "mutation",
|
|
32487
|
+
auth: "admin"
|
|
32488
|
+
}), method(_void(), HubAddressesSchema), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
|
|
31952
32489
|
kind: "mutation",
|
|
31953
32490
|
auth: "admin"
|
|
31954
32491
|
}), method(object({
|
|
@@ -37495,6 +38032,16 @@ DeviceType.Camera, method(object({
|
|
|
37495
38032
|
package: array(ZoneRuleSchema).readonly()
|
|
37496
38033
|
});
|
|
37497
38034
|
SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
|
|
38035
|
+
Object.freeze({
|
|
38036
|
+
person: .5,
|
|
38037
|
+
vehicle: .5,
|
|
38038
|
+
animal: .5
|
|
38039
|
+
});
|
|
38040
|
+
Object.freeze({
|
|
38041
|
+
person: .65,
|
|
38042
|
+
vehicle: .65,
|
|
38043
|
+
animal: .65
|
|
38044
|
+
});
|
|
37498
38045
|
/**
|
|
37499
38046
|
* Accessory device helpers — shared across drivers.
|
|
37500
38047
|
*
|
|
@@ -40423,12 +40970,24 @@ Object.freeze({
|
|
|
40423
40970
|
addonId: null,
|
|
40424
40971
|
access: "view"
|
|
40425
40972
|
},
|
|
40973
|
+
"localNetwork.addCustomAddress": {
|
|
40974
|
+
capName: "local-network",
|
|
40975
|
+
capScope: "system",
|
|
40976
|
+
addonId: null,
|
|
40977
|
+
access: "create"
|
|
40978
|
+
},
|
|
40426
40979
|
"localNetwork.downloadCa": {
|
|
40427
40980
|
capName: "local-network",
|
|
40428
40981
|
capScope: "system",
|
|
40429
40982
|
addonId: null,
|
|
40430
40983
|
access: "view"
|
|
40431
40984
|
},
|
|
40985
|
+
"localNetwork.getAddresses": {
|
|
40986
|
+
capName: "local-network",
|
|
40987
|
+
capScope: "system",
|
|
40988
|
+
addonId: null,
|
|
40989
|
+
access: "view"
|
|
40990
|
+
},
|
|
40432
40991
|
"localNetwork.getAllowedAddresses": {
|
|
40433
40992
|
capName: "local-network",
|
|
40434
40993
|
capScope: "system",
|
|
@@ -40483,6 +41042,12 @@ Object.freeze({
|
|
|
40483
41042
|
addonId: null,
|
|
40484
41043
|
access: "create"
|
|
40485
41044
|
},
|
|
41045
|
+
"localNetwork.removeCustomAddress": {
|
|
41046
|
+
capName: "local-network",
|
|
41047
|
+
capScope: "system",
|
|
41048
|
+
addonId: null,
|
|
41049
|
+
access: "delete"
|
|
41050
|
+
},
|
|
40486
41051
|
"localNetwork.resetAllowlistToBestMatch": {
|
|
40487
41052
|
capName: "local-network",
|
|
40488
41053
|
capScope: "system",
|
|
@@ -40495,13 +41060,13 @@ Object.freeze({
|
|
|
40495
41060
|
addonId: null,
|
|
40496
41061
|
access: "create"
|
|
40497
41062
|
},
|
|
40498
|
-
"localNetwork.
|
|
41063
|
+
"localNetwork.setAddressRole": {
|
|
40499
41064
|
capName: "local-network",
|
|
40500
41065
|
capScope: "system",
|
|
40501
41066
|
addonId: null,
|
|
40502
41067
|
access: "create"
|
|
40503
41068
|
},
|
|
40504
|
-
"localNetwork.
|
|
41069
|
+
"localNetwork.setAllowedAddresses": {
|
|
40505
41070
|
capName: "local-network",
|
|
40506
41071
|
capScope: "system",
|
|
40507
41072
|
addonId: null,
|
|
@@ -41995,6 +42560,12 @@ Object.freeze({
|
|
|
41995
42560
|
addonId: null,
|
|
41996
42561
|
access: "delete"
|
|
41997
42562
|
},
|
|
42563
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": {
|
|
42564
|
+
capName: "pipeline-executor",
|
|
42565
|
+
capScope: "system",
|
|
42566
|
+
addonId: null,
|
|
42567
|
+
access: "delete"
|
|
42568
|
+
},
|
|
41998
42569
|
"pipelineExecutor.deleteModel": {
|
|
41999
42570
|
capName: "pipeline-executor",
|
|
42000
42571
|
capScope: "system",
|
|
@@ -42211,6 +42782,12 @@ Object.freeze({
|
|
|
42211
42782
|
addonId: null,
|
|
42212
42783
|
access: "view"
|
|
42213
42784
|
},
|
|
42785
|
+
"pipelineOrchestrator.applyAutoTune": {
|
|
42786
|
+
capName: "pipeline-orchestrator",
|
|
42787
|
+
capScope: "system",
|
|
42788
|
+
addonId: null,
|
|
42789
|
+
access: "create"
|
|
42790
|
+
},
|
|
42214
42791
|
"pipelineOrchestrator.applyDeviceSettingsPatch": {
|
|
42215
42792
|
capName: "pipeline-orchestrator",
|
|
42216
42793
|
capScope: "system",
|
|
@@ -42325,6 +42902,12 @@ Object.freeze({
|
|
|
42325
42902
|
addonId: null,
|
|
42326
42903
|
access: "view"
|
|
42327
42904
|
},
|
|
42905
|
+
"pipelineOrchestrator.getEffectiveShares": {
|
|
42906
|
+
capName: "pipeline-orchestrator",
|
|
42907
|
+
capScope: "system",
|
|
42908
|
+
addonId: null,
|
|
42909
|
+
access: "view"
|
|
42910
|
+
},
|
|
42328
42911
|
"pipelineOrchestrator.getGlobalMetrics": {
|
|
42329
42912
|
capName: "pipeline-orchestrator",
|
|
42330
42913
|
capScope: "system",
|
|
@@ -42361,6 +42944,12 @@ Object.freeze({
|
|
|
42361
42944
|
addonId: null,
|
|
42362
42945
|
access: "view"
|
|
42363
42946
|
},
|
|
42947
|
+
"pipelineOrchestrator.getPlacementStats": {
|
|
42948
|
+
capName: "pipeline-orchestrator",
|
|
42949
|
+
capScope: "system",
|
|
42950
|
+
addonId: null,
|
|
42951
|
+
access: "view"
|
|
42952
|
+
},
|
|
42364
42953
|
"pipelineOrchestrator.getReconcileFromDiskStatus": {
|
|
42365
42954
|
capName: "pipeline-orchestrator",
|
|
42366
42955
|
capScope: "system",
|
|
@@ -42385,6 +42974,12 @@ Object.freeze({
|
|
|
42385
42974
|
addonId: null,
|
|
42386
42975
|
access: "create"
|
|
42387
42976
|
},
|
|
42977
|
+
"pipelineOrchestrator.planAutoTune": {
|
|
42978
|
+
capName: "pipeline-orchestrator",
|
|
42979
|
+
capScope: "system",
|
|
42980
|
+
addonId: null,
|
|
42981
|
+
access: "view"
|
|
42982
|
+
},
|
|
42388
42983
|
"pipelineOrchestrator.rebalance": {
|
|
42389
42984
|
capName: "pipeline-orchestrator",
|
|
42390
42985
|
capScope: "system",
|
|
@@ -42445,12 +43040,6 @@ Object.freeze({
|
|
|
42445
43040
|
addonId: null,
|
|
42446
43041
|
access: "create"
|
|
42447
43042
|
},
|
|
42448
|
-
"pipelineOrchestrator.setAgentDetectWeight": {
|
|
42449
|
-
capName: "pipeline-orchestrator",
|
|
42450
|
-
capScope: "system",
|
|
42451
|
-
addonId: null,
|
|
42452
|
-
access: "create"
|
|
42453
|
-
},
|
|
42454
43043
|
"pipelineOrchestrator.setAgentInferenceDevices": {
|
|
42455
43044
|
capName: "pipeline-orchestrator",
|
|
42456
43045
|
capScope: "system",
|
|
@@ -42505,12 +43094,30 @@ Object.freeze({
|
|
|
42505
43094
|
addonId: null,
|
|
42506
43095
|
access: "create"
|
|
42507
43096
|
},
|
|
43097
|
+
"pipelineOrchestrator.setLoadBalancingShares": {
|
|
43098
|
+
capName: "pipeline-orchestrator",
|
|
43099
|
+
capScope: "system",
|
|
43100
|
+
addonId: null,
|
|
43101
|
+
access: "create"
|
|
43102
|
+
},
|
|
42508
43103
|
"pipelineOrchestrator.setPipelineDevicePin": {
|
|
42509
43104
|
capName: "pipeline-orchestrator",
|
|
42510
43105
|
capScope: "system",
|
|
42511
43106
|
addonId: null,
|
|
42512
43107
|
access: "create"
|
|
42513
43108
|
},
|
|
43109
|
+
"pipelineOrchestrator.setShareSource": {
|
|
43110
|
+
capName: "pipeline-orchestrator",
|
|
43111
|
+
capScope: "system",
|
|
43112
|
+
addonId: null,
|
|
43113
|
+
access: "create"
|
|
43114
|
+
},
|
|
43115
|
+
"pipelineOrchestrator.suggestShares": {
|
|
43116
|
+
capName: "pipeline-orchestrator",
|
|
43117
|
+
capScope: "system",
|
|
43118
|
+
addonId: null,
|
|
43119
|
+
access: "view"
|
|
43120
|
+
},
|
|
42514
43121
|
"pipelineOrchestrator.unassignAudio": {
|
|
42515
43122
|
capName: "pipeline-orchestrator",
|
|
42516
43123
|
capScope: "system",
|
|
@@ -44755,6 +45362,12 @@ Object.freeze({
|
|
|
44755
45362
|
addonId: null,
|
|
44756
45363
|
access: "create"
|
|
44757
45364
|
},
|
|
45365
|
+
"webrtcSession.applyDownlinkProbe": {
|
|
45366
|
+
capName: "webrtc-session",
|
|
45367
|
+
capScope: "device",
|
|
45368
|
+
addonId: null,
|
|
45369
|
+
access: "create"
|
|
45370
|
+
},
|
|
44758
45371
|
"webrtcSession.closeSession": {
|
|
44759
45372
|
capName: "webrtc-session",
|
|
44760
45373
|
capScope: "device",
|
|
@@ -47801,6 +48414,11 @@ Object.freeze({
|
|
|
47801
48414
|
form: "single",
|
|
47802
48415
|
optional: false
|
|
47803
48416
|
}],
|
|
48417
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": [{
|
|
48418
|
+
name: "deviceIds",
|
|
48419
|
+
form: "array",
|
|
48420
|
+
optional: true
|
|
48421
|
+
}],
|
|
47804
48422
|
"pipelineExecutor.runPipeline": [{
|
|
47805
48423
|
name: "deviceId",
|
|
47806
48424
|
form: "single",
|
|
@@ -48677,6 +49295,11 @@ Object.freeze({
|
|
|
48677
49295
|
form: "single",
|
|
48678
49296
|
optional: false
|
|
48679
49297
|
}],
|
|
49298
|
+
"webrtcSession.applyDownlinkProbe": [{
|
|
49299
|
+
name: "deviceId",
|
|
49300
|
+
form: "single",
|
|
49301
|
+
optional: false
|
|
49302
|
+
}],
|
|
48680
49303
|
"webrtcSession.closeSession": [{
|
|
48681
49304
|
name: "deviceId",
|
|
48682
49305
|
form: "single",
|
|
@@ -116152,7 +116775,6 @@ var HAP_STREAM_PREFERENCE_OPTIONS = [
|
|
|
116152
116775
|
];
|
|
116153
116776
|
var DEFAULT_CONFIG = {
|
|
116154
116777
|
bridgeName: "CamStack Bridge",
|
|
116155
|
-
port: 0,
|
|
116156
116778
|
fixedPin: "",
|
|
116157
116779
|
interfaceName: "",
|
|
116158
116780
|
ptzPulseMs: 400,
|
|
@@ -116829,20 +117451,11 @@ var ExportHapAddon = class extends BaseAddon {
|
|
|
116829
117451
|
type: "text",
|
|
116830
117452
|
key: "bridgeName",
|
|
116831
117453
|
label: "Installation name",
|
|
116832
|
-
description: "
|
|
117454
|
+
description: "The name of the shared bridge that carries every exposed device that is not a camera (switches, sensors, locks, alarm panels) — what iOS Home lists under Add Accessory. Cameras are never bridged: each one is published as its own accessory under its device name. Set it before you add the bridge in iOS Home.",
|
|
116833
117455
|
default: DEFAULT_CONFIG.bridgeName,
|
|
116834
117456
|
requiresRestart: true,
|
|
116835
117457
|
placement: { tab: "advanced" }
|
|
116836
117458
|
}),
|
|
116837
|
-
this.field({
|
|
116838
|
-
type: "number",
|
|
116839
|
-
key: "port",
|
|
116840
|
-
label: "HAP port",
|
|
116841
|
-
description: "Local port for the HAP server. 0 = random ephemeral port (recommended).",
|
|
116842
|
-
default: DEFAULT_CONFIG.port,
|
|
116843
|
-
requiresRestart: true,
|
|
116844
|
-
placement: { tab: "advanced" }
|
|
116845
|
-
}),
|
|
116846
117459
|
this.field({
|
|
116847
117460
|
type: "text",
|
|
116848
117461
|
key: "fixedPin",
|