@camstack/addon-export-hap 1.2.149 → 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 +808 -46
- package/dist/hap-export.addon.mjs +808 -46
- package/package.json +2 -2
|
@@ -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).
|
|
@@ -11378,6 +11378,26 @@ var ClipSearchStrictnessSchema = _enum([
|
|
|
11378
11378
|
"balanced",
|
|
11379
11379
|
"strict"
|
|
11380
11380
|
]);
|
|
11381
|
+
/** Steps whose effect a root label can BE. */
|
|
11382
|
+
var LABEL_SUPPLY_STEP_IDS = [
|
|
11383
|
+
"animal-classifier",
|
|
11384
|
+
"vehicle-classifier",
|
|
11385
|
+
"package-detection"
|
|
11386
|
+
];
|
|
11387
|
+
/** Steps whose box a root detection can BE. */
|
|
11388
|
+
var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
|
|
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
|
+
];
|
|
11381
11401
|
var MODEL_FORMATS = [
|
|
11382
11402
|
"onnx",
|
|
11383
11403
|
"coreml",
|
|
@@ -11406,7 +11426,53 @@ var ModelFormatEntrySchema = object({
|
|
|
11406
11426
|
/** Multi-file payload (directory members or sibling files). */
|
|
11407
11427
|
files: array(string()).readonly().optional(),
|
|
11408
11428
|
/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
|
|
11409
|
-
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()
|
|
11410
11476
|
});
|
|
11411
11477
|
/**
|
|
11412
11478
|
* Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
|
|
@@ -11510,6 +11576,46 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
|
|
|
11510
11576
|
/** True when the weights or their data forbid commercial use. */
|
|
11511
11577
|
nonCommercial: boolean().optional()
|
|
11512
11578
|
}));
|
|
11579
|
+
/**
|
|
11580
|
+
* One step a ROOT detector can supply from its own output (D730) — see
|
|
11581
|
+
* `ModelCatalogEntry.suppliesSteps`.
|
|
11582
|
+
*
|
|
11583
|
+
* - `label`: the root's raw class IS the step's answer. `labelToEffect` maps
|
|
11584
|
+
* the root's label to the step's vocabulary; `uncovered` is the vocabulary
|
|
11585
|
+
* the root cannot produce (shown as unavailable, never a blocker).
|
|
11586
|
+
* - `crop`: the root draws the box the step would have found (`license_plate`
|
|
11587
|
+
* for plate-detection, `face` for face-detection). The box becomes a detail
|
|
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.
|
|
11593
|
+
*/
|
|
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
|
+
]);
|
|
11513
11619
|
var ModelCatalogEntrySchema = object({
|
|
11514
11620
|
id: string(),
|
|
11515
11621
|
name: string(),
|
|
@@ -11575,6 +11681,35 @@ var ModelCatalogEntrySchema = object({
|
|
|
11575
11681
|
*/
|
|
11576
11682
|
defaultConfidence: number().min(0).max(1).optional(),
|
|
11577
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
|
+
/**
|
|
11578
11713
|
* When true, the executor produces a landmark-aligned crop (similarity warp
|
|
11579
11714
|
* onto the canonical template) before this step runs, instead of a plain
|
|
11580
11715
|
* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
|
|
@@ -11636,6 +11771,16 @@ var ModelCatalogEntrySchema = object({
|
|
|
11636
11771
|
*/
|
|
11637
11772
|
classMap: DetectionCatalogClassMapSchema.optional(),
|
|
11638
11773
|
/**
|
|
11774
|
+
* The pipeline steps this ROOT detector can supply from its own output
|
|
11775
|
+
* (D730): its labels name a step's effect (`deer` for `animal-classifier`)
|
|
11776
|
+
* or draw a step's box (`license_plate` for `plate-detection`). Computed at
|
|
11777
|
+
* import from THIS model's labelmap by `deriveRootSupplies`, never written
|
|
11778
|
+
* by hand and never assumed per family; a row without it is derived on read
|
|
11779
|
+
* (`rootSuppliesOf`). Whether a camera uses it is the step's own
|
|
11780
|
+
* `useRootModel` flag (`resolveRootSupply`).
|
|
11781
|
+
*/
|
|
11782
|
+
suppliesSteps: array(RootStepSupplySchema).readonly().optional(),
|
|
11783
|
+
/**
|
|
11639
11784
|
* The model's CLIP feature-space contract (text encoder, dimension, vector
|
|
11640
11785
|
* index, token window, search floor) — see `clip-model.ts`. Present ONLY on a
|
|
11641
11786
|
* CLIP image encoder; its absence is what "not a CLIP model" means to the
|
|
@@ -16875,6 +17020,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
|
|
|
16875
17020
|
kind: "mutation",
|
|
16876
17021
|
auth: "admin"
|
|
16877
17022
|
});
|
|
17023
|
+
var HUB_ADDRESS_ROLES = [
|
|
17024
|
+
"appConnections",
|
|
17025
|
+
"notificationTaps",
|
|
17026
|
+
"internal",
|
|
17027
|
+
"publicEndpoint"
|
|
17028
|
+
];
|
|
16878
17029
|
/**
|
|
16879
17030
|
* Transport bounds for AI capability methods.
|
|
16880
17031
|
*
|
|
@@ -19439,6 +19590,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
19439
19590
|
"stream-offline",
|
|
19440
19591
|
"node-online",
|
|
19441
19592
|
"node-offline",
|
|
19593
|
+
"node-restarting",
|
|
19594
|
+
"node-updating",
|
|
19442
19595
|
"node-inference-unavailable",
|
|
19443
19596
|
"detection-blind",
|
|
19444
19597
|
"addon-crash-loop",
|
|
@@ -21044,7 +21197,13 @@ var NcAlarmModeDelaysListSchema = array(object({
|
|
|
21044
21197
|
* Absent = false (logged, not sent). Even when true it is not sent when that same sensor
|
|
21045
21198
|
* is the one that starts the entry delay — the entry-delay notification already names it.
|
|
21046
21199
|
*/
|
|
21047
|
-
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()
|
|
21048
21207
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
|
|
21049
21208
|
var NcAlarmModeDelaysEditListSchema = array(object({
|
|
21050
21209
|
mode: AlarmArmModeSchema,
|
|
@@ -21057,7 +21216,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
|
|
|
21057
21216
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21058
21217
|
notifyDuringEntryDelay: boolean().nullable().optional(),
|
|
21059
21218
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21060
|
-
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()
|
|
21061
21222
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
|
|
21062
21223
|
/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
|
|
21063
21224
|
var NcAlarmNonBlockingEditSchema = object({
|
|
@@ -23956,6 +24117,34 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
23956
24117
|
timestamp: number()
|
|
23957
24118
|
});
|
|
23958
24119
|
/**
|
|
24120
|
+
* A root model's boxes standing in for one crop-kind step's own inference
|
|
24121
|
+
* (D730) — see `runPipeline.suppliedRoot`.
|
|
24122
|
+
*/
|
|
24123
|
+
var SuppliedRootOutputSchema = object({
|
|
24124
|
+
stepId: string(),
|
|
24125
|
+
/** The root model that drew the boxes — stamped on the result. */
|
|
24126
|
+
modelId: string(),
|
|
24127
|
+
detections: array(object({
|
|
24128
|
+
/** `[x1, y1, x2, y2]` in the pixels of the call's image. */
|
|
24129
|
+
bbox: tuple([
|
|
24130
|
+
number(),
|
|
24131
|
+
number(),
|
|
24132
|
+
number(),
|
|
24133
|
+
number()
|
|
24134
|
+
]),
|
|
24135
|
+
score: number(),
|
|
24136
|
+
/**
|
|
24137
|
+
* Five facial landmarks in the same pixels — a face the step's own
|
|
24138
|
+
* detector already re-found inside a root face box (D730), so its
|
|
24139
|
+
* embedder child aligns it exactly as it aligns any detected face.
|
|
24140
|
+
*/
|
|
24141
|
+
landmarks: array(object({
|
|
24142
|
+
x: number(),
|
|
24143
|
+
y: number()
|
|
24144
|
+
})).optional()
|
|
24145
|
+
})).min(1)
|
|
24146
|
+
});
|
|
24147
|
+
/**
|
|
23959
24148
|
* Reference to the frame's retained NATIVE surface + the parent crop's placement
|
|
23960
24149
|
* within the frame, so the executor can re-cut a leaf child ROI at native
|
|
23961
24150
|
* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
|
|
@@ -24003,7 +24192,7 @@ var FrameRefSchema = object({
|
|
|
24003
24192
|
timestamp: number(),
|
|
24004
24193
|
capturedAt: number().optional()
|
|
24005
24194
|
});
|
|
24006
|
-
var ModelFormatSchema$
|
|
24195
|
+
var ModelFormatSchema$2 = _enum([
|
|
24007
24196
|
"onnx",
|
|
24008
24197
|
"coreml",
|
|
24009
24198
|
"openvino",
|
|
@@ -24021,7 +24210,7 @@ var PipelineSlotSchema = _enum([
|
|
|
24021
24210
|
var PipelineEngineChoiceSchema = object({
|
|
24022
24211
|
runtime: literal("python"),
|
|
24023
24212
|
backend: string(),
|
|
24024
|
-
format: ModelFormatSchema$
|
|
24213
|
+
format: ModelFormatSchema$2,
|
|
24025
24214
|
device: string().optional()
|
|
24026
24215
|
});
|
|
24027
24216
|
/**
|
|
@@ -24078,14 +24267,12 @@ var PipelineTemplateSchema$1 = object({
|
|
|
24078
24267
|
var PipelineModelOptionSchema = object({
|
|
24079
24268
|
id: string(),
|
|
24080
24269
|
name: string(),
|
|
24081
|
-
formats: record(string(),
|
|
24082
|
-
downloaded: boolean(),
|
|
24083
|
-
sizeMB: number()
|
|
24084
|
-
})),
|
|
24270
|
+
formats: record(string(), PipelineModelFormatStatusSchema),
|
|
24085
24271
|
group: ModelVariantGroupSchema.optional(),
|
|
24086
24272
|
legacy: boolean().optional(),
|
|
24087
24273
|
provider: ModelProviderIdSchema.optional(),
|
|
24088
|
-
defaultConfidence: number().optional()
|
|
24274
|
+
defaultConfidence: number().optional(),
|
|
24275
|
+
suppliesSteps: array(RootStepSupplySchema).readonly().optional()
|
|
24089
24276
|
});
|
|
24090
24277
|
var ConfigFieldBridge = custom();
|
|
24091
24278
|
var PipelineAddonSchemaSchema = object({
|
|
@@ -24247,6 +24434,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24247
24434
|
}), {
|
|
24248
24435
|
kind: "mutation",
|
|
24249
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"
|
|
24250
24453
|
}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
|
|
24251
24454
|
/** `<backend>:<device>`, e.g. `openvino:gpu`. */
|
|
24252
24455
|
deviceKey: string(),
|
|
@@ -24283,11 +24486,11 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24283
24486
|
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24284
24487
|
addonId: string(),
|
|
24285
24488
|
modelId: string(),
|
|
24286
|
-
format: ModelFormatSchema$
|
|
24489
|
+
format: ModelFormatSchema$2
|
|
24287
24490
|
}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
|
|
24288
24491
|
addonId: string(),
|
|
24289
24492
|
modelId: string(),
|
|
24290
|
-
format: ModelFormatSchema$
|
|
24493
|
+
format: ModelFormatSchema$2
|
|
24291
24494
|
}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
|
|
24292
24495
|
steps: array(PipelineStepInputSchema).min(1),
|
|
24293
24496
|
frame: FrameInputSchema.optional(),
|
|
@@ -24353,7 +24556,16 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24353
24556
|
* `device-not-servable`), and nothing reaches the camera's live
|
|
24354
24557
|
* trace stream. Absent ⇒ unchanged behaviour.
|
|
24355
24558
|
*/
|
|
24356
|
-
replay: literal(true).optional()
|
|
24559
|
+
replay: literal(true).optional(),
|
|
24560
|
+
/**
|
|
24561
|
+
* Root-supplied detections for the tree's ROOT step (D730). Set by
|
|
24562
|
+
* `runDetailSubtree` when the camera's root model supplies a crop-kind
|
|
24563
|
+
* step (a Frigate+ `license_plate` for `plate-detection`): the step is
|
|
24564
|
+
* NOT inferred, these boxes are its output, and its children (the plate
|
|
24565
|
+
* reader) run on them through their own crop policy. Boxes are in the
|
|
24566
|
+
* PIXELS of the image this call carries. Absent ⇒ the root step runs.
|
|
24567
|
+
*/
|
|
24568
|
+
suppliedRoot: SuppliedRootOutputSchema.optional()
|
|
24357
24569
|
}), PipelineRunResultBridge, { kind: "mutation" }), method(object({
|
|
24358
24570
|
steps: array(PipelineStepInputSchema).min(1),
|
|
24359
24571
|
frames: array(FrameInputSchema).min(1).max(255),
|
|
@@ -24435,6 +24647,352 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24435
24647
|
filename: string().optional(),
|
|
24436
24648
|
settings: record(string(), unknown()).optional()
|
|
24437
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
|
+
]);
|
|
24438
24996
|
object({
|
|
24439
24997
|
activeCameras: number(),
|
|
24440
24998
|
throttledCameras: number(),
|
|
@@ -25455,7 +26013,22 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
|
|
|
25455
26013
|
*/
|
|
25456
26014
|
cropJpeg: string().optional(),
|
|
25457
26015
|
parent: DetailParentSchema,
|
|
25458
|
-
steps: array(string()).optional()
|
|
26016
|
+
steps: array(string()).optional(),
|
|
26017
|
+
/**
|
|
26018
|
+
* The camera's root model already drew this step's boxes (D730): a
|
|
26019
|
+
* `license_plate` inside the parent vehicle. The named step is NOT
|
|
26020
|
+
* inferred — these FRAME-space boxes are its output — and its
|
|
26021
|
+
* requested children (the plate reader) run on them. Absent ⇒ every
|
|
26022
|
+
* requested step infers as before.
|
|
26023
|
+
*/
|
|
26024
|
+
supplied: object({
|
|
26025
|
+
stepId: string(),
|
|
26026
|
+
modelId: string(),
|
|
26027
|
+
boxes: array(object({
|
|
26028
|
+
bbox: NativeCropBboxSchema,
|
|
26029
|
+
score: number()
|
|
26030
|
+
})).min(1)
|
|
26031
|
+
}).optional()
|
|
25459
26032
|
}), object({ details: array(DetailResultSchema) }).nullable(), { kind: "mutation" }), method(object({
|
|
25460
26033
|
/** Catalog step id, e.g. `clip-embedding`. */
|
|
25461
26034
|
stepId: string(),
|
|
@@ -25600,7 +26173,6 @@ var CameraStepOverridePatchSchema = object({
|
|
|
25600
26173
|
settings: record(string(), unknown()).readonly().optional()
|
|
25601
26174
|
});
|
|
25602
26175
|
var CameraPipelineSettingsSchema = object({
|
|
25603
|
-
pinnedAgentNodeId: string().optional(),
|
|
25604
26176
|
stepToggles: record(string(), boolean()).optional(),
|
|
25605
26177
|
stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
|
|
25606
26178
|
pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
|
|
@@ -26099,12 +26671,6 @@ method(object({
|
|
|
26099
26671
|
}), object({ success: literal(true) }), {
|
|
26100
26672
|
kind: "mutation",
|
|
26101
26673
|
auth: "admin"
|
|
26102
|
-
}), method(object({
|
|
26103
|
-
agentNodeId: string(),
|
|
26104
|
-
detectWeight: number().positive().nullable()
|
|
26105
|
-
}), object({ success: literal(true) }), {
|
|
26106
|
-
kind: "mutation",
|
|
26107
|
-
auth: "admin"
|
|
26108
26674
|
}), method(object({
|
|
26109
26675
|
agentNodeId: string(),
|
|
26110
26676
|
detect: boolean().nullable().optional(),
|
|
@@ -26146,6 +26712,15 @@ method(object({
|
|
|
26146
26712
|
}), {
|
|
26147
26713
|
kind: "mutation",
|
|
26148
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"
|
|
26149
26724
|
}), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
|
|
26150
26725
|
deviceId: number(),
|
|
26151
26726
|
addonId: string(),
|
|
@@ -28949,6 +29524,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
|
|
|
28949
29524
|
*/
|
|
28950
29525
|
alive: boolean()
|
|
28951
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({
|
|
28952
29535
|
deviceId: number().int().nonnegative(),
|
|
28953
29536
|
sessionId: string()
|
|
28954
29537
|
}), WebrtcSessionDebugSchema, { kind: "query" });
|
|
@@ -31660,7 +32243,8 @@ var ConnectionEndpointSchema = object({
|
|
|
31660
32243
|
"lan-ipv6",
|
|
31661
32244
|
"public",
|
|
31662
32245
|
"loopback",
|
|
31663
|
-
"app-link"
|
|
32246
|
+
"app-link",
|
|
32247
|
+
"custom"
|
|
31664
32248
|
]),
|
|
31665
32249
|
/**
|
|
31666
32250
|
* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
|
|
@@ -31729,7 +32313,7 @@ var GetConnectionEndpointsResultSchema = object({
|
|
|
31729
32313
|
localPort: AdvertisedLocalPortSchema
|
|
31730
32314
|
});
|
|
31731
32315
|
/**
|
|
31732
|
-
* The address flagged for notification
|
|
32316
|
+
* The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
|
|
31733
32317
|
* since D709 is the CamStack app link; `resolved` reports the effective value,
|
|
31734
32318
|
* so the UI can show it either way.
|
|
31735
32319
|
*/
|
|
@@ -31762,6 +32346,72 @@ var ViewerEndpointsSchema = object({
|
|
|
31762
32346
|
/** What the ranking currently resolves to (may be empty if nothing is up). */
|
|
31763
32347
|
resolved: array(string()).readonly()
|
|
31764
32348
|
});
|
|
32349
|
+
/**
|
|
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.
|
|
32353
|
+
*/
|
|
32354
|
+
var HubAddressSnapshotSchema = object({
|
|
32355
|
+
override: string().nullable(),
|
|
32356
|
+
resolved: string().nullable(),
|
|
32357
|
+
source: _enum([
|
|
32358
|
+
"override",
|
|
32359
|
+
"auto",
|
|
32360
|
+
"none"
|
|
32361
|
+
])
|
|
32362
|
+
});
|
|
32363
|
+
var HubAddressesSchema = object({
|
|
32364
|
+
cluster: HubAddressSnapshotSchema,
|
|
32365
|
+
browser: HubAddressSnapshotSchema
|
|
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
|
+
});
|
|
31765
32415
|
var AllowedAddressesSchema = object({
|
|
31766
32416
|
/**
|
|
31767
32417
|
* Allowlist of interface addresses operators have explicitly opted
|
|
@@ -31805,10 +32455,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
|
|
|
31805
32455
|
* tunnel always emits `https://` regardless. */
|
|
31806
32456
|
scheme: _enum(["http", "https"]).optional(),
|
|
31807
32457
|
/** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
|
|
31808
|
-
* an address notification
|
|
32458
|
+
* an address notification taps can be flagged with, not a hub
|
|
31809
32459
|
* route. Default `false`: racers and rankers never see it. */
|
|
31810
32460
|
includeAppLink: boolean().optional()
|
|
31811
|
-
}), 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(
|
|
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, {
|
|
32465
|
+
kind: "mutation",
|
|
32466
|
+
auth: "admin"
|
|
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, {
|
|
31812
32479
|
kind: "mutation",
|
|
31813
32480
|
auth: "admin"
|
|
31814
32481
|
}), method(object({
|
|
@@ -32198,7 +32865,8 @@ var MotionStatusSchema = object({
|
|
|
32198
32865
|
* writes this slice (not even a boot seed), and neither does the runner's
|
|
32199
32866
|
* phase machine: its phase is "a session is attached" for every on-motion
|
|
32200
32867
|
* session, not motion, and it now has its own `DetectionPhaseTransition`.
|
|
32201
|
-
* A provider's `isDetected`
|
|
32868
|
+
* A provider's `isDetected` and `getStatus` answer from the hub's slice
|
|
32869
|
+
* (`hubMotionNativeProvider`).
|
|
32202
32870
|
* - **Sensors** (Home Assistant binary sensors, Homematic, Matter, Alexa
|
|
32203
32871
|
* imports) — the provider pushes both edges itself, from the upstream
|
|
32204
32872
|
* system's own state change. That is the sensor's own fact.
|
|
@@ -37354,6 +38022,16 @@ DeviceType.Camera, method(object({
|
|
|
37354
38022
|
package: array(ZoneRuleSchema).readonly()
|
|
37355
38023
|
});
|
|
37356
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
|
+
});
|
|
37357
38035
|
/**
|
|
37358
38036
|
* Accessory device helpers — shared across drivers.
|
|
37359
38037
|
*
|
|
@@ -40282,12 +40960,24 @@ Object.freeze({
|
|
|
40282
40960
|
addonId: null,
|
|
40283
40961
|
access: "view"
|
|
40284
40962
|
},
|
|
40963
|
+
"localNetwork.addCustomAddress": {
|
|
40964
|
+
capName: "local-network",
|
|
40965
|
+
capScope: "system",
|
|
40966
|
+
addonId: null,
|
|
40967
|
+
access: "create"
|
|
40968
|
+
},
|
|
40285
40969
|
"localNetwork.downloadCa": {
|
|
40286
40970
|
capName: "local-network",
|
|
40287
40971
|
capScope: "system",
|
|
40288
40972
|
addonId: null,
|
|
40289
40973
|
access: "view"
|
|
40290
40974
|
},
|
|
40975
|
+
"localNetwork.getAddresses": {
|
|
40976
|
+
capName: "local-network",
|
|
40977
|
+
capScope: "system",
|
|
40978
|
+
addonId: null,
|
|
40979
|
+
access: "view"
|
|
40980
|
+
},
|
|
40291
40981
|
"localNetwork.getAllowedAddresses": {
|
|
40292
40982
|
capName: "local-network",
|
|
40293
40983
|
capScope: "system",
|
|
@@ -40300,6 +40990,12 @@ Object.freeze({
|
|
|
40300
40990
|
addonId: null,
|
|
40301
40991
|
access: "view"
|
|
40302
40992
|
},
|
|
40993
|
+
"localNetwork.getHubAddresses": {
|
|
40994
|
+
capName: "local-network",
|
|
40995
|
+
capScope: "system",
|
|
40996
|
+
addonId: null,
|
|
40997
|
+
access: "view"
|
|
40998
|
+
},
|
|
40303
40999
|
"localNetwork.getNotificationEndpoint": {
|
|
40304
41000
|
capName: "local-network",
|
|
40305
41001
|
capScope: "system",
|
|
@@ -40336,6 +41032,12 @@ Object.freeze({
|
|
|
40336
41032
|
addonId: null,
|
|
40337
41033
|
access: "create"
|
|
40338
41034
|
},
|
|
41035
|
+
"localNetwork.removeCustomAddress": {
|
|
41036
|
+
capName: "local-network",
|
|
41037
|
+
capScope: "system",
|
|
41038
|
+
addonId: null,
|
|
41039
|
+
access: "delete"
|
|
41040
|
+
},
|
|
40339
41041
|
"localNetwork.resetAllowlistToBestMatch": {
|
|
40340
41042
|
capName: "local-network",
|
|
40341
41043
|
capScope: "system",
|
|
@@ -40348,6 +41050,12 @@ Object.freeze({
|
|
|
40348
41050
|
addonId: null,
|
|
40349
41051
|
access: "create"
|
|
40350
41052
|
},
|
|
41053
|
+
"localNetwork.setAddressRole": {
|
|
41054
|
+
capName: "local-network",
|
|
41055
|
+
capScope: "system",
|
|
41056
|
+
addonId: null,
|
|
41057
|
+
access: "create"
|
|
41058
|
+
},
|
|
40351
41059
|
"localNetwork.setAllowedAddresses": {
|
|
40352
41060
|
capName: "local-network",
|
|
40353
41061
|
capScope: "system",
|
|
@@ -41842,6 +42550,12 @@ Object.freeze({
|
|
|
41842
42550
|
addonId: null,
|
|
41843
42551
|
access: "delete"
|
|
41844
42552
|
},
|
|
42553
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": {
|
|
42554
|
+
capName: "pipeline-executor",
|
|
42555
|
+
capScope: "system",
|
|
42556
|
+
addonId: null,
|
|
42557
|
+
access: "delete"
|
|
42558
|
+
},
|
|
41845
42559
|
"pipelineExecutor.deleteModel": {
|
|
41846
42560
|
capName: "pipeline-executor",
|
|
41847
42561
|
capScope: "system",
|
|
@@ -42058,6 +42772,12 @@ Object.freeze({
|
|
|
42058
42772
|
addonId: null,
|
|
42059
42773
|
access: "view"
|
|
42060
42774
|
},
|
|
42775
|
+
"pipelineOrchestrator.applyAutoTune": {
|
|
42776
|
+
capName: "pipeline-orchestrator",
|
|
42777
|
+
capScope: "system",
|
|
42778
|
+
addonId: null,
|
|
42779
|
+
access: "create"
|
|
42780
|
+
},
|
|
42061
42781
|
"pipelineOrchestrator.applyDeviceSettingsPatch": {
|
|
42062
42782
|
capName: "pipeline-orchestrator",
|
|
42063
42783
|
capScope: "system",
|
|
@@ -42172,6 +42892,12 @@ Object.freeze({
|
|
|
42172
42892
|
addonId: null,
|
|
42173
42893
|
access: "view"
|
|
42174
42894
|
},
|
|
42895
|
+
"pipelineOrchestrator.getEffectiveShares": {
|
|
42896
|
+
capName: "pipeline-orchestrator",
|
|
42897
|
+
capScope: "system",
|
|
42898
|
+
addonId: null,
|
|
42899
|
+
access: "view"
|
|
42900
|
+
},
|
|
42175
42901
|
"pipelineOrchestrator.getGlobalMetrics": {
|
|
42176
42902
|
capName: "pipeline-orchestrator",
|
|
42177
42903
|
capScope: "system",
|
|
@@ -42208,6 +42934,12 @@ Object.freeze({
|
|
|
42208
42934
|
addonId: null,
|
|
42209
42935
|
access: "view"
|
|
42210
42936
|
},
|
|
42937
|
+
"pipelineOrchestrator.getPlacementStats": {
|
|
42938
|
+
capName: "pipeline-orchestrator",
|
|
42939
|
+
capScope: "system",
|
|
42940
|
+
addonId: null,
|
|
42941
|
+
access: "view"
|
|
42942
|
+
},
|
|
42211
42943
|
"pipelineOrchestrator.getReconcileFromDiskStatus": {
|
|
42212
42944
|
capName: "pipeline-orchestrator",
|
|
42213
42945
|
capScope: "system",
|
|
@@ -42232,6 +42964,12 @@ Object.freeze({
|
|
|
42232
42964
|
addonId: null,
|
|
42233
42965
|
access: "create"
|
|
42234
42966
|
},
|
|
42967
|
+
"pipelineOrchestrator.planAutoTune": {
|
|
42968
|
+
capName: "pipeline-orchestrator",
|
|
42969
|
+
capScope: "system",
|
|
42970
|
+
addonId: null,
|
|
42971
|
+
access: "view"
|
|
42972
|
+
},
|
|
42235
42973
|
"pipelineOrchestrator.rebalance": {
|
|
42236
42974
|
capName: "pipeline-orchestrator",
|
|
42237
42975
|
capScope: "system",
|
|
@@ -42292,12 +43030,6 @@ Object.freeze({
|
|
|
42292
43030
|
addonId: null,
|
|
42293
43031
|
access: "create"
|
|
42294
43032
|
},
|
|
42295
|
-
"pipelineOrchestrator.setAgentDetectWeight": {
|
|
42296
|
-
capName: "pipeline-orchestrator",
|
|
42297
|
-
capScope: "system",
|
|
42298
|
-
addonId: null,
|
|
42299
|
-
access: "create"
|
|
42300
|
-
},
|
|
42301
43033
|
"pipelineOrchestrator.setAgentInferenceDevices": {
|
|
42302
43034
|
capName: "pipeline-orchestrator",
|
|
42303
43035
|
capScope: "system",
|
|
@@ -42352,12 +43084,30 @@ Object.freeze({
|
|
|
42352
43084
|
addonId: null,
|
|
42353
43085
|
access: "create"
|
|
42354
43086
|
},
|
|
43087
|
+
"pipelineOrchestrator.setLoadBalancingShares": {
|
|
43088
|
+
capName: "pipeline-orchestrator",
|
|
43089
|
+
capScope: "system",
|
|
43090
|
+
addonId: null,
|
|
43091
|
+
access: "create"
|
|
43092
|
+
},
|
|
42355
43093
|
"pipelineOrchestrator.setPipelineDevicePin": {
|
|
42356
43094
|
capName: "pipeline-orchestrator",
|
|
42357
43095
|
capScope: "system",
|
|
42358
43096
|
addonId: null,
|
|
42359
43097
|
access: "create"
|
|
42360
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
|
+
},
|
|
42361
43111
|
"pipelineOrchestrator.unassignAudio": {
|
|
42362
43112
|
capName: "pipeline-orchestrator",
|
|
42363
43113
|
capScope: "system",
|
|
@@ -44602,6 +45352,12 @@ Object.freeze({
|
|
|
44602
45352
|
addonId: null,
|
|
44603
45353
|
access: "create"
|
|
44604
45354
|
},
|
|
45355
|
+
"webrtcSession.applyDownlinkProbe": {
|
|
45356
|
+
capName: "webrtc-session",
|
|
45357
|
+
capScope: "device",
|
|
45358
|
+
addonId: null,
|
|
45359
|
+
access: "create"
|
|
45360
|
+
},
|
|
44605
45361
|
"webrtcSession.closeSession": {
|
|
44606
45362
|
capName: "webrtc-session",
|
|
44607
45363
|
capScope: "device",
|
|
@@ -47648,6 +48404,11 @@ Object.freeze({
|
|
|
47648
48404
|
form: "single",
|
|
47649
48405
|
optional: false
|
|
47650
48406
|
}],
|
|
48407
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": [{
|
|
48408
|
+
name: "deviceIds",
|
|
48409
|
+
form: "array",
|
|
48410
|
+
optional: true
|
|
48411
|
+
}],
|
|
47651
48412
|
"pipelineExecutor.runPipeline": [{
|
|
47652
48413
|
name: "deviceId",
|
|
47653
48414
|
form: "single",
|
|
@@ -48524,6 +49285,11 @@ Object.freeze({
|
|
|
48524
49285
|
form: "single",
|
|
48525
49286
|
optional: false
|
|
48526
49287
|
}],
|
|
49288
|
+
"webrtcSession.applyDownlinkProbe": [{
|
|
49289
|
+
name: "deviceId",
|
|
49290
|
+
form: "single",
|
|
49291
|
+
optional: false
|
|
49292
|
+
}],
|
|
48527
49293
|
"webrtcSession.closeSession": [{
|
|
48528
49294
|
name: "deviceId",
|
|
48529
49295
|
form: "single",
|
|
@@ -48753,6 +49519,8 @@ new Map(Object.entries({
|
|
|
48753
49519
|
"detection-blind": "device-events",
|
|
48754
49520
|
"node-online": "system",
|
|
48755
49521
|
"node-offline": "system",
|
|
49522
|
+
"node-restarting": "system",
|
|
49523
|
+
"node-updating": "system",
|
|
48756
49524
|
"node-inference-unavailable": "system",
|
|
48757
49525
|
"addon-crash-loop": "system",
|
|
48758
49526
|
"addon-update-available": "system",
|
|
@@ -48830,6 +49598,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
48830
49598
|
kinds: [
|
|
48831
49599
|
"node-offline",
|
|
48832
49600
|
"node-online",
|
|
49601
|
+
"node-restarting",
|
|
48833
49602
|
"node-inference-unavailable"
|
|
48834
49603
|
]
|
|
48835
49604
|
},
|
|
@@ -48851,6 +49620,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
48851
49620
|
label: "Server & container updates",
|
|
48852
49621
|
kinds: [
|
|
48853
49622
|
"server-update-available",
|
|
49623
|
+
"node-updating",
|
|
48854
49624
|
"server-updated",
|
|
48855
49625
|
"wrapper-update-available"
|
|
48856
49626
|
]
|
|
@@ -48998,6 +49768,7 @@ var STATE_SUMMARY_SECTION_VARS = [
|
|
|
48998
49768
|
kinds: [
|
|
48999
49769
|
"node-offline",
|
|
49000
49770
|
"node-online",
|
|
49771
|
+
"node-restarting",
|
|
49001
49772
|
"node-inference-unavailable"
|
|
49002
49773
|
]
|
|
49003
49774
|
},
|
|
@@ -49019,6 +49790,7 @@ var STATE_SUMMARY_SECTION_VARS = [
|
|
|
49019
49790
|
example: "server 1.2.377 → 1.2.378",
|
|
49020
49791
|
kinds: [
|
|
49021
49792
|
"server-update-available",
|
|
49793
|
+
"node-updating",
|
|
49022
49794
|
"server-updated",
|
|
49023
49795
|
"wrapper-update-available"
|
|
49024
49796
|
]
|
|
@@ -49051,7 +49823,7 @@ var STATE_SUMMARY_VARS = [
|
|
|
49051
49823
|
{
|
|
49052
49824
|
name: "summarySection",
|
|
49053
49825
|
label: "Summary: this section",
|
|
49054
|
-
description: "The section a per-section summary row is about
|
|
49826
|
+
description: "The section a per-section summary row is about; on a summary sent as one message, every section it reports, comma-separated.",
|
|
49055
49827
|
example: "Batterie scariche",
|
|
49056
49828
|
group: "system",
|
|
49057
49829
|
families: ["rule"],
|
|
@@ -96744,7 +97516,7 @@ function createBoundedFfmpegRunner(input) {
|
|
|
96744
97516
|
code: null,
|
|
96745
97517
|
timedOut: false,
|
|
96746
97518
|
spawnFailed: true,
|
|
96747
|
-
stderr: `no pinned ffmpeg on this node
|
|
97519
|
+
stderr: `no pinned ffmpeg on this node: ${err instanceof Error ? err.message : String(err)}`
|
|
96748
97520
|
};
|
|
96749
97521
|
}
|
|
96750
97522
|
return await new Promise((resolve) => {
|
|
@@ -115993,7 +116765,6 @@ var HAP_STREAM_PREFERENCE_OPTIONS = [
|
|
|
115993
116765
|
];
|
|
115994
116766
|
var DEFAULT_CONFIG = {
|
|
115995
116767
|
bridgeName: "CamStack Bridge",
|
|
115996
|
-
port: 0,
|
|
115997
116768
|
fixedPin: "",
|
|
115998
116769
|
interfaceName: "",
|
|
115999
116770
|
ptzPulseMs: 400,
|
|
@@ -116670,20 +117441,11 @@ var ExportHapAddon = class extends BaseAddon {
|
|
|
116670
117441
|
type: "text",
|
|
116671
117442
|
key: "bridgeName",
|
|
116672
117443
|
label: "Installation name",
|
|
116673
|
-
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.",
|
|
116674
117445
|
default: DEFAULT_CONFIG.bridgeName,
|
|
116675
117446
|
requiresRestart: true,
|
|
116676
117447
|
placement: { tab: "advanced" }
|
|
116677
117448
|
}),
|
|
116678
|
-
this.field({
|
|
116679
|
-
type: "number",
|
|
116680
|
-
key: "port",
|
|
116681
|
-
label: "HAP port",
|
|
116682
|
-
description: "Local port for the HAP server. 0 = random ephemeral port (recommended).",
|
|
116683
|
-
default: DEFAULT_CONFIG.port,
|
|
116684
|
-
requiresRestart: true,
|
|
116685
|
-
placement: { tab: "advanced" }
|
|
116686
|
-
}),
|
|
116687
117449
|
this.field({
|
|
116688
117450
|
type: "text",
|
|
116689
117451
|
key: "fixedPin",
|