@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
|
@@ -5418,7 +5418,7 @@ var ZodIssueCode = {
|
|
|
5418
5418
|
var ZodFirstPartyTypeKind;
|
|
5419
5419
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5420
5420
|
//#endregion
|
|
5421
|
-
//#region ../types/dist/sleep-
|
|
5421
|
+
//#region ../types/dist/sleep-C16NCZR2.mjs
|
|
5422
5422
|
/**
|
|
5423
5423
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5424
5424
|
* window to float samples (D455).
|
|
@@ -11386,7 +11386,18 @@ var LABEL_SUPPLY_STEP_IDS = [
|
|
|
11386
11386
|
];
|
|
11387
11387
|
/** Steps whose box a root detection can BE. */
|
|
11388
11388
|
var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
|
|
11389
|
-
|
|
11389
|
+
/**
|
|
11390
|
+
* Steps whose per-detection MASK a root detection can carry (D737). The live
|
|
11391
|
+
* mask step is `segmentation` — a frame-plane refiner that runs its own model
|
|
11392
|
+
* once per detection crop. (`instance-segmentation` is a dormant step id that
|
|
11393
|
+
* no camera tree carries.)
|
|
11394
|
+
*/
|
|
11395
|
+
var MASK_SUPPLY_STEP_IDS = ["segmentation"];
|
|
11396
|
+
[
|
|
11397
|
+
...LABEL_SUPPLY_STEP_IDS,
|
|
11398
|
+
...CROP_SUPPLY_STEP_IDS,
|
|
11399
|
+
...MASK_SUPPLY_STEP_IDS
|
|
11400
|
+
];
|
|
11390
11401
|
var MODEL_FORMATS = [
|
|
11391
11402
|
"onnx",
|
|
11392
11403
|
"coreml",
|
|
@@ -11415,7 +11426,53 @@ var ModelFormatEntrySchema = object({
|
|
|
11415
11426
|
/** Multi-file payload (directory members or sibling files). */
|
|
11416
11427
|
files: array(string()).readonly().optional(),
|
|
11417
11428
|
/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
|
|
11418
|
-
runtimes: array(_enum(["python"])).readonly().optional()
|
|
11429
|
+
runtimes: array(_enum(["python"])).readonly().optional(),
|
|
11430
|
+
/**
|
|
11431
|
+
* Content revision of the artefact, for one hosted OFF the CamStack mirror.
|
|
11432
|
+
* A format on the mirror leaves it unset: its revision (the sha256 of its
|
|
11433
|
+
* weight file) comes from the downloader's generated table, kept in step
|
|
11434
|
+
* with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
|
|
11435
|
+
* node records the revision it downloaded next to the file
|
|
11436
|
+
* (`<file>.revision`); a copy with no record or a different one is stale
|
|
11437
|
+
* unless its weight file hashes to the revision, and a stale copy is
|
|
11438
|
+
* downloaded again, the old one serving until the new one is complete. No
|
|
11439
|
+
* revision at all ⇒ a file on disk is current, whatever it holds (D743).
|
|
11440
|
+
*/
|
|
11441
|
+
revision: string().min(1).optional()
|
|
11442
|
+
});
|
|
11443
|
+
/**
|
|
11444
|
+
* What a node holds for one (model, format) (D746). `current` is a complete
|
|
11445
|
+
* copy at its catalog revision — exactly what `downloaded: true` means.
|
|
11446
|
+
* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
|
|
11447
|
+
* no or a different revision record, or a missing sibling. `missing` is no
|
|
11448
|
+
* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
|
|
11449
|
+
* reclaimable bytes and a copy about to be replaced.
|
|
11450
|
+
*/
|
|
11451
|
+
var ModelOnDiskStateSchema = _enum([
|
|
11452
|
+
"current",
|
|
11453
|
+
"stale",
|
|
11454
|
+
"missing"
|
|
11455
|
+
]);
|
|
11456
|
+
/**
|
|
11457
|
+
* The numeric precision of one format's BUILD (D746) — reported only when the
|
|
11458
|
+
* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
|
|
11459
|
+
* CamStack Core ML export). Absent means "not stated", never "fp32".
|
|
11460
|
+
*/
|
|
11461
|
+
var ModelFormatPrecisionSchema = _enum([
|
|
11462
|
+
"fp32",
|
|
11463
|
+
"fp16",
|
|
11464
|
+
"int8"
|
|
11465
|
+
]);
|
|
11466
|
+
/**
|
|
11467
|
+
* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
|
|
11468
|
+
* `onDisk` / `precision` are optional for version skew: a runner that predates
|
|
11469
|
+
* them omits them, and a reader falls back to `downloaded`.
|
|
11470
|
+
*/
|
|
11471
|
+
var PipelineModelFormatStatusSchema = object({
|
|
11472
|
+
downloaded: boolean(),
|
|
11473
|
+
sizeMB: number(),
|
|
11474
|
+
onDisk: ModelOnDiskStateSchema.optional(),
|
|
11475
|
+
precision: ModelFormatPrecisionSchema.optional()
|
|
11419
11476
|
});
|
|
11420
11477
|
/**
|
|
11421
11478
|
* Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
|
|
@@ -11529,25 +11586,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
|
|
|
11529
11586
|
* - `crop`: the root draws the box the step would have found (`license_plate`
|
|
11530
11587
|
* for plate-detection, `face` for face-detection). The box becomes a detail
|
|
11531
11588
|
* child of the `parentMacro` detection that contains it — never a track.
|
|
11589
|
+
* - `mask`: the root's decode emits an instance mask with every detection (a
|
|
11590
|
+
* YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
|
|
11591
|
+
* detection in the shape that step produces. Derived from the model's
|
|
11592
|
+
* postprocessor on read, never stored by an import.
|
|
11532
11593
|
*/
|
|
11533
|
-
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
11534
|
-
|
|
11535
|
-
|
|
11536
|
-
|
|
11537
|
-
|
|
11538
|
-
|
|
11539
|
-
|
|
11540
|
-
|
|
11541
|
-
|
|
11542
|
-
|
|
11543
|
-
|
|
11544
|
-
|
|
11545
|
-
|
|
11546
|
-
|
|
11547
|
-
|
|
11548
|
-
|
|
11549
|
-
|
|
11550
|
-
|
|
11594
|
+
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
11595
|
+
object({
|
|
11596
|
+
kind: literal("label"),
|
|
11597
|
+
stepId: _enum(LABEL_SUPPLY_STEP_IDS),
|
|
11598
|
+
labelToEffect: record(string(), string()),
|
|
11599
|
+
uncovered: array(string()).readonly()
|
|
11600
|
+
}),
|
|
11601
|
+
object({
|
|
11602
|
+
kind: literal("crop"),
|
|
11603
|
+
stepId: _enum(CROP_SUPPLY_STEP_IDS),
|
|
11604
|
+
rootLabels: array(string()).readonly(),
|
|
11605
|
+
parentMacro: _enum(["vehicle", "person"]),
|
|
11606
|
+
childClass: _enum(["plate", "face"]),
|
|
11607
|
+
/**
|
|
11608
|
+
* The root's smaller input side, stamped on read by `rootSuppliesOf` from
|
|
11609
|
+
* the model entry — what a step's `minRootInputPx` gate judges. Never
|
|
11610
|
+
* stored by an import.
|
|
11611
|
+
*/
|
|
11612
|
+
rootInputPx: number().int().positive().optional()
|
|
11613
|
+
}),
|
|
11614
|
+
object({
|
|
11615
|
+
kind: literal("mask"),
|
|
11616
|
+
stepId: _enum(MASK_SUPPLY_STEP_IDS)
|
|
11617
|
+
})
|
|
11618
|
+
]);
|
|
11551
11619
|
var ModelCatalogEntrySchema = object({
|
|
11552
11620
|
id: string(),
|
|
11553
11621
|
name: string(),
|
|
@@ -11613,6 +11681,35 @@ var ModelCatalogEntrySchema = object({
|
|
|
11613
11681
|
*/
|
|
11614
11682
|
defaultConfidence: number().min(0).max(1).optional(),
|
|
11615
11683
|
/**
|
|
11684
|
+
* Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
|
|
11685
|
+
* on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
|
|
11686
|
+
* absent here runs at the step slider's global default. The same row shape
|
|
11687
|
+
* the floor measurement produces (`model-floors.json`: modelId → floors), so
|
|
11688
|
+
* a measured table is copied in as-is. An operator override is bound to the
|
|
11689
|
+
* model it was made for and does not survive a model change (D738). A custom
|
|
11690
|
+
* / imported model may declare it; without it, the global defaults apply.
|
|
11691
|
+
*/
|
|
11692
|
+
defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11693
|
+
/**
|
|
11694
|
+
* The inference precision this model's OpenVINO IR needs on an Intel GPU.
|
|
11695
|
+
* Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
|
|
11696
|
+
* that produces invalid output at f16 — measured 2026-10-07 for YOLO26
|
|
11697
|
+
* base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
|
|
11698
|
+
* scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
|
|
11699
|
+
* `PoolModelConfig.gpuInferencePrecision`; the pool sets
|
|
11700
|
+
* INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
|
|
11701
|
+
*/
|
|
11702
|
+
gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
|
|
11703
|
+
/**
|
|
11704
|
+
* ROOT detectors only: per supplied step (`animal-classifier`, …), the
|
|
11705
|
+
* minimum DETECTION score from which this root's own fine label (species,
|
|
11706
|
+
* vehicle type — D736 root supply) is taken (D741). Below it the detection
|
|
11707
|
+
* keeps its macro class without the fine label. `1` = never take it from
|
|
11708
|
+
* this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
|
|
11709
|
+
* `minConfidence` slider, bound to the ROOT model, overrides it.
|
|
11710
|
+
*/
|
|
11711
|
+
suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11712
|
+
/**
|
|
11616
11713
|
* When true, the executor produces a landmark-aligned crop (similarity warp
|
|
11617
11714
|
* onto the canonical template) before this step runs, instead of a plain
|
|
11618
11715
|
* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
|
|
@@ -16923,6 +17020,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
|
|
|
16923
17020
|
kind: "mutation",
|
|
16924
17021
|
auth: "admin"
|
|
16925
17022
|
});
|
|
17023
|
+
var HUB_ADDRESS_ROLES = [
|
|
17024
|
+
"appConnections",
|
|
17025
|
+
"notificationTaps",
|
|
17026
|
+
"internal",
|
|
17027
|
+
"publicEndpoint"
|
|
17028
|
+
];
|
|
16926
17029
|
/**
|
|
16927
17030
|
* Transport bounds for AI capability methods.
|
|
16928
17031
|
*
|
|
@@ -21094,7 +21197,13 @@ var NcAlarmModeDelaysListSchema = array(object({
|
|
|
21094
21197
|
* Absent = false (logged, not sent). Even when true it is not sent when that same sensor
|
|
21095
21198
|
* is the one that starts the entry delay — the entry-delay notification already names it.
|
|
21096
21199
|
*/
|
|
21097
|
-
notifySensorRewatched: boolean().optional()
|
|
21200
|
+
notifySensorRewatched: boolean().optional(),
|
|
21201
|
+
/**
|
|
21202
|
+
* D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
|
|
21203
|
+
* change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
|
|
21204
|
+
* re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
|
|
21205
|
+
*/
|
|
21206
|
+
notifySensorIgnored: boolean().optional()
|
|
21098
21207
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
|
|
21099
21208
|
var NcAlarmModeDelaysEditListSchema = array(object({
|
|
21100
21209
|
mode: AlarmArmModeSchema,
|
|
@@ -21107,7 +21216,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
|
|
|
21107
21216
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21108
21217
|
notifyDuringEntryDelay: boolean().nullable().optional(),
|
|
21109
21218
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21110
|
-
notifySensorRewatched: boolean().nullable().optional()
|
|
21219
|
+
notifySensorRewatched: boolean().nullable().optional(),
|
|
21220
|
+
/** D735: set the switch, or `null` to clear it (back to the default, false). */
|
|
21221
|
+
notifySensorIgnored: boolean().nullable().optional()
|
|
21111
21222
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
|
|
21112
21223
|
/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
|
|
21113
21224
|
var NcAlarmNonBlockingEditSchema = object({
|
|
@@ -24081,7 +24192,7 @@ var FrameRefSchema = object({
|
|
|
24081
24192
|
timestamp: number(),
|
|
24082
24193
|
capturedAt: number().optional()
|
|
24083
24194
|
});
|
|
24084
|
-
var ModelFormatSchema$
|
|
24195
|
+
var ModelFormatSchema$2 = _enum([
|
|
24085
24196
|
"onnx",
|
|
24086
24197
|
"coreml",
|
|
24087
24198
|
"openvino",
|
|
@@ -24099,7 +24210,7 @@ var PipelineSlotSchema = _enum([
|
|
|
24099
24210
|
var PipelineEngineChoiceSchema = object({
|
|
24100
24211
|
runtime: literal("python"),
|
|
24101
24212
|
backend: string(),
|
|
24102
|
-
format: ModelFormatSchema$
|
|
24213
|
+
format: ModelFormatSchema$2,
|
|
24103
24214
|
device: string().optional()
|
|
24104
24215
|
});
|
|
24105
24216
|
/**
|
|
@@ -24156,10 +24267,7 @@ var PipelineTemplateSchema$1 = object({
|
|
|
24156
24267
|
var PipelineModelOptionSchema = object({
|
|
24157
24268
|
id: string(),
|
|
24158
24269
|
name: string(),
|
|
24159
|
-
formats: record(string(),
|
|
24160
|
-
downloaded: boolean(),
|
|
24161
|
-
sizeMB: number()
|
|
24162
|
-
})),
|
|
24270
|
+
formats: record(string(), PipelineModelFormatStatusSchema),
|
|
24163
24271
|
group: ModelVariantGroupSchema.optional(),
|
|
24164
24272
|
legacy: boolean().optional(),
|
|
24165
24273
|
provider: ModelProviderIdSchema.optional(),
|
|
@@ -24326,6 +24434,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24326
24434
|
}), {
|
|
24327
24435
|
kind: "mutation",
|
|
24328
24436
|
auth: "admin"
|
|
24437
|
+
}), method(object({
|
|
24438
|
+
nodeId: string(),
|
|
24439
|
+
deviceIds: array(number()).readonly().optional(),
|
|
24440
|
+
dryRun: boolean()
|
|
24441
|
+
}), object({
|
|
24442
|
+
entries: array(object({
|
|
24443
|
+
deviceId: number(),
|
|
24444
|
+
keys: array(string()).readonly()
|
|
24445
|
+
})).readonly(),
|
|
24446
|
+
refused: array(object({
|
|
24447
|
+
deviceId: number(),
|
|
24448
|
+
reason: string()
|
|
24449
|
+
})).readonly()
|
|
24450
|
+
}), {
|
|
24451
|
+
kind: "mutation",
|
|
24452
|
+
auth: "admin"
|
|
24329
24453
|
}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
|
|
24330
24454
|
/** `<backend>:<device>`, e.g. `openvino:gpu`. */
|
|
24331
24455
|
deviceKey: string(),
|
|
@@ -24362,11 +24486,11 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24362
24486
|
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24363
24487
|
addonId: string(),
|
|
24364
24488
|
modelId: string(),
|
|
24365
|
-
format: ModelFormatSchema$
|
|
24489
|
+
format: ModelFormatSchema$2
|
|
24366
24490
|
}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
|
|
24367
24491
|
addonId: string(),
|
|
24368
24492
|
modelId: string(),
|
|
24369
|
-
format: ModelFormatSchema$
|
|
24493
|
+
format: ModelFormatSchema$2
|
|
24370
24494
|
}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
|
|
24371
24495
|
steps: array(PipelineStepInputSchema).min(1),
|
|
24372
24496
|
frame: FrameInputSchema.optional(),
|
|
@@ -24523,6 +24647,352 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24523
24647
|
filename: string().optional(),
|
|
24524
24648
|
settings: record(string(), unknown()).optional()
|
|
24525
24649
|
}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
|
|
24650
|
+
/**
|
|
24651
|
+
* Wire shapes of the Load balancing surface (D748): the session placement
|
|
24652
|
+
* policy, the atomic share write, the observed placement statistics, the
|
|
24653
|
+
* hardware share suggestion and the stale device pins.
|
|
24654
|
+
*/
|
|
24655
|
+
/**
|
|
24656
|
+
* How a new detection session picks its node and device.
|
|
24657
|
+
* - `least-loaded` — the historical rule: lowest `attached / weight`, a
|
|
24658
|
+
* constant node order at a tie (D37). An idle node always ties at 0, so a
|
|
24659
|
+
* weight only bites once a node already holds a session.
|
|
24660
|
+
* - `share` — the share of PARALLEL sessions is held to the weights, and a
|
|
24661
|
+
* full or drowning node yields to a free one (D748).
|
|
24662
|
+
*/
|
|
24663
|
+
var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
|
|
24664
|
+
var LoadBalancingSharesInputSchema = object({
|
|
24665
|
+
/** nodeId → share (> 0). A node left out keeps its weight. */
|
|
24666
|
+
nodes: record(string(), number().positive()).default({}),
|
|
24667
|
+
/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
|
|
24668
|
+
devices: record(string(), record(string(), number().positive())).default({})
|
|
24669
|
+
});
|
|
24670
|
+
var PlacementStatsInputSchema = object({
|
|
24671
|
+
/** Window the observed shares are averaged over (default 1 h, max 24 h). */
|
|
24672
|
+
windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
|
|
24673
|
+
var PlacementDeviceStatsSchema = object({
|
|
24674
|
+
deviceKey: string(),
|
|
24675
|
+
/** Sessions running on this device now. */
|
|
24676
|
+
sessionsNow: number(),
|
|
24677
|
+
/** Sessions started on this device inside the window. */
|
|
24678
|
+
sessionsStarted: number(),
|
|
24679
|
+
/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
|
|
24680
|
+
observedShare: number().nullable()
|
|
24681
|
+
});
|
|
24682
|
+
var PlacementNodeStatsSchema = object({
|
|
24683
|
+
nodeId: string(),
|
|
24684
|
+
sessionsNow: number(),
|
|
24685
|
+
sessionsStarted: number(),
|
|
24686
|
+
/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
|
|
24687
|
+
observedShare: number().nullable(),
|
|
24688
|
+
/** Most sessions this node ran at once inside the window. */
|
|
24689
|
+
peakSessions: number(),
|
|
24690
|
+
/** Sessions a share election handed elsewhere because this node was full or drowning. */
|
|
24691
|
+
yieldsAway: number(),
|
|
24692
|
+
devices: array(PlacementDeviceStatsSchema).readonly()
|
|
24693
|
+
});
|
|
24694
|
+
/** A camera's device pin that the session path cannot honour. */
|
|
24695
|
+
var StaleDevicePinSchema = object({
|
|
24696
|
+
deviceId: number(),
|
|
24697
|
+
deviceKey: string(),
|
|
24698
|
+
/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
|
|
24699
|
+
reason: _enum(["disabled", "absent"])
|
|
24700
|
+
});
|
|
24701
|
+
var PlacementStatsSchema = object({
|
|
24702
|
+
policy: SessionPlacementPolicySchema,
|
|
24703
|
+
windowMs: number(),
|
|
24704
|
+
/** How much of the window was actually observed (the hub keeps it in memory). */
|
|
24705
|
+
observedForMs: number(),
|
|
24706
|
+
sessionsNow: number(),
|
|
24707
|
+
/** Most parallel sessions across the cluster inside the window. */
|
|
24708
|
+
clusterPeakSessions: number(),
|
|
24709
|
+
nodes: array(PlacementNodeStatsSchema).readonly(),
|
|
24710
|
+
stalePins: array(StaleDevicePinSchema).readonly()
|
|
24711
|
+
});
|
|
24712
|
+
var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
|
|
24713
|
+
var SuggestedDeviceShareSchema = object({
|
|
24714
|
+
deviceKey: string(),
|
|
24715
|
+
/** Share of the node (0–100, rounded). */
|
|
24716
|
+
share: number(),
|
|
24717
|
+
modelId: string().nullable(),
|
|
24718
|
+
/** Inferences per second at that model, from the measured table. */
|
|
24719
|
+
fps: number().nullable(),
|
|
24720
|
+
measured: boolean(),
|
|
24721
|
+
/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
|
|
24722
|
+
suggestedMaxSessions: number().nullable()
|
|
24723
|
+
});
|
|
24724
|
+
var SuggestedNodeShareSchema = object({
|
|
24725
|
+
nodeId: string(),
|
|
24726
|
+
/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
|
|
24727
|
+
share: number().nullable(),
|
|
24728
|
+
/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
|
|
24729
|
+
capacitySessions: number(),
|
|
24730
|
+
devices: array(SuggestedDeviceShareSchema).readonly(),
|
|
24731
|
+
skippedReason: string().nullable()
|
|
24732
|
+
});
|
|
24733
|
+
var SuggestSharesResultSchema = object({
|
|
24734
|
+
headroom: number(),
|
|
24735
|
+
/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
|
|
24736
|
+
cameraFps: number(),
|
|
24737
|
+
/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
|
|
24738
|
+
iterations: number(),
|
|
24739
|
+
nodes: array(SuggestedNodeShareSchema).readonly()
|
|
24740
|
+
});
|
|
24741
|
+
/**
|
|
24742
|
+
* Where the node and device shares come from (D750).
|
|
24743
|
+
* - `auto` — computed by the system from the cluster's measured capacity at
|
|
24744
|
+
* the Auto tune models, and recomputed whenever a node or device joins,
|
|
24745
|
+
* leaves, is switched on or off, or changes model.
|
|
24746
|
+
* - `manual` — the operator's stored sliders. A node or device that cannot
|
|
24747
|
+
* take sessions gives its share to the others in proportion; the stored
|
|
24748
|
+
* values are never rewritten for that.
|
|
24749
|
+
*/
|
|
24750
|
+
var ShareSourceSchema = _enum(["auto", "manual"]);
|
|
24751
|
+
var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
|
|
24752
|
+
object({
|
|
24753
|
+
nodes: record(string(), number()),
|
|
24754
|
+
devices: record(string(), record(string(), number()))
|
|
24755
|
+
});
|
|
24756
|
+
var EffectiveDeviceShareSchema = object({
|
|
24757
|
+
deviceKey: string(),
|
|
24758
|
+
/** Can take sessions now (enabled, available, can run the root). */
|
|
24759
|
+
eligible: boolean(),
|
|
24760
|
+
/** The share the source assigns, as a percentage of the node's devices. */
|
|
24761
|
+
configuredPct: number(),
|
|
24762
|
+
/** The share actually used, after an ineligible device's share went to the others. */
|
|
24763
|
+
effectivePct: number()
|
|
24764
|
+
});
|
|
24765
|
+
var EffectiveNodeShareSchema = object({
|
|
24766
|
+
nodeId: string(),
|
|
24767
|
+
eligible: boolean(),
|
|
24768
|
+
configuredPct: number(),
|
|
24769
|
+
effectivePct: number(),
|
|
24770
|
+
devices: array(EffectiveDeviceShareSchema).readonly()
|
|
24771
|
+
});
|
|
24772
|
+
var EffectiveSharesSchema = object({
|
|
24773
|
+
source: ShareSourceSchema,
|
|
24774
|
+
policy: SessionPlacementPolicySchema,
|
|
24775
|
+
/** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
|
|
24776
|
+
autoPending: boolean(),
|
|
24777
|
+
/** When the automatic shares were last computed (ms epoch); null = never. */
|
|
24778
|
+
computedAt: number().nullable(),
|
|
24779
|
+
/** What made the system recompute them last. */
|
|
24780
|
+
trigger: string().nullable(),
|
|
24781
|
+
nodes: array(EffectiveNodeShareSchema).readonly(),
|
|
24782
|
+
/** The relative weights the election reads (before eligibility). */
|
|
24783
|
+
nodeWeights: record(string(), number()),
|
|
24784
|
+
deviceWeights: record(string(), record(string(), number()))
|
|
24785
|
+
});
|
|
24786
|
+
/**
|
|
24787
|
+
* The wire shapes of the Auto tune plan and apply (D745), used by the
|
|
24788
|
+
* `pipeline-orchestrator` cap. The recommender's own types
|
|
24789
|
+
* (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
|
|
24790
|
+
* schemas are what crosses the cap boundary.
|
|
24791
|
+
*/
|
|
24792
|
+
var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
|
|
24793
|
+
var HardwareClassIdSchema = _enum([
|
|
24794
|
+
"intel-core-ultra",
|
|
24795
|
+
"intel-n-series",
|
|
24796
|
+
"apple-m-base",
|
|
24797
|
+
"apple-m-pro",
|
|
24798
|
+
"unknown"
|
|
24799
|
+
]);
|
|
24800
|
+
var AcceleratorKindSchema = _enum([
|
|
24801
|
+
"intel-npu",
|
|
24802
|
+
"intel-igpu",
|
|
24803
|
+
"x86-cpu",
|
|
24804
|
+
"arm-cpu",
|
|
24805
|
+
"apple-ane",
|
|
24806
|
+
"coral"
|
|
24807
|
+
]);
|
|
24808
|
+
var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
24809
|
+
object({
|
|
24810
|
+
kind: literal("fits"),
|
|
24811
|
+
utilisation: number()
|
|
24812
|
+
}),
|
|
24813
|
+
object({
|
|
24814
|
+
kind: literal("tie-faster"),
|
|
24815
|
+
over: string(),
|
|
24816
|
+
recallDelta: number()
|
|
24817
|
+
}),
|
|
24818
|
+
object({
|
|
24819
|
+
kind: literal("stepped-down"),
|
|
24820
|
+
from: string(),
|
|
24821
|
+
to: string(),
|
|
24822
|
+
limitedBy: string()
|
|
24823
|
+
}),
|
|
24824
|
+
object({
|
|
24825
|
+
kind: literal("no-fit-lightest"),
|
|
24826
|
+
utilisation: number()
|
|
24827
|
+
}),
|
|
24828
|
+
object({
|
|
24829
|
+
kind: literal("derived-latency"),
|
|
24830
|
+
modelId: string()
|
|
24831
|
+
}),
|
|
24832
|
+
object({
|
|
24833
|
+
kind: literal("estimated-load"),
|
|
24834
|
+
observedForMs: number().nullable()
|
|
24835
|
+
}),
|
|
24836
|
+
object({ kind: literal("cpu-device") }),
|
|
24837
|
+
object({ kind: literal("coral-untouched") }),
|
|
24838
|
+
object({ kind: literal("device-disabled") }),
|
|
24839
|
+
object({ kind: literal("device-unavailable") }),
|
|
24840
|
+
object({ kind: literal("node-offline") }),
|
|
24841
|
+
object({ kind: literal("no-hardware-facts") }),
|
|
24842
|
+
object({
|
|
24843
|
+
kind: literal("no-measured-data"),
|
|
24844
|
+
hardwareClass: HardwareClassIdSchema
|
|
24845
|
+
}),
|
|
24846
|
+
object({
|
|
24847
|
+
kind: literal("no-family-build"),
|
|
24848
|
+
format: ModelFormatSchema$1
|
|
24849
|
+
})
|
|
24850
|
+
]);
|
|
24851
|
+
var DeviceDemandSchema = object({
|
|
24852
|
+
nodeId: string(),
|
|
24853
|
+
deviceKey: string(),
|
|
24854
|
+
demandFps: number(),
|
|
24855
|
+
maxCameraFps: number(),
|
|
24856
|
+
alwaysOnCameras: number(),
|
|
24857
|
+
onMotionSessions: number(),
|
|
24858
|
+
onMotionSource: _enum([
|
|
24859
|
+
"observed-24h",
|
|
24860
|
+
"estimate",
|
|
24861
|
+
"none"
|
|
24862
|
+
]),
|
|
24863
|
+
observedForMs: number().nullable(),
|
|
24864
|
+
/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
|
|
24865
|
+
placement: SessionPlacementPolicySchema
|
|
24866
|
+
});
|
|
24867
|
+
var DeviceModelChoiceSchema = object({
|
|
24868
|
+
modelId: string(),
|
|
24869
|
+
p50Ms: number(),
|
|
24870
|
+
fps: number(),
|
|
24871
|
+
measured: boolean(),
|
|
24872
|
+
utilisation: number(),
|
|
24873
|
+
personRecall: number()
|
|
24874
|
+
});
|
|
24875
|
+
var DeviceRecommendationSchema = object({
|
|
24876
|
+
deviceKey: string(),
|
|
24877
|
+
accelerator: AcceleratorKindSchema.nullable(),
|
|
24878
|
+
enabled: boolean(),
|
|
24879
|
+
available: boolean(),
|
|
24880
|
+
demand: DeviceDemandSchema.nullable(),
|
|
24881
|
+
chosen: DeviceModelChoiceSchema.nullable(),
|
|
24882
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24883
|
+
});
|
|
24884
|
+
var NodeRecommendationSchema = object({
|
|
24885
|
+
nodeId: string(),
|
|
24886
|
+
reachable: boolean(),
|
|
24887
|
+
hardwareClass: HardwareClassIdSchema.nullable(),
|
|
24888
|
+
cpuModel: string().nullable(),
|
|
24889
|
+
skipped: boolean(),
|
|
24890
|
+
acceleratorModelId: string().nullable(),
|
|
24891
|
+
devices: array(DeviceRecommendationSchema).readonly(),
|
|
24892
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24893
|
+
});
|
|
24894
|
+
var ModelPinChangeSchema = object({
|
|
24895
|
+
stepId: string(),
|
|
24896
|
+
before: string().nullable(),
|
|
24897
|
+
after: string().nullable()
|
|
24898
|
+
});
|
|
24899
|
+
var NodeDeviceChangeSchema = object({
|
|
24900
|
+
nodeId: string(),
|
|
24901
|
+
deviceKey: string(),
|
|
24902
|
+
madeExplicit: boolean(),
|
|
24903
|
+
modelPins: array(ModelPinChangeSchema).readonly(),
|
|
24904
|
+
thresholds: array(object({
|
|
24905
|
+
stepId: string(),
|
|
24906
|
+
keys: array(string()).readonly()
|
|
24907
|
+
})).readonly()
|
|
24908
|
+
});
|
|
24909
|
+
var CameraOverrideClearSchema = object({
|
|
24910
|
+
deviceId: number(),
|
|
24911
|
+
source: _enum(["step-override", "wholesale"]),
|
|
24912
|
+
nodeId: string(),
|
|
24913
|
+
deviceKey: string().nullable(),
|
|
24914
|
+
stepId: string(),
|
|
24915
|
+
modelIdBefore: string().nullable(),
|
|
24916
|
+
keys: array(string()).readonly()
|
|
24917
|
+
});
|
|
24918
|
+
var DetectorStoreClearSchema = object({
|
|
24919
|
+
deviceId: number(),
|
|
24920
|
+
keys: array(string()).readonly()
|
|
24921
|
+
});
|
|
24922
|
+
var AutoTuneWarningSchema = discriminatedUnion("kind", [
|
|
24923
|
+
object({
|
|
24924
|
+
kind: literal("detector-store-cluster-wide"),
|
|
24925
|
+
skippedNodes: array(string()).readonly()
|
|
24926
|
+
}),
|
|
24927
|
+
object({
|
|
24928
|
+
kind: literal("detector-store-unreadable"),
|
|
24929
|
+
error: string()
|
|
24930
|
+
}),
|
|
24931
|
+
object({
|
|
24932
|
+
kind: literal("coral-enabled"),
|
|
24933
|
+
nodeId: string(),
|
|
24934
|
+
deviceKey: string()
|
|
24935
|
+
})
|
|
24936
|
+
]);
|
|
24937
|
+
var AutoTuneOptionsSchema = object({
|
|
24938
|
+
/** Share of each accelerator's throughput kept free (0.3–0.5). */
|
|
24939
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24940
|
+
/**
|
|
24941
|
+
* What-if shares (D748): plan as if these node/device shares were stored
|
|
24942
|
+
* and the policy were `share`. Absent = the stored shares under the stored
|
|
24943
|
+
* policy. A what-if plan is for display; apply always re-plans from what
|
|
24944
|
+
* is stored.
|
|
24945
|
+
*/
|
|
24946
|
+
shares: LoadBalancingSharesInputSchema.optional()
|
|
24947
|
+
});
|
|
24948
|
+
var AutoTunePlanSchema = object({
|
|
24949
|
+
/** Hash of everything the apply will write — the apply refuses a different one. */
|
|
24950
|
+
planHash: string(),
|
|
24951
|
+
family: literal("yolov9"),
|
|
24952
|
+
headroom: number(),
|
|
24953
|
+
/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
|
|
24954
|
+
whatIf: boolean(),
|
|
24955
|
+
generatedAt: number(),
|
|
24956
|
+
nodes: array(NodeRecommendationSchema).readonly(),
|
|
24957
|
+
nodeChanges: array(NodeDeviceChangeSchema).readonly(),
|
|
24958
|
+
cameraClears: array(CameraOverrideClearSchema).readonly(),
|
|
24959
|
+
detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
|
|
24960
|
+
warnings: array(AutoTuneWarningSchema).readonly()
|
|
24961
|
+
});
|
|
24962
|
+
var AutoTuneApplyInputSchema = object({
|
|
24963
|
+
planHash: string(),
|
|
24964
|
+
headroom: number().min(.3).max(.5).default(.4)
|
|
24965
|
+
});
|
|
24966
|
+
var AutoTunePhaseResultSchema = object({
|
|
24967
|
+
phase: _enum([
|
|
24968
|
+
"download",
|
|
24969
|
+
"camera-overrides",
|
|
24970
|
+
"detector-thresholds",
|
|
24971
|
+
"node-models",
|
|
24972
|
+
"redispatch"
|
|
24973
|
+
]),
|
|
24974
|
+
ok: boolean(),
|
|
24975
|
+
detail: string()
|
|
24976
|
+
});
|
|
24977
|
+
var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
|
|
24978
|
+
object({
|
|
24979
|
+
kind: literal("applied"),
|
|
24980
|
+
planHash: string(),
|
|
24981
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24982
|
+
}),
|
|
24983
|
+
object({
|
|
24984
|
+
kind: literal("aborted"),
|
|
24985
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24986
|
+
}),
|
|
24987
|
+
object({
|
|
24988
|
+
kind: literal("stale"),
|
|
24989
|
+
plan: AutoTunePlanSchema
|
|
24990
|
+
}),
|
|
24991
|
+
object({
|
|
24992
|
+
kind: literal("refused"),
|
|
24993
|
+
reason: _enum(["apply-in-progress"])
|
|
24994
|
+
})
|
|
24995
|
+
]);
|
|
24526
24996
|
object({
|
|
24527
24997
|
activeCameras: number(),
|
|
24528
24998
|
throttledCameras: number(),
|
|
@@ -25703,7 +26173,6 @@ var CameraStepOverridePatchSchema = object({
|
|
|
25703
26173
|
settings: record(string(), unknown()).readonly().optional()
|
|
25704
26174
|
});
|
|
25705
26175
|
var CameraPipelineSettingsSchema = object({
|
|
25706
|
-
pinnedAgentNodeId: string().optional(),
|
|
25707
26176
|
stepToggles: record(string(), boolean()).optional(),
|
|
25708
26177
|
stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
|
|
25709
26178
|
pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
|
|
@@ -26202,12 +26671,6 @@ method(object({
|
|
|
26202
26671
|
}), object({ success: literal(true) }), {
|
|
26203
26672
|
kind: "mutation",
|
|
26204
26673
|
auth: "admin"
|
|
26205
|
-
}), method(object({
|
|
26206
|
-
agentNodeId: string(),
|
|
26207
|
-
detectWeight: number().positive().nullable()
|
|
26208
|
-
}), object({ success: literal(true) }), {
|
|
26209
|
-
kind: "mutation",
|
|
26210
|
-
auth: "admin"
|
|
26211
26674
|
}), method(object({
|
|
26212
26675
|
agentNodeId: string(),
|
|
26213
26676
|
detect: boolean().nullable().optional(),
|
|
@@ -26249,6 +26712,15 @@ method(object({
|
|
|
26249
26712
|
}), {
|
|
26250
26713
|
kind: "mutation",
|
|
26251
26714
|
auth: "admin"
|
|
26715
|
+
}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
|
|
26716
|
+
kind: "mutation",
|
|
26717
|
+
auth: "admin"
|
|
26718
|
+
}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
|
|
26719
|
+
kind: "mutation",
|
|
26720
|
+
auth: "admin"
|
|
26721
|
+
}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
|
|
26722
|
+
kind: "mutation",
|
|
26723
|
+
auth: "admin"
|
|
26252
26724
|
}), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
|
|
26253
26725
|
deviceId: number(),
|
|
26254
26726
|
addonId: string(),
|
|
@@ -29052,6 +29524,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
|
|
|
29052
29524
|
*/
|
|
29053
29525
|
alive: boolean()
|
|
29054
29526
|
})), method(object({
|
|
29527
|
+
deviceId: number().int().nonnegative(),
|
|
29528
|
+
sessionId: string(),
|
|
29529
|
+
downlinkMbps: number().nonnegative()
|
|
29530
|
+
}), object({
|
|
29531
|
+
outcome: _enum(["switching", "held"]),
|
|
29532
|
+
tier: CamProfileSchema.nullable(),
|
|
29533
|
+
reason: string()
|
|
29534
|
+
}), { kind: "mutation" }), method(object({
|
|
29055
29535
|
deviceId: number().int().nonnegative(),
|
|
29056
29536
|
sessionId: string()
|
|
29057
29537
|
}), WebrtcSessionDebugSchema, { kind: "query" });
|
|
@@ -31763,7 +32243,8 @@ var ConnectionEndpointSchema = object({
|
|
|
31763
32243
|
"lan-ipv6",
|
|
31764
32244
|
"public",
|
|
31765
32245
|
"loopback",
|
|
31766
|
-
"app-link"
|
|
32246
|
+
"app-link",
|
|
32247
|
+
"custom"
|
|
31767
32248
|
]),
|
|
31768
32249
|
/**
|
|
31769
32250
|
* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
|
|
@@ -31832,7 +32313,7 @@ var GetConnectionEndpointsResultSchema = object({
|
|
|
31832
32313
|
localPort: AdvertisedLocalPortSchema
|
|
31833
32314
|
});
|
|
31834
32315
|
/**
|
|
31835
|
-
* The address flagged for notification
|
|
32316
|
+
* The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
|
|
31836
32317
|
* since D709 is the CamStack app link; `resolved` reports the effective value,
|
|
31837
32318
|
* so the UI can show it either way.
|
|
31838
32319
|
*/
|
|
@@ -31866,13 +32347,12 @@ var ViewerEndpointsSchema = object({
|
|
|
31866
32347
|
resolved: array(string()).readonly()
|
|
31867
32348
|
});
|
|
31868
32349
|
/**
|
|
31869
|
-
*
|
|
31870
|
-
*
|
|
32350
|
+
* DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
|
|
32351
|
+
* for addons built against it): `cluster` is the `internal` role, `browser`
|
|
32352
|
+
* the `publicEndpoint` role; `override` is the flagged address.
|
|
31871
32353
|
*/
|
|
31872
32354
|
var HubAddressSnapshotSchema = object({
|
|
31873
|
-
/** The operator's override, or null for automatic. */
|
|
31874
32355
|
override: string().nullable(),
|
|
31875
|
-
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
31876
32356
|
resolved: string().nullable(),
|
|
31877
32357
|
source: _enum([
|
|
31878
32358
|
"override",
|
|
@@ -31881,11 +32361,57 @@ var HubAddressSnapshotSchema = object({
|
|
|
31881
32361
|
])
|
|
31882
32362
|
});
|
|
31883
32363
|
var HubAddressesSchema = object({
|
|
31884
|
-
/** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
|
|
31885
32364
|
cluster: HubAddressSnapshotSchema,
|
|
31886
|
-
/** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
|
|
31887
32365
|
browser: HubAddressSnapshotSchema
|
|
31888
32366
|
});
|
|
32367
|
+
/**
|
|
32368
|
+
* What an address is used for (`hub-address.ts`, D734). `appConnections` is
|
|
32369
|
+
* many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
|
|
32370
|
+
* by at most one address.
|
|
32371
|
+
*/
|
|
32372
|
+
var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
|
|
32373
|
+
var RoleSourceSchema = _enum([
|
|
32374
|
+
"flagged",
|
|
32375
|
+
"auto",
|
|
32376
|
+
"none"
|
|
32377
|
+
]);
|
|
32378
|
+
/** One single-valued role: the flagged address, the one in use, and why. */
|
|
32379
|
+
var HubAddressRoleResolutionSchema = object({
|
|
32380
|
+
/** The address carrying the flag, or null = automatic. */
|
|
32381
|
+
flagged: string().nullable(),
|
|
32382
|
+
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
32383
|
+
resolved: string().nullable(),
|
|
32384
|
+
source: RoleSourceSchema
|
|
32385
|
+
});
|
|
32386
|
+
var HubAppConnectionsResolutionSchema = object({
|
|
32387
|
+
/** The addresses flagged `appConnections`, or empty = automatic. */
|
|
32388
|
+
flagged: array(string()).readonly(),
|
|
32389
|
+
/** What the apps race right now. */
|
|
32390
|
+
resolved: array(string()).readonly(),
|
|
32391
|
+
source: RoleSourceSchema
|
|
32392
|
+
});
|
|
32393
|
+
var HubAddressBookSchema = object({
|
|
32394
|
+
rows: array(ConnectionEndpointSchema.extend({
|
|
32395
|
+
/** In the hub's detected palette right now. */
|
|
32396
|
+
detected: boolean(),
|
|
32397
|
+
/** Entered by the operator (removable). */
|
|
32398
|
+
custom: boolean(),
|
|
32399
|
+
/** The roles explicitly flagged on this address. */
|
|
32400
|
+
flags: array(HubAddressRoleSchema).readonly(),
|
|
32401
|
+
/** The roles this address serves right now — flagged or automatic. */
|
|
32402
|
+
inUse: array(HubAddressRoleSchema).readonly(),
|
|
32403
|
+
/** The roles this address may be flagged with. */
|
|
32404
|
+
eligible: array(HubAddressRoleSchema).readonly()
|
|
32405
|
+
})).readonly(),
|
|
32406
|
+
roles: object({
|
|
32407
|
+
appConnections: HubAppConnectionsResolutionSchema,
|
|
32408
|
+
notificationTaps: HubAddressRoleResolutionSchema,
|
|
32409
|
+
internal: HubAddressRoleResolutionSchema,
|
|
32410
|
+
publicEndpoint: HubAddressRoleResolutionSchema
|
|
32411
|
+
}),
|
|
32412
|
+
/** The `hub=` an app link carries (D709), or null. */
|
|
32413
|
+
appLinkHub: string().nullable()
|
|
32414
|
+
});
|
|
31889
32415
|
var AllowedAddressesSchema = object({
|
|
31890
32416
|
/**
|
|
31891
32417
|
* Allowlist of interface addresses operators have explicitly opted
|
|
@@ -31929,16 +32455,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
|
|
|
31929
32455
|
* tunnel always emits `https://` regardless. */
|
|
31930
32456
|
scheme: _enum(["http", "https"]).optional(),
|
|
31931
32457
|
/** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
|
|
31932
|
-
* an address notification
|
|
32458
|
+
* an address notification taps can be flagged with, not a hub
|
|
31933
32459
|
* route. Default `false`: racers and rankers never see it. */
|
|
31934
32460
|
includeAppLink: boolean().optional()
|
|
31935
|
-
}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(
|
|
31936
|
-
|
|
31937
|
-
|
|
31938
|
-
}),
|
|
32461
|
+
}), 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({
|
|
32462
|
+
baseUrl: string(),
|
|
32463
|
+
label: string().max(80)
|
|
32464
|
+
}), HubAddressBookSchema, {
|
|
31939
32465
|
kind: "mutation",
|
|
31940
32466
|
auth: "admin"
|
|
31941
|
-
}), method(
|
|
32467
|
+
}), method(object({ baseUrl: string() }), HubAddressBookSchema, {
|
|
32468
|
+
kind: "mutation",
|
|
32469
|
+
auth: "admin"
|
|
32470
|
+
}), method(object({
|
|
32471
|
+
role: HubAddressRoleSchema,
|
|
32472
|
+
baseUrl: string().nullable(),
|
|
32473
|
+
enabled: boolean(),
|
|
32474
|
+
acceptInsecureHttp: boolean().optional()
|
|
32475
|
+
}), HubAddressBookSchema, {
|
|
32476
|
+
kind: "mutation",
|
|
32477
|
+
auth: "admin"
|
|
32478
|
+
}), method(_void(), HubAddressesSchema), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
|
|
31942
32479
|
kind: "mutation",
|
|
31943
32480
|
auth: "admin"
|
|
31944
32481
|
}), method(object({
|
|
@@ -37485,6 +38022,16 @@ DeviceType.Camera, method(object({
|
|
|
37485
38022
|
package: array(ZoneRuleSchema).readonly()
|
|
37486
38023
|
});
|
|
37487
38024
|
SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
|
|
38025
|
+
Object.freeze({
|
|
38026
|
+
person: .5,
|
|
38027
|
+
vehicle: .5,
|
|
38028
|
+
animal: .5
|
|
38029
|
+
});
|
|
38030
|
+
Object.freeze({
|
|
38031
|
+
person: .65,
|
|
38032
|
+
vehicle: .65,
|
|
38033
|
+
animal: .65
|
|
38034
|
+
});
|
|
37488
38035
|
/**
|
|
37489
38036
|
* Accessory device helpers — shared across drivers.
|
|
37490
38037
|
*
|
|
@@ -40413,12 +40960,24 @@ Object.freeze({
|
|
|
40413
40960
|
addonId: null,
|
|
40414
40961
|
access: "view"
|
|
40415
40962
|
},
|
|
40963
|
+
"localNetwork.addCustomAddress": {
|
|
40964
|
+
capName: "local-network",
|
|
40965
|
+
capScope: "system",
|
|
40966
|
+
addonId: null,
|
|
40967
|
+
access: "create"
|
|
40968
|
+
},
|
|
40416
40969
|
"localNetwork.downloadCa": {
|
|
40417
40970
|
capName: "local-network",
|
|
40418
40971
|
capScope: "system",
|
|
40419
40972
|
addonId: null,
|
|
40420
40973
|
access: "view"
|
|
40421
40974
|
},
|
|
40975
|
+
"localNetwork.getAddresses": {
|
|
40976
|
+
capName: "local-network",
|
|
40977
|
+
capScope: "system",
|
|
40978
|
+
addonId: null,
|
|
40979
|
+
access: "view"
|
|
40980
|
+
},
|
|
40422
40981
|
"localNetwork.getAllowedAddresses": {
|
|
40423
40982
|
capName: "local-network",
|
|
40424
40983
|
capScope: "system",
|
|
@@ -40473,6 +41032,12 @@ Object.freeze({
|
|
|
40473
41032
|
addonId: null,
|
|
40474
41033
|
access: "create"
|
|
40475
41034
|
},
|
|
41035
|
+
"localNetwork.removeCustomAddress": {
|
|
41036
|
+
capName: "local-network",
|
|
41037
|
+
capScope: "system",
|
|
41038
|
+
addonId: null,
|
|
41039
|
+
access: "delete"
|
|
41040
|
+
},
|
|
40476
41041
|
"localNetwork.resetAllowlistToBestMatch": {
|
|
40477
41042
|
capName: "local-network",
|
|
40478
41043
|
capScope: "system",
|
|
@@ -40485,13 +41050,13 @@ Object.freeze({
|
|
|
40485
41050
|
addonId: null,
|
|
40486
41051
|
access: "create"
|
|
40487
41052
|
},
|
|
40488
|
-
"localNetwork.
|
|
41053
|
+
"localNetwork.setAddressRole": {
|
|
40489
41054
|
capName: "local-network",
|
|
40490
41055
|
capScope: "system",
|
|
40491
41056
|
addonId: null,
|
|
40492
41057
|
access: "create"
|
|
40493
41058
|
},
|
|
40494
|
-
"localNetwork.
|
|
41059
|
+
"localNetwork.setAllowedAddresses": {
|
|
40495
41060
|
capName: "local-network",
|
|
40496
41061
|
capScope: "system",
|
|
40497
41062
|
addonId: null,
|
|
@@ -41985,6 +42550,12 @@ Object.freeze({
|
|
|
41985
42550
|
addonId: null,
|
|
41986
42551
|
access: "delete"
|
|
41987
42552
|
},
|
|
42553
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": {
|
|
42554
|
+
capName: "pipeline-executor",
|
|
42555
|
+
capScope: "system",
|
|
42556
|
+
addonId: null,
|
|
42557
|
+
access: "delete"
|
|
42558
|
+
},
|
|
41988
42559
|
"pipelineExecutor.deleteModel": {
|
|
41989
42560
|
capName: "pipeline-executor",
|
|
41990
42561
|
capScope: "system",
|
|
@@ -42201,6 +42772,12 @@ Object.freeze({
|
|
|
42201
42772
|
addonId: null,
|
|
42202
42773
|
access: "view"
|
|
42203
42774
|
},
|
|
42775
|
+
"pipelineOrchestrator.applyAutoTune": {
|
|
42776
|
+
capName: "pipeline-orchestrator",
|
|
42777
|
+
capScope: "system",
|
|
42778
|
+
addonId: null,
|
|
42779
|
+
access: "create"
|
|
42780
|
+
},
|
|
42204
42781
|
"pipelineOrchestrator.applyDeviceSettingsPatch": {
|
|
42205
42782
|
capName: "pipeline-orchestrator",
|
|
42206
42783
|
capScope: "system",
|
|
@@ -42315,6 +42892,12 @@ Object.freeze({
|
|
|
42315
42892
|
addonId: null,
|
|
42316
42893
|
access: "view"
|
|
42317
42894
|
},
|
|
42895
|
+
"pipelineOrchestrator.getEffectiveShares": {
|
|
42896
|
+
capName: "pipeline-orchestrator",
|
|
42897
|
+
capScope: "system",
|
|
42898
|
+
addonId: null,
|
|
42899
|
+
access: "view"
|
|
42900
|
+
},
|
|
42318
42901
|
"pipelineOrchestrator.getGlobalMetrics": {
|
|
42319
42902
|
capName: "pipeline-orchestrator",
|
|
42320
42903
|
capScope: "system",
|
|
@@ -42351,6 +42934,12 @@ Object.freeze({
|
|
|
42351
42934
|
addonId: null,
|
|
42352
42935
|
access: "view"
|
|
42353
42936
|
},
|
|
42937
|
+
"pipelineOrchestrator.getPlacementStats": {
|
|
42938
|
+
capName: "pipeline-orchestrator",
|
|
42939
|
+
capScope: "system",
|
|
42940
|
+
addonId: null,
|
|
42941
|
+
access: "view"
|
|
42942
|
+
},
|
|
42354
42943
|
"pipelineOrchestrator.getReconcileFromDiskStatus": {
|
|
42355
42944
|
capName: "pipeline-orchestrator",
|
|
42356
42945
|
capScope: "system",
|
|
@@ -42375,6 +42964,12 @@ Object.freeze({
|
|
|
42375
42964
|
addonId: null,
|
|
42376
42965
|
access: "create"
|
|
42377
42966
|
},
|
|
42967
|
+
"pipelineOrchestrator.planAutoTune": {
|
|
42968
|
+
capName: "pipeline-orchestrator",
|
|
42969
|
+
capScope: "system",
|
|
42970
|
+
addonId: null,
|
|
42971
|
+
access: "view"
|
|
42972
|
+
},
|
|
42378
42973
|
"pipelineOrchestrator.rebalance": {
|
|
42379
42974
|
capName: "pipeline-orchestrator",
|
|
42380
42975
|
capScope: "system",
|
|
@@ -42435,12 +43030,6 @@ Object.freeze({
|
|
|
42435
43030
|
addonId: null,
|
|
42436
43031
|
access: "create"
|
|
42437
43032
|
},
|
|
42438
|
-
"pipelineOrchestrator.setAgentDetectWeight": {
|
|
42439
|
-
capName: "pipeline-orchestrator",
|
|
42440
|
-
capScope: "system",
|
|
42441
|
-
addonId: null,
|
|
42442
|
-
access: "create"
|
|
42443
|
-
},
|
|
42444
43033
|
"pipelineOrchestrator.setAgentInferenceDevices": {
|
|
42445
43034
|
capName: "pipeline-orchestrator",
|
|
42446
43035
|
capScope: "system",
|
|
@@ -42495,12 +43084,30 @@ Object.freeze({
|
|
|
42495
43084
|
addonId: null,
|
|
42496
43085
|
access: "create"
|
|
42497
43086
|
},
|
|
43087
|
+
"pipelineOrchestrator.setLoadBalancingShares": {
|
|
43088
|
+
capName: "pipeline-orchestrator",
|
|
43089
|
+
capScope: "system",
|
|
43090
|
+
addonId: null,
|
|
43091
|
+
access: "create"
|
|
43092
|
+
},
|
|
42498
43093
|
"pipelineOrchestrator.setPipelineDevicePin": {
|
|
42499
43094
|
capName: "pipeline-orchestrator",
|
|
42500
43095
|
capScope: "system",
|
|
42501
43096
|
addonId: null,
|
|
42502
43097
|
access: "create"
|
|
42503
43098
|
},
|
|
43099
|
+
"pipelineOrchestrator.setShareSource": {
|
|
43100
|
+
capName: "pipeline-orchestrator",
|
|
43101
|
+
capScope: "system",
|
|
43102
|
+
addonId: null,
|
|
43103
|
+
access: "create"
|
|
43104
|
+
},
|
|
43105
|
+
"pipelineOrchestrator.suggestShares": {
|
|
43106
|
+
capName: "pipeline-orchestrator",
|
|
43107
|
+
capScope: "system",
|
|
43108
|
+
addonId: null,
|
|
43109
|
+
access: "view"
|
|
43110
|
+
},
|
|
42504
43111
|
"pipelineOrchestrator.unassignAudio": {
|
|
42505
43112
|
capName: "pipeline-orchestrator",
|
|
42506
43113
|
capScope: "system",
|
|
@@ -44745,6 +45352,12 @@ Object.freeze({
|
|
|
44745
45352
|
addonId: null,
|
|
44746
45353
|
access: "create"
|
|
44747
45354
|
},
|
|
45355
|
+
"webrtcSession.applyDownlinkProbe": {
|
|
45356
|
+
capName: "webrtc-session",
|
|
45357
|
+
capScope: "device",
|
|
45358
|
+
addonId: null,
|
|
45359
|
+
access: "create"
|
|
45360
|
+
},
|
|
44748
45361
|
"webrtcSession.closeSession": {
|
|
44749
45362
|
capName: "webrtc-session",
|
|
44750
45363
|
capScope: "device",
|
|
@@ -47791,6 +48404,11 @@ Object.freeze({
|
|
|
47791
48404
|
form: "single",
|
|
47792
48405
|
optional: false
|
|
47793
48406
|
}],
|
|
48407
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": [{
|
|
48408
|
+
name: "deviceIds",
|
|
48409
|
+
form: "array",
|
|
48410
|
+
optional: true
|
|
48411
|
+
}],
|
|
47794
48412
|
"pipelineExecutor.runPipeline": [{
|
|
47795
48413
|
name: "deviceId",
|
|
47796
48414
|
form: "single",
|
|
@@ -48667,6 +49285,11 @@ Object.freeze({
|
|
|
48667
49285
|
form: "single",
|
|
48668
49286
|
optional: false
|
|
48669
49287
|
}],
|
|
49288
|
+
"webrtcSession.applyDownlinkProbe": [{
|
|
49289
|
+
name: "deviceId",
|
|
49290
|
+
form: "single",
|
|
49291
|
+
optional: false
|
|
49292
|
+
}],
|
|
48670
49293
|
"webrtcSession.closeSession": [{
|
|
48671
49294
|
name: "deviceId",
|
|
48672
49295
|
form: "single",
|
|
@@ -116142,7 +116765,6 @@ var HAP_STREAM_PREFERENCE_OPTIONS = [
|
|
|
116142
116765
|
];
|
|
116143
116766
|
var DEFAULT_CONFIG = {
|
|
116144
116767
|
bridgeName: "CamStack Bridge",
|
|
116145
|
-
port: 0,
|
|
116146
116768
|
fixedPin: "",
|
|
116147
116769
|
interfaceName: "",
|
|
116148
116770
|
ptzPulseMs: 400,
|
|
@@ -116819,20 +117441,11 @@ var ExportHapAddon = class extends BaseAddon {
|
|
|
116819
117441
|
type: "text",
|
|
116820
117442
|
key: "bridgeName",
|
|
116821
117443
|
label: "Installation name",
|
|
116822
|
-
description: "
|
|
117444
|
+
description: "The name of the shared bridge that carries every exposed device that is not a camera (switches, sensors, locks, alarm panels) — what iOS Home lists under Add Accessory. Cameras are never bridged: each one is published as its own accessory under its device name. Set it before you add the bridge in iOS Home.",
|
|
116823
117445
|
default: DEFAULT_CONFIG.bridgeName,
|
|
116824
117446
|
requiresRestart: true,
|
|
116825
117447
|
placement: { tab: "advanced" }
|
|
116826
117448
|
}),
|
|
116827
|
-
this.field({
|
|
116828
|
-
type: "number",
|
|
116829
|
-
key: "port",
|
|
116830
|
-
label: "HAP port",
|
|
116831
|
-
description: "Local port for the HAP server. 0 = random ephemeral port (recommended).",
|
|
116832
|
-
default: DEFAULT_CONFIG.port,
|
|
116833
|
-
requiresRestart: true,
|
|
116834
|
-
placement: { tab: "advanced" }
|
|
116835
|
-
}),
|
|
116836
117449
|
this.field({
|
|
116837
117450
|
type: "text",
|
|
116838
117451
|
key: "fixedPin",
|