@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
package/dist/hap-export.addon.js
CHANGED
|
@@ -5428,7 +5428,7 @@ var ZodIssueCode = {
|
|
|
5428
5428
|
var ZodFirstPartyTypeKind;
|
|
5429
5429
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5430
5430
|
//#endregion
|
|
5431
|
-
//#region ../types/dist/sleep-
|
|
5431
|
+
//#region ../types/dist/sleep-C16NCZR2.mjs
|
|
5432
5432
|
/**
|
|
5433
5433
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5434
5434
|
* window to float samples (D455).
|
|
@@ -11388,6 +11388,26 @@ var ClipSearchStrictnessSchema = _enum([
|
|
|
11388
11388
|
"balanced",
|
|
11389
11389
|
"strict"
|
|
11390
11390
|
]);
|
|
11391
|
+
/** Steps whose effect a root label can BE. */
|
|
11392
|
+
var LABEL_SUPPLY_STEP_IDS = [
|
|
11393
|
+
"animal-classifier",
|
|
11394
|
+
"vehicle-classifier",
|
|
11395
|
+
"package-detection"
|
|
11396
|
+
];
|
|
11397
|
+
/** Steps whose box a root detection can BE. */
|
|
11398
|
+
var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
|
|
11399
|
+
/**
|
|
11400
|
+
* Steps whose per-detection MASK a root detection can carry (D737). The live
|
|
11401
|
+
* mask step is `segmentation` — a frame-plane refiner that runs its own model
|
|
11402
|
+
* once per detection crop. (`instance-segmentation` is a dormant step id that
|
|
11403
|
+
* no camera tree carries.)
|
|
11404
|
+
*/
|
|
11405
|
+
var MASK_SUPPLY_STEP_IDS = ["segmentation"];
|
|
11406
|
+
[
|
|
11407
|
+
...LABEL_SUPPLY_STEP_IDS,
|
|
11408
|
+
...CROP_SUPPLY_STEP_IDS,
|
|
11409
|
+
...MASK_SUPPLY_STEP_IDS
|
|
11410
|
+
];
|
|
11391
11411
|
var MODEL_FORMATS = [
|
|
11392
11412
|
"onnx",
|
|
11393
11413
|
"coreml",
|
|
@@ -11416,7 +11436,53 @@ var ModelFormatEntrySchema = object({
|
|
|
11416
11436
|
/** Multi-file payload (directory members or sibling files). */
|
|
11417
11437
|
files: array(string()).readonly().optional(),
|
|
11418
11438
|
/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
|
|
11419
|
-
runtimes: array(_enum(["python"])).readonly().optional()
|
|
11439
|
+
runtimes: array(_enum(["python"])).readonly().optional(),
|
|
11440
|
+
/**
|
|
11441
|
+
* Content revision of the artefact, for one hosted OFF the CamStack mirror.
|
|
11442
|
+
* A format on the mirror leaves it unset: its revision (the sha256 of its
|
|
11443
|
+
* weight file) comes from the downloader's generated table, kept in step
|
|
11444
|
+
* with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
|
|
11445
|
+
* node records the revision it downloaded next to the file
|
|
11446
|
+
* (`<file>.revision`); a copy with no record or a different one is stale
|
|
11447
|
+
* unless its weight file hashes to the revision, and a stale copy is
|
|
11448
|
+
* downloaded again, the old one serving until the new one is complete. No
|
|
11449
|
+
* revision at all ⇒ a file on disk is current, whatever it holds (D743).
|
|
11450
|
+
*/
|
|
11451
|
+
revision: string().min(1).optional()
|
|
11452
|
+
});
|
|
11453
|
+
/**
|
|
11454
|
+
* What a node holds for one (model, format) (D746). `current` is a complete
|
|
11455
|
+
* copy at its catalog revision — exactly what `downloaded: true` means.
|
|
11456
|
+
* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
|
|
11457
|
+
* no or a different revision record, or a missing sibling. `missing` is no
|
|
11458
|
+
* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
|
|
11459
|
+
* reclaimable bytes and a copy about to be replaced.
|
|
11460
|
+
*/
|
|
11461
|
+
var ModelOnDiskStateSchema = _enum([
|
|
11462
|
+
"current",
|
|
11463
|
+
"stale",
|
|
11464
|
+
"missing"
|
|
11465
|
+
]);
|
|
11466
|
+
/**
|
|
11467
|
+
* The numeric precision of one format's BUILD (D746) — reported only when the
|
|
11468
|
+
* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
|
|
11469
|
+
* CamStack Core ML export). Absent means "not stated", never "fp32".
|
|
11470
|
+
*/
|
|
11471
|
+
var ModelFormatPrecisionSchema = _enum([
|
|
11472
|
+
"fp32",
|
|
11473
|
+
"fp16",
|
|
11474
|
+
"int8"
|
|
11475
|
+
]);
|
|
11476
|
+
/**
|
|
11477
|
+
* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
|
|
11478
|
+
* `onDisk` / `precision` are optional for version skew: a runner that predates
|
|
11479
|
+
* them omits them, and a reader falls back to `downloaded`.
|
|
11480
|
+
*/
|
|
11481
|
+
var PipelineModelFormatStatusSchema = object({
|
|
11482
|
+
downloaded: boolean(),
|
|
11483
|
+
sizeMB: number(),
|
|
11484
|
+
onDisk: ModelOnDiskStateSchema.optional(),
|
|
11485
|
+
precision: ModelFormatPrecisionSchema.optional()
|
|
11420
11486
|
});
|
|
11421
11487
|
/**
|
|
11422
11488
|
* Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
|
|
@@ -11520,6 +11586,46 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
|
|
|
11520
11586
|
/** True when the weights or their data forbid commercial use. */
|
|
11521
11587
|
nonCommercial: boolean().optional()
|
|
11522
11588
|
}));
|
|
11589
|
+
/**
|
|
11590
|
+
* One step a ROOT detector can supply from its own output (D730) — see
|
|
11591
|
+
* `ModelCatalogEntry.suppliesSteps`.
|
|
11592
|
+
*
|
|
11593
|
+
* - `label`: the root's raw class IS the step's answer. `labelToEffect` maps
|
|
11594
|
+
* the root's label to the step's vocabulary; `uncovered` is the vocabulary
|
|
11595
|
+
* the root cannot produce (shown as unavailable, never a blocker).
|
|
11596
|
+
* - `crop`: the root draws the box the step would have found (`license_plate`
|
|
11597
|
+
* for plate-detection, `face` for face-detection). The box becomes a detail
|
|
11598
|
+
* child of the `parentMacro` detection that contains it — never a track.
|
|
11599
|
+
* - `mask`: the root's decode emits an instance mask with every detection (a
|
|
11600
|
+
* YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
|
|
11601
|
+
* detection in the shape that step produces. Derived from the model's
|
|
11602
|
+
* postprocessor on read, never stored by an import.
|
|
11603
|
+
*/
|
|
11604
|
+
var RootStepSupplySchema = discriminatedUnion("kind", [
|
|
11605
|
+
object({
|
|
11606
|
+
kind: literal("label"),
|
|
11607
|
+
stepId: _enum(LABEL_SUPPLY_STEP_IDS),
|
|
11608
|
+
labelToEffect: record(string(), string()),
|
|
11609
|
+
uncovered: array(string()).readonly()
|
|
11610
|
+
}),
|
|
11611
|
+
object({
|
|
11612
|
+
kind: literal("crop"),
|
|
11613
|
+
stepId: _enum(CROP_SUPPLY_STEP_IDS),
|
|
11614
|
+
rootLabels: array(string()).readonly(),
|
|
11615
|
+
parentMacro: _enum(["vehicle", "person"]),
|
|
11616
|
+
childClass: _enum(["plate", "face"]),
|
|
11617
|
+
/**
|
|
11618
|
+
* The root's smaller input side, stamped on read by `rootSuppliesOf` from
|
|
11619
|
+
* the model entry — what a step's `minRootInputPx` gate judges. Never
|
|
11620
|
+
* stored by an import.
|
|
11621
|
+
*/
|
|
11622
|
+
rootInputPx: number().int().positive().optional()
|
|
11623
|
+
}),
|
|
11624
|
+
object({
|
|
11625
|
+
kind: literal("mask"),
|
|
11626
|
+
stepId: _enum(MASK_SUPPLY_STEP_IDS)
|
|
11627
|
+
})
|
|
11628
|
+
]);
|
|
11523
11629
|
var ModelCatalogEntrySchema = object({
|
|
11524
11630
|
id: string(),
|
|
11525
11631
|
name: string(),
|
|
@@ -11585,6 +11691,35 @@ var ModelCatalogEntrySchema = object({
|
|
|
11585
11691
|
*/
|
|
11586
11692
|
defaultConfidence: number().min(0).max(1).optional(),
|
|
11587
11693
|
/**
|
|
11694
|
+
* Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
|
|
11695
|
+
* on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
|
|
11696
|
+
* absent here runs at the step slider's global default. The same row shape
|
|
11697
|
+
* the floor measurement produces (`model-floors.json`: modelId → floors), so
|
|
11698
|
+
* a measured table is copied in as-is. An operator override is bound to the
|
|
11699
|
+
* model it was made for and does not survive a model change (D738). A custom
|
|
11700
|
+
* / imported model may declare it; without it, the global defaults apply.
|
|
11701
|
+
*/
|
|
11702
|
+
defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11703
|
+
/**
|
|
11704
|
+
* The inference precision this model's OpenVINO IR needs on an Intel GPU.
|
|
11705
|
+
* Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
|
|
11706
|
+
* that produces invalid output at f16 — measured 2026-10-07 for YOLO26
|
|
11707
|
+
* base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
|
|
11708
|
+
* scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
|
|
11709
|
+
* `PoolModelConfig.gpuInferencePrecision`; the pool sets
|
|
11710
|
+
* INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
|
|
11711
|
+
*/
|
|
11712
|
+
gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
|
|
11713
|
+
/**
|
|
11714
|
+
* ROOT detectors only: per supplied step (`animal-classifier`, …), the
|
|
11715
|
+
* minimum DETECTION score from which this root's own fine label (species,
|
|
11716
|
+
* vehicle type — D736 root supply) is taken (D741). Below it the detection
|
|
11717
|
+
* keeps its macro class without the fine label. `1` = never take it from
|
|
11718
|
+
* this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
|
|
11719
|
+
* `minConfidence` slider, bound to the ROOT model, overrides it.
|
|
11720
|
+
*/
|
|
11721
|
+
suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
|
|
11722
|
+
/**
|
|
11588
11723
|
* When true, the executor produces a landmark-aligned crop (similarity warp
|
|
11589
11724
|
* onto the canonical template) before this step runs, instead of a plain
|
|
11590
11725
|
* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
|
|
@@ -11646,6 +11781,16 @@ var ModelCatalogEntrySchema = object({
|
|
|
11646
11781
|
*/
|
|
11647
11782
|
classMap: DetectionCatalogClassMapSchema.optional(),
|
|
11648
11783
|
/**
|
|
11784
|
+
* The pipeline steps this ROOT detector can supply from its own output
|
|
11785
|
+
* (D730): its labels name a step's effect (`deer` for `animal-classifier`)
|
|
11786
|
+
* or draw a step's box (`license_plate` for `plate-detection`). Computed at
|
|
11787
|
+
* import from THIS model's labelmap by `deriveRootSupplies`, never written
|
|
11788
|
+
* by hand and never assumed per family; a row without it is derived on read
|
|
11789
|
+
* (`rootSuppliesOf`). Whether a camera uses it is the step's own
|
|
11790
|
+
* `useRootModel` flag (`resolveRootSupply`).
|
|
11791
|
+
*/
|
|
11792
|
+
suppliesSteps: array(RootStepSupplySchema).readonly().optional(),
|
|
11793
|
+
/**
|
|
11649
11794
|
* The model's CLIP feature-space contract (text encoder, dimension, vector
|
|
11650
11795
|
* index, token window, search floor) — see `clip-model.ts`. Present ONLY on a
|
|
11651
11796
|
* CLIP image encoder; its absence is what "not a CLIP model" means to the
|
|
@@ -16885,6 +17030,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
|
|
|
16885
17030
|
kind: "mutation",
|
|
16886
17031
|
auth: "admin"
|
|
16887
17032
|
});
|
|
17033
|
+
var HUB_ADDRESS_ROLES = [
|
|
17034
|
+
"appConnections",
|
|
17035
|
+
"notificationTaps",
|
|
17036
|
+
"internal",
|
|
17037
|
+
"publicEndpoint"
|
|
17038
|
+
];
|
|
16888
17039
|
/**
|
|
16889
17040
|
* Transport bounds for AI capability methods.
|
|
16890
17041
|
*
|
|
@@ -19449,6 +19600,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
19449
19600
|
"stream-offline",
|
|
19450
19601
|
"node-online",
|
|
19451
19602
|
"node-offline",
|
|
19603
|
+
"node-restarting",
|
|
19604
|
+
"node-updating",
|
|
19452
19605
|
"node-inference-unavailable",
|
|
19453
19606
|
"detection-blind",
|
|
19454
19607
|
"addon-crash-loop",
|
|
@@ -21054,7 +21207,13 @@ var NcAlarmModeDelaysListSchema = array(object({
|
|
|
21054
21207
|
* Absent = false (logged, not sent). Even when true it is not sent when that same sensor
|
|
21055
21208
|
* is the one that starts the entry delay — the entry-delay notification already names it.
|
|
21056
21209
|
*/
|
|
21057
|
-
notifySensorRewatched: boolean().optional()
|
|
21210
|
+
notifySensorRewatched: boolean().optional(),
|
|
21211
|
+
/**
|
|
21212
|
+
* D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
|
|
21213
|
+
* change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
|
|
21214
|
+
* re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
|
|
21215
|
+
*/
|
|
21216
|
+
notifySensorIgnored: boolean().optional()
|
|
21058
21217
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
|
|
21059
21218
|
var NcAlarmModeDelaysEditListSchema = array(object({
|
|
21060
21219
|
mode: AlarmArmModeSchema,
|
|
@@ -21067,7 +21226,9 @@ var NcAlarmModeDelaysEditListSchema = array(object({
|
|
|
21067
21226
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21068
21227
|
notifyDuringEntryDelay: boolean().nullable().optional(),
|
|
21069
21228
|
/** D706: set the switch, or `null` to clear it (back to the default, false). */
|
|
21070
|
-
notifySensorRewatched: boolean().nullable().optional()
|
|
21229
|
+
notifySensorRewatched: boolean().nullable().optional(),
|
|
21230
|
+
/** D735: set the switch, or `null` to clear it (back to the default, false). */
|
|
21231
|
+
notifySensorIgnored: boolean().nullable().optional()
|
|
21071
21232
|
})).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
|
|
21072
21233
|
/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
|
|
21073
21234
|
var NcAlarmNonBlockingEditSchema = object({
|
|
@@ -23966,6 +24127,34 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
23966
24127
|
timestamp: number()
|
|
23967
24128
|
});
|
|
23968
24129
|
/**
|
|
24130
|
+
* A root model's boxes standing in for one crop-kind step's own inference
|
|
24131
|
+
* (D730) — see `runPipeline.suppliedRoot`.
|
|
24132
|
+
*/
|
|
24133
|
+
var SuppliedRootOutputSchema = object({
|
|
24134
|
+
stepId: string(),
|
|
24135
|
+
/** The root model that drew the boxes — stamped on the result. */
|
|
24136
|
+
modelId: string(),
|
|
24137
|
+
detections: array(object({
|
|
24138
|
+
/** `[x1, y1, x2, y2]` in the pixels of the call's image. */
|
|
24139
|
+
bbox: tuple([
|
|
24140
|
+
number(),
|
|
24141
|
+
number(),
|
|
24142
|
+
number(),
|
|
24143
|
+
number()
|
|
24144
|
+
]),
|
|
24145
|
+
score: number(),
|
|
24146
|
+
/**
|
|
24147
|
+
* Five facial landmarks in the same pixels — a face the step's own
|
|
24148
|
+
* detector already re-found inside a root face box (D730), so its
|
|
24149
|
+
* embedder child aligns it exactly as it aligns any detected face.
|
|
24150
|
+
*/
|
|
24151
|
+
landmarks: array(object({
|
|
24152
|
+
x: number(),
|
|
24153
|
+
y: number()
|
|
24154
|
+
})).optional()
|
|
24155
|
+
})).min(1)
|
|
24156
|
+
});
|
|
24157
|
+
/**
|
|
23969
24158
|
* Reference to the frame's retained NATIVE surface + the parent crop's placement
|
|
23970
24159
|
* within the frame, so the executor can re-cut a leaf child ROI at native
|
|
23971
24160
|
* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
|
|
@@ -24013,7 +24202,7 @@ var FrameRefSchema = object({
|
|
|
24013
24202
|
timestamp: number(),
|
|
24014
24203
|
capturedAt: number().optional()
|
|
24015
24204
|
});
|
|
24016
|
-
var ModelFormatSchema$
|
|
24205
|
+
var ModelFormatSchema$2 = _enum([
|
|
24017
24206
|
"onnx",
|
|
24018
24207
|
"coreml",
|
|
24019
24208
|
"openvino",
|
|
@@ -24031,7 +24220,7 @@ var PipelineSlotSchema = _enum([
|
|
|
24031
24220
|
var PipelineEngineChoiceSchema = object({
|
|
24032
24221
|
runtime: literal("python"),
|
|
24033
24222
|
backend: string(),
|
|
24034
|
-
format: ModelFormatSchema$
|
|
24223
|
+
format: ModelFormatSchema$2,
|
|
24035
24224
|
device: string().optional()
|
|
24036
24225
|
});
|
|
24037
24226
|
/**
|
|
@@ -24088,14 +24277,12 @@ var PipelineTemplateSchema$1 = object({
|
|
|
24088
24277
|
var PipelineModelOptionSchema = object({
|
|
24089
24278
|
id: string(),
|
|
24090
24279
|
name: string(),
|
|
24091
|
-
formats: record(string(),
|
|
24092
|
-
downloaded: boolean(),
|
|
24093
|
-
sizeMB: number()
|
|
24094
|
-
})),
|
|
24280
|
+
formats: record(string(), PipelineModelFormatStatusSchema),
|
|
24095
24281
|
group: ModelVariantGroupSchema.optional(),
|
|
24096
24282
|
legacy: boolean().optional(),
|
|
24097
24283
|
provider: ModelProviderIdSchema.optional(),
|
|
24098
|
-
defaultConfidence: number().optional()
|
|
24284
|
+
defaultConfidence: number().optional(),
|
|
24285
|
+
suppliesSteps: array(RootStepSupplySchema).readonly().optional()
|
|
24099
24286
|
});
|
|
24100
24287
|
var ConfigFieldBridge = custom();
|
|
24101
24288
|
var PipelineAddonSchemaSchema = object({
|
|
@@ -24257,6 +24444,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24257
24444
|
}), {
|
|
24258
24445
|
kind: "mutation",
|
|
24259
24446
|
auth: "admin"
|
|
24447
|
+
}), method(object({
|
|
24448
|
+
nodeId: string(),
|
|
24449
|
+
deviceIds: array(number()).readonly().optional(),
|
|
24450
|
+
dryRun: boolean()
|
|
24451
|
+
}), object({
|
|
24452
|
+
entries: array(object({
|
|
24453
|
+
deviceId: number(),
|
|
24454
|
+
keys: array(string()).readonly()
|
|
24455
|
+
})).readonly(),
|
|
24456
|
+
refused: array(object({
|
|
24457
|
+
deviceId: number(),
|
|
24458
|
+
reason: string()
|
|
24459
|
+
})).readonly()
|
|
24460
|
+
}), {
|
|
24461
|
+
kind: "mutation",
|
|
24462
|
+
auth: "admin"
|
|
24260
24463
|
}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
|
|
24261
24464
|
/** `<backend>:<device>`, e.g. `openvino:gpu`. */
|
|
24262
24465
|
deviceKey: string(),
|
|
@@ -24293,11 +24496,11 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24293
24496
|
}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
|
|
24294
24497
|
addonId: string(),
|
|
24295
24498
|
modelId: string(),
|
|
24296
|
-
format: ModelFormatSchema$
|
|
24499
|
+
format: ModelFormatSchema$2
|
|
24297
24500
|
}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
|
|
24298
24501
|
addonId: string(),
|
|
24299
24502
|
modelId: string(),
|
|
24300
|
-
format: ModelFormatSchema$
|
|
24503
|
+
format: ModelFormatSchema$2
|
|
24301
24504
|
}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
|
|
24302
24505
|
steps: array(PipelineStepInputSchema).min(1),
|
|
24303
24506
|
frame: FrameInputSchema.optional(),
|
|
@@ -24363,7 +24566,16 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24363
24566
|
* `device-not-servable`), and nothing reaches the camera's live
|
|
24364
24567
|
* trace stream. Absent ⇒ unchanged behaviour.
|
|
24365
24568
|
*/
|
|
24366
|
-
replay: literal(true).optional()
|
|
24569
|
+
replay: literal(true).optional(),
|
|
24570
|
+
/**
|
|
24571
|
+
* Root-supplied detections for the tree's ROOT step (D730). Set by
|
|
24572
|
+
* `runDetailSubtree` when the camera's root model supplies a crop-kind
|
|
24573
|
+
* step (a Frigate+ `license_plate` for `plate-detection`): the step is
|
|
24574
|
+
* NOT inferred, these boxes are its output, and its children (the plate
|
|
24575
|
+
* reader) run on them through their own crop policy. Boxes are in the
|
|
24576
|
+
* PIXELS of the image this call carries. Absent ⇒ the root step runs.
|
|
24577
|
+
*/
|
|
24578
|
+
suppliedRoot: SuppliedRootOutputSchema.optional()
|
|
24367
24579
|
}), PipelineRunResultBridge, { kind: "mutation" }), method(object({
|
|
24368
24580
|
steps: array(PipelineStepInputSchema).min(1),
|
|
24369
24581
|
frames: array(FrameInputSchema).min(1).max(255),
|
|
@@ -24445,6 +24657,352 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
|
|
|
24445
24657
|
filename: string().optional(),
|
|
24446
24658
|
settings: record(string(), unknown()).optional()
|
|
24447
24659
|
}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
|
|
24660
|
+
/**
|
|
24661
|
+
* Wire shapes of the Load balancing surface (D748): the session placement
|
|
24662
|
+
* policy, the atomic share write, the observed placement statistics, the
|
|
24663
|
+
* hardware share suggestion and the stale device pins.
|
|
24664
|
+
*/
|
|
24665
|
+
/**
|
|
24666
|
+
* How a new detection session picks its node and device.
|
|
24667
|
+
* - `least-loaded` — the historical rule: lowest `attached / weight`, a
|
|
24668
|
+
* constant node order at a tie (D37). An idle node always ties at 0, so a
|
|
24669
|
+
* weight only bites once a node already holds a session.
|
|
24670
|
+
* - `share` — the share of PARALLEL sessions is held to the weights, and a
|
|
24671
|
+
* full or drowning node yields to a free one (D748).
|
|
24672
|
+
*/
|
|
24673
|
+
var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
|
|
24674
|
+
var LoadBalancingSharesInputSchema = object({
|
|
24675
|
+
/** nodeId → share (> 0). A node left out keeps its weight. */
|
|
24676
|
+
nodes: record(string(), number().positive()).default({}),
|
|
24677
|
+
/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
|
|
24678
|
+
devices: record(string(), record(string(), number().positive())).default({})
|
|
24679
|
+
});
|
|
24680
|
+
var PlacementStatsInputSchema = object({
|
|
24681
|
+
/** Window the observed shares are averaged over (default 1 h, max 24 h). */
|
|
24682
|
+
windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
|
|
24683
|
+
var PlacementDeviceStatsSchema = object({
|
|
24684
|
+
deviceKey: string(),
|
|
24685
|
+
/** Sessions running on this device now. */
|
|
24686
|
+
sessionsNow: number(),
|
|
24687
|
+
/** Sessions started on this device inside the window. */
|
|
24688
|
+
sessionsStarted: number(),
|
|
24689
|
+
/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
|
|
24690
|
+
observedShare: number().nullable()
|
|
24691
|
+
});
|
|
24692
|
+
var PlacementNodeStatsSchema = object({
|
|
24693
|
+
nodeId: string(),
|
|
24694
|
+
sessionsNow: number(),
|
|
24695
|
+
sessionsStarted: number(),
|
|
24696
|
+
/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
|
|
24697
|
+
observedShare: number().nullable(),
|
|
24698
|
+
/** Most sessions this node ran at once inside the window. */
|
|
24699
|
+
peakSessions: number(),
|
|
24700
|
+
/** Sessions a share election handed elsewhere because this node was full or drowning. */
|
|
24701
|
+
yieldsAway: number(),
|
|
24702
|
+
devices: array(PlacementDeviceStatsSchema).readonly()
|
|
24703
|
+
});
|
|
24704
|
+
/** A camera's device pin that the session path cannot honour. */
|
|
24705
|
+
var StaleDevicePinSchema = object({
|
|
24706
|
+
deviceId: number(),
|
|
24707
|
+
deviceKey: string(),
|
|
24708
|
+
/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
|
|
24709
|
+
reason: _enum(["disabled", "absent"])
|
|
24710
|
+
});
|
|
24711
|
+
var PlacementStatsSchema = object({
|
|
24712
|
+
policy: SessionPlacementPolicySchema,
|
|
24713
|
+
windowMs: number(),
|
|
24714
|
+
/** How much of the window was actually observed (the hub keeps it in memory). */
|
|
24715
|
+
observedForMs: number(),
|
|
24716
|
+
sessionsNow: number(),
|
|
24717
|
+
/** Most parallel sessions across the cluster inside the window. */
|
|
24718
|
+
clusterPeakSessions: number(),
|
|
24719
|
+
nodes: array(PlacementNodeStatsSchema).readonly(),
|
|
24720
|
+
stalePins: array(StaleDevicePinSchema).readonly()
|
|
24721
|
+
});
|
|
24722
|
+
var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
|
|
24723
|
+
var SuggestedDeviceShareSchema = object({
|
|
24724
|
+
deviceKey: string(),
|
|
24725
|
+
/** Share of the node (0–100, rounded). */
|
|
24726
|
+
share: number(),
|
|
24727
|
+
modelId: string().nullable(),
|
|
24728
|
+
/** Inferences per second at that model, from the measured table. */
|
|
24729
|
+
fps: number().nullable(),
|
|
24730
|
+
measured: boolean(),
|
|
24731
|
+
/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
|
|
24732
|
+
suggestedMaxSessions: number().nullable()
|
|
24733
|
+
});
|
|
24734
|
+
var SuggestedNodeShareSchema = object({
|
|
24735
|
+
nodeId: string(),
|
|
24736
|
+
/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
|
|
24737
|
+
share: number().nullable(),
|
|
24738
|
+
/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
|
|
24739
|
+
capacitySessions: number(),
|
|
24740
|
+
devices: array(SuggestedDeviceShareSchema).readonly(),
|
|
24741
|
+
skippedReason: string().nullable()
|
|
24742
|
+
});
|
|
24743
|
+
var SuggestSharesResultSchema = object({
|
|
24744
|
+
headroom: number(),
|
|
24745
|
+
/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
|
|
24746
|
+
cameraFps: number(),
|
|
24747
|
+
/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
|
|
24748
|
+
iterations: number(),
|
|
24749
|
+
nodes: array(SuggestedNodeShareSchema).readonly()
|
|
24750
|
+
});
|
|
24751
|
+
/**
|
|
24752
|
+
* Where the node and device shares come from (D750).
|
|
24753
|
+
* - `auto` — computed by the system from the cluster's measured capacity at
|
|
24754
|
+
* the Auto tune models, and recomputed whenever a node or device joins,
|
|
24755
|
+
* leaves, is switched on or off, or changes model.
|
|
24756
|
+
* - `manual` — the operator's stored sliders. A node or device that cannot
|
|
24757
|
+
* take sessions gives its share to the others in proportion; the stored
|
|
24758
|
+
* values are never rewritten for that.
|
|
24759
|
+
*/
|
|
24760
|
+
var ShareSourceSchema = _enum(["auto", "manual"]);
|
|
24761
|
+
var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
|
|
24762
|
+
object({
|
|
24763
|
+
nodes: record(string(), number()),
|
|
24764
|
+
devices: record(string(), record(string(), number()))
|
|
24765
|
+
});
|
|
24766
|
+
var EffectiveDeviceShareSchema = object({
|
|
24767
|
+
deviceKey: string(),
|
|
24768
|
+
/** Can take sessions now (enabled, available, can run the root). */
|
|
24769
|
+
eligible: boolean(),
|
|
24770
|
+
/** The share the source assigns, as a percentage of the node's devices. */
|
|
24771
|
+
configuredPct: number(),
|
|
24772
|
+
/** The share actually used, after an ineligible device's share went to the others. */
|
|
24773
|
+
effectivePct: number()
|
|
24774
|
+
});
|
|
24775
|
+
var EffectiveNodeShareSchema = object({
|
|
24776
|
+
nodeId: string(),
|
|
24777
|
+
eligible: boolean(),
|
|
24778
|
+
configuredPct: number(),
|
|
24779
|
+
effectivePct: number(),
|
|
24780
|
+
devices: array(EffectiveDeviceShareSchema).readonly()
|
|
24781
|
+
});
|
|
24782
|
+
var EffectiveSharesSchema = object({
|
|
24783
|
+
source: ShareSourceSchema,
|
|
24784
|
+
policy: SessionPlacementPolicySchema,
|
|
24785
|
+
/** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
|
|
24786
|
+
autoPending: boolean(),
|
|
24787
|
+
/** When the automatic shares were last computed (ms epoch); null = never. */
|
|
24788
|
+
computedAt: number().nullable(),
|
|
24789
|
+
/** What made the system recompute them last. */
|
|
24790
|
+
trigger: string().nullable(),
|
|
24791
|
+
nodes: array(EffectiveNodeShareSchema).readonly(),
|
|
24792
|
+
/** The relative weights the election reads (before eligibility). */
|
|
24793
|
+
nodeWeights: record(string(), number()),
|
|
24794
|
+
deviceWeights: record(string(), record(string(), number()))
|
|
24795
|
+
});
|
|
24796
|
+
/**
|
|
24797
|
+
* The wire shapes of the Auto tune plan and apply (D745), used by the
|
|
24798
|
+
* `pipeline-orchestrator` cap. The recommender's own types
|
|
24799
|
+
* (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
|
|
24800
|
+
* schemas are what crosses the cap boundary.
|
|
24801
|
+
*/
|
|
24802
|
+
var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
|
|
24803
|
+
var HardwareClassIdSchema = _enum([
|
|
24804
|
+
"intel-core-ultra",
|
|
24805
|
+
"intel-n-series",
|
|
24806
|
+
"apple-m-base",
|
|
24807
|
+
"apple-m-pro",
|
|
24808
|
+
"unknown"
|
|
24809
|
+
]);
|
|
24810
|
+
var AcceleratorKindSchema = _enum([
|
|
24811
|
+
"intel-npu",
|
|
24812
|
+
"intel-igpu",
|
|
24813
|
+
"x86-cpu",
|
|
24814
|
+
"arm-cpu",
|
|
24815
|
+
"apple-ane",
|
|
24816
|
+
"coral"
|
|
24817
|
+
]);
|
|
24818
|
+
var RecommendationReasonSchema = discriminatedUnion("kind", [
|
|
24819
|
+
object({
|
|
24820
|
+
kind: literal("fits"),
|
|
24821
|
+
utilisation: number()
|
|
24822
|
+
}),
|
|
24823
|
+
object({
|
|
24824
|
+
kind: literal("tie-faster"),
|
|
24825
|
+
over: string(),
|
|
24826
|
+
recallDelta: number()
|
|
24827
|
+
}),
|
|
24828
|
+
object({
|
|
24829
|
+
kind: literal("stepped-down"),
|
|
24830
|
+
from: string(),
|
|
24831
|
+
to: string(),
|
|
24832
|
+
limitedBy: string()
|
|
24833
|
+
}),
|
|
24834
|
+
object({
|
|
24835
|
+
kind: literal("no-fit-lightest"),
|
|
24836
|
+
utilisation: number()
|
|
24837
|
+
}),
|
|
24838
|
+
object({
|
|
24839
|
+
kind: literal("derived-latency"),
|
|
24840
|
+
modelId: string()
|
|
24841
|
+
}),
|
|
24842
|
+
object({
|
|
24843
|
+
kind: literal("estimated-load"),
|
|
24844
|
+
observedForMs: number().nullable()
|
|
24845
|
+
}),
|
|
24846
|
+
object({ kind: literal("cpu-device") }),
|
|
24847
|
+
object({ kind: literal("coral-untouched") }),
|
|
24848
|
+
object({ kind: literal("device-disabled") }),
|
|
24849
|
+
object({ kind: literal("device-unavailable") }),
|
|
24850
|
+
object({ kind: literal("node-offline") }),
|
|
24851
|
+
object({ kind: literal("no-hardware-facts") }),
|
|
24852
|
+
object({
|
|
24853
|
+
kind: literal("no-measured-data"),
|
|
24854
|
+
hardwareClass: HardwareClassIdSchema
|
|
24855
|
+
}),
|
|
24856
|
+
object({
|
|
24857
|
+
kind: literal("no-family-build"),
|
|
24858
|
+
format: ModelFormatSchema$1
|
|
24859
|
+
})
|
|
24860
|
+
]);
|
|
24861
|
+
var DeviceDemandSchema = object({
|
|
24862
|
+
nodeId: string(),
|
|
24863
|
+
deviceKey: string(),
|
|
24864
|
+
demandFps: number(),
|
|
24865
|
+
maxCameraFps: number(),
|
|
24866
|
+
alwaysOnCameras: number(),
|
|
24867
|
+
onMotionSessions: number(),
|
|
24868
|
+
onMotionSource: _enum([
|
|
24869
|
+
"observed-24h",
|
|
24870
|
+
"estimate",
|
|
24871
|
+
"none"
|
|
24872
|
+
]),
|
|
24873
|
+
observedForMs: number().nullable(),
|
|
24874
|
+
/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
|
|
24875
|
+
placement: SessionPlacementPolicySchema
|
|
24876
|
+
});
|
|
24877
|
+
var DeviceModelChoiceSchema = object({
|
|
24878
|
+
modelId: string(),
|
|
24879
|
+
p50Ms: number(),
|
|
24880
|
+
fps: number(),
|
|
24881
|
+
measured: boolean(),
|
|
24882
|
+
utilisation: number(),
|
|
24883
|
+
personRecall: number()
|
|
24884
|
+
});
|
|
24885
|
+
var DeviceRecommendationSchema = object({
|
|
24886
|
+
deviceKey: string(),
|
|
24887
|
+
accelerator: AcceleratorKindSchema.nullable(),
|
|
24888
|
+
enabled: boolean(),
|
|
24889
|
+
available: boolean(),
|
|
24890
|
+
demand: DeviceDemandSchema.nullable(),
|
|
24891
|
+
chosen: DeviceModelChoiceSchema.nullable(),
|
|
24892
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24893
|
+
});
|
|
24894
|
+
var NodeRecommendationSchema = object({
|
|
24895
|
+
nodeId: string(),
|
|
24896
|
+
reachable: boolean(),
|
|
24897
|
+
hardwareClass: HardwareClassIdSchema.nullable(),
|
|
24898
|
+
cpuModel: string().nullable(),
|
|
24899
|
+
skipped: boolean(),
|
|
24900
|
+
acceleratorModelId: string().nullable(),
|
|
24901
|
+
devices: array(DeviceRecommendationSchema).readonly(),
|
|
24902
|
+
reasons: array(RecommendationReasonSchema).readonly()
|
|
24903
|
+
});
|
|
24904
|
+
var ModelPinChangeSchema = object({
|
|
24905
|
+
stepId: string(),
|
|
24906
|
+
before: string().nullable(),
|
|
24907
|
+
after: string().nullable()
|
|
24908
|
+
});
|
|
24909
|
+
var NodeDeviceChangeSchema = object({
|
|
24910
|
+
nodeId: string(),
|
|
24911
|
+
deviceKey: string(),
|
|
24912
|
+
madeExplicit: boolean(),
|
|
24913
|
+
modelPins: array(ModelPinChangeSchema).readonly(),
|
|
24914
|
+
thresholds: array(object({
|
|
24915
|
+
stepId: string(),
|
|
24916
|
+
keys: array(string()).readonly()
|
|
24917
|
+
})).readonly()
|
|
24918
|
+
});
|
|
24919
|
+
var CameraOverrideClearSchema = object({
|
|
24920
|
+
deviceId: number(),
|
|
24921
|
+
source: _enum(["step-override", "wholesale"]),
|
|
24922
|
+
nodeId: string(),
|
|
24923
|
+
deviceKey: string().nullable(),
|
|
24924
|
+
stepId: string(),
|
|
24925
|
+
modelIdBefore: string().nullable(),
|
|
24926
|
+
keys: array(string()).readonly()
|
|
24927
|
+
});
|
|
24928
|
+
var DetectorStoreClearSchema = object({
|
|
24929
|
+
deviceId: number(),
|
|
24930
|
+
keys: array(string()).readonly()
|
|
24931
|
+
});
|
|
24932
|
+
var AutoTuneWarningSchema = discriminatedUnion("kind", [
|
|
24933
|
+
object({
|
|
24934
|
+
kind: literal("detector-store-cluster-wide"),
|
|
24935
|
+
skippedNodes: array(string()).readonly()
|
|
24936
|
+
}),
|
|
24937
|
+
object({
|
|
24938
|
+
kind: literal("detector-store-unreadable"),
|
|
24939
|
+
error: string()
|
|
24940
|
+
}),
|
|
24941
|
+
object({
|
|
24942
|
+
kind: literal("coral-enabled"),
|
|
24943
|
+
nodeId: string(),
|
|
24944
|
+
deviceKey: string()
|
|
24945
|
+
})
|
|
24946
|
+
]);
|
|
24947
|
+
var AutoTuneOptionsSchema = object({
|
|
24948
|
+
/** Share of each accelerator's throughput kept free (0.3–0.5). */
|
|
24949
|
+
headroom: number().min(.3).max(.5).default(.4),
|
|
24950
|
+
/**
|
|
24951
|
+
* What-if shares (D748): plan as if these node/device shares were stored
|
|
24952
|
+
* and the policy were `share`. Absent = the stored shares under the stored
|
|
24953
|
+
* policy. A what-if plan is for display; apply always re-plans from what
|
|
24954
|
+
* is stored.
|
|
24955
|
+
*/
|
|
24956
|
+
shares: LoadBalancingSharesInputSchema.optional()
|
|
24957
|
+
});
|
|
24958
|
+
var AutoTunePlanSchema = object({
|
|
24959
|
+
/** Hash of everything the apply will write — the apply refuses a different one. */
|
|
24960
|
+
planHash: string(),
|
|
24961
|
+
family: literal("yolov9"),
|
|
24962
|
+
headroom: number(),
|
|
24963
|
+
/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
|
|
24964
|
+
whatIf: boolean(),
|
|
24965
|
+
generatedAt: number(),
|
|
24966
|
+
nodes: array(NodeRecommendationSchema).readonly(),
|
|
24967
|
+
nodeChanges: array(NodeDeviceChangeSchema).readonly(),
|
|
24968
|
+
cameraClears: array(CameraOverrideClearSchema).readonly(),
|
|
24969
|
+
detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
|
|
24970
|
+
warnings: array(AutoTuneWarningSchema).readonly()
|
|
24971
|
+
});
|
|
24972
|
+
var AutoTuneApplyInputSchema = object({
|
|
24973
|
+
planHash: string(),
|
|
24974
|
+
headroom: number().min(.3).max(.5).default(.4)
|
|
24975
|
+
});
|
|
24976
|
+
var AutoTunePhaseResultSchema = object({
|
|
24977
|
+
phase: _enum([
|
|
24978
|
+
"download",
|
|
24979
|
+
"camera-overrides",
|
|
24980
|
+
"detector-thresholds",
|
|
24981
|
+
"node-models",
|
|
24982
|
+
"redispatch"
|
|
24983
|
+
]),
|
|
24984
|
+
ok: boolean(),
|
|
24985
|
+
detail: string()
|
|
24986
|
+
});
|
|
24987
|
+
var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
|
|
24988
|
+
object({
|
|
24989
|
+
kind: literal("applied"),
|
|
24990
|
+
planHash: string(),
|
|
24991
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24992
|
+
}),
|
|
24993
|
+
object({
|
|
24994
|
+
kind: literal("aborted"),
|
|
24995
|
+
phases: array(AutoTunePhaseResultSchema).readonly()
|
|
24996
|
+
}),
|
|
24997
|
+
object({
|
|
24998
|
+
kind: literal("stale"),
|
|
24999
|
+
plan: AutoTunePlanSchema
|
|
25000
|
+
}),
|
|
25001
|
+
object({
|
|
25002
|
+
kind: literal("refused"),
|
|
25003
|
+
reason: _enum(["apply-in-progress"])
|
|
25004
|
+
})
|
|
25005
|
+
]);
|
|
24448
25006
|
object({
|
|
24449
25007
|
activeCameras: number(),
|
|
24450
25008
|
throttledCameras: number(),
|
|
@@ -25465,7 +26023,22 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
|
|
|
25465
26023
|
*/
|
|
25466
26024
|
cropJpeg: string().optional(),
|
|
25467
26025
|
parent: DetailParentSchema,
|
|
25468
|
-
steps: array(string()).optional()
|
|
26026
|
+
steps: array(string()).optional(),
|
|
26027
|
+
/**
|
|
26028
|
+
* The camera's root model already drew this step's boxes (D730): a
|
|
26029
|
+
* `license_plate` inside the parent vehicle. The named step is NOT
|
|
26030
|
+
* inferred — these FRAME-space boxes are its output — and its
|
|
26031
|
+
* requested children (the plate reader) run on them. Absent ⇒ every
|
|
26032
|
+
* requested step infers as before.
|
|
26033
|
+
*/
|
|
26034
|
+
supplied: object({
|
|
26035
|
+
stepId: string(),
|
|
26036
|
+
modelId: string(),
|
|
26037
|
+
boxes: array(object({
|
|
26038
|
+
bbox: NativeCropBboxSchema,
|
|
26039
|
+
score: number()
|
|
26040
|
+
})).min(1)
|
|
26041
|
+
}).optional()
|
|
25469
26042
|
}), object({ details: array(DetailResultSchema) }).nullable(), { kind: "mutation" }), method(object({
|
|
25470
26043
|
/** Catalog step id, e.g. `clip-embedding`. */
|
|
25471
26044
|
stepId: string(),
|
|
@@ -25610,7 +26183,6 @@ var CameraStepOverridePatchSchema = object({
|
|
|
25610
26183
|
settings: record(string(), unknown()).readonly().optional()
|
|
25611
26184
|
});
|
|
25612
26185
|
var CameraPipelineSettingsSchema = object({
|
|
25613
|
-
pinnedAgentNodeId: string().optional(),
|
|
25614
26186
|
stepToggles: record(string(), boolean()).optional(),
|
|
25615
26187
|
stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
|
|
25616
26188
|
pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
|
|
@@ -26109,12 +26681,6 @@ method(object({
|
|
|
26109
26681
|
}), object({ success: literal(true) }), {
|
|
26110
26682
|
kind: "mutation",
|
|
26111
26683
|
auth: "admin"
|
|
26112
|
-
}), method(object({
|
|
26113
|
-
agentNodeId: string(),
|
|
26114
|
-
detectWeight: number().positive().nullable()
|
|
26115
|
-
}), object({ success: literal(true) }), {
|
|
26116
|
-
kind: "mutation",
|
|
26117
|
-
auth: "admin"
|
|
26118
26684
|
}), method(object({
|
|
26119
26685
|
agentNodeId: string(),
|
|
26120
26686
|
detect: boolean().nullable().optional(),
|
|
@@ -26156,6 +26722,15 @@ method(object({
|
|
|
26156
26722
|
}), {
|
|
26157
26723
|
kind: "mutation",
|
|
26158
26724
|
auth: "admin"
|
|
26725
|
+
}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
|
|
26726
|
+
kind: "mutation",
|
|
26727
|
+
auth: "admin"
|
|
26728
|
+
}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
|
|
26729
|
+
kind: "mutation",
|
|
26730
|
+
auth: "admin"
|
|
26731
|
+
}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
|
|
26732
|
+
kind: "mutation",
|
|
26733
|
+
auth: "admin"
|
|
26159
26734
|
}), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
|
|
26160
26735
|
deviceId: number(),
|
|
26161
26736
|
addonId: string(),
|
|
@@ -28959,6 +29534,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
|
|
|
28959
29534
|
*/
|
|
28960
29535
|
alive: boolean()
|
|
28961
29536
|
})), method(object({
|
|
29537
|
+
deviceId: number().int().nonnegative(),
|
|
29538
|
+
sessionId: string(),
|
|
29539
|
+
downlinkMbps: number().nonnegative()
|
|
29540
|
+
}), object({
|
|
29541
|
+
outcome: _enum(["switching", "held"]),
|
|
29542
|
+
tier: CamProfileSchema.nullable(),
|
|
29543
|
+
reason: string()
|
|
29544
|
+
}), { kind: "mutation" }), method(object({
|
|
28962
29545
|
deviceId: number().int().nonnegative(),
|
|
28963
29546
|
sessionId: string()
|
|
28964
29547
|
}), WebrtcSessionDebugSchema, { kind: "query" });
|
|
@@ -31670,7 +32253,8 @@ var ConnectionEndpointSchema = object({
|
|
|
31670
32253
|
"lan-ipv6",
|
|
31671
32254
|
"public",
|
|
31672
32255
|
"loopback",
|
|
31673
|
-
"app-link"
|
|
32256
|
+
"app-link",
|
|
32257
|
+
"custom"
|
|
31674
32258
|
]),
|
|
31675
32259
|
/**
|
|
31676
32260
|
* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
|
|
@@ -31739,7 +32323,7 @@ var GetConnectionEndpointsResultSchema = object({
|
|
|
31739
32323
|
localPort: AdvertisedLocalPortSchema
|
|
31740
32324
|
});
|
|
31741
32325
|
/**
|
|
31742
|
-
* The address flagged for notification
|
|
32326
|
+
* The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
|
|
31743
32327
|
* since D709 is the CamStack app link; `resolved` reports the effective value,
|
|
31744
32328
|
* so the UI can show it either way.
|
|
31745
32329
|
*/
|
|
@@ -31772,6 +32356,72 @@ var ViewerEndpointsSchema = object({
|
|
|
31772
32356
|
/** What the ranking currently resolves to (may be empty if nothing is up). */
|
|
31773
32357
|
resolved: array(string()).readonly()
|
|
31774
32358
|
});
|
|
32359
|
+
/**
|
|
32360
|
+
* DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
|
|
32361
|
+
* for addons built against it): `cluster` is the `internal` role, `browser`
|
|
32362
|
+
* the `publicEndpoint` role; `override` is the flagged address.
|
|
32363
|
+
*/
|
|
32364
|
+
var HubAddressSnapshotSchema = object({
|
|
32365
|
+
override: string().nullable(),
|
|
32366
|
+
resolved: string().nullable(),
|
|
32367
|
+
source: _enum([
|
|
32368
|
+
"override",
|
|
32369
|
+
"auto",
|
|
32370
|
+
"none"
|
|
32371
|
+
])
|
|
32372
|
+
});
|
|
32373
|
+
var HubAddressesSchema = object({
|
|
32374
|
+
cluster: HubAddressSnapshotSchema,
|
|
32375
|
+
browser: HubAddressSnapshotSchema
|
|
32376
|
+
});
|
|
32377
|
+
/**
|
|
32378
|
+
* What an address is used for (`hub-address.ts`, D734). `appConnections` is
|
|
32379
|
+
* many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
|
|
32380
|
+
* by at most one address.
|
|
32381
|
+
*/
|
|
32382
|
+
var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
|
|
32383
|
+
var RoleSourceSchema = _enum([
|
|
32384
|
+
"flagged",
|
|
32385
|
+
"auto",
|
|
32386
|
+
"none"
|
|
32387
|
+
]);
|
|
32388
|
+
/** One single-valued role: the flagged address, the one in use, and why. */
|
|
32389
|
+
var HubAddressRoleResolutionSchema = object({
|
|
32390
|
+
/** The address carrying the flag, or null = automatic. */
|
|
32391
|
+
flagged: string().nullable(),
|
|
32392
|
+
/** The address in use, or null when nothing qualifies (never loopback). */
|
|
32393
|
+
resolved: string().nullable(),
|
|
32394
|
+
source: RoleSourceSchema
|
|
32395
|
+
});
|
|
32396
|
+
var HubAppConnectionsResolutionSchema = object({
|
|
32397
|
+
/** The addresses flagged `appConnections`, or empty = automatic. */
|
|
32398
|
+
flagged: array(string()).readonly(),
|
|
32399
|
+
/** What the apps race right now. */
|
|
32400
|
+
resolved: array(string()).readonly(),
|
|
32401
|
+
source: RoleSourceSchema
|
|
32402
|
+
});
|
|
32403
|
+
var HubAddressBookSchema = object({
|
|
32404
|
+
rows: array(ConnectionEndpointSchema.extend({
|
|
32405
|
+
/** In the hub's detected palette right now. */
|
|
32406
|
+
detected: boolean(),
|
|
32407
|
+
/** Entered by the operator (removable). */
|
|
32408
|
+
custom: boolean(),
|
|
32409
|
+
/** The roles explicitly flagged on this address. */
|
|
32410
|
+
flags: array(HubAddressRoleSchema).readonly(),
|
|
32411
|
+
/** The roles this address serves right now — flagged or automatic. */
|
|
32412
|
+
inUse: array(HubAddressRoleSchema).readonly(),
|
|
32413
|
+
/** The roles this address may be flagged with. */
|
|
32414
|
+
eligible: array(HubAddressRoleSchema).readonly()
|
|
32415
|
+
})).readonly(),
|
|
32416
|
+
roles: object({
|
|
32417
|
+
appConnections: HubAppConnectionsResolutionSchema,
|
|
32418
|
+
notificationTaps: HubAddressRoleResolutionSchema,
|
|
32419
|
+
internal: HubAddressRoleResolutionSchema,
|
|
32420
|
+
publicEndpoint: HubAddressRoleResolutionSchema
|
|
32421
|
+
}),
|
|
32422
|
+
/** The `hub=` an app link carries (D709), or null. */
|
|
32423
|
+
appLinkHub: string().nullable()
|
|
32424
|
+
});
|
|
31775
32425
|
var AllowedAddressesSchema = object({
|
|
31776
32426
|
/**
|
|
31777
32427
|
* Allowlist of interface addresses operators have explicitly opted
|
|
@@ -31815,10 +32465,27 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
|
|
|
31815
32465
|
* tunnel always emits `https://` regardless. */
|
|
31816
32466
|
scheme: _enum(["http", "https"]).optional(),
|
|
31817
32467
|
/** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
|
|
31818
|
-
* an address notification
|
|
32468
|
+
* an address notification taps can be flagged with, not a hub
|
|
31819
32469
|
* route. Default `false`: racers and rankers never see it. */
|
|
31820
32470
|
includeAppLink: boolean().optional()
|
|
31821
|
-
}), 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(
|
|
32471
|
+
}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(object({ scheme: _enum(["http", "https"]).optional() }).optional(), HubAddressBookSchema), method(object({
|
|
32472
|
+
baseUrl: string(),
|
|
32473
|
+
label: string().max(80)
|
|
32474
|
+
}), HubAddressBookSchema, {
|
|
32475
|
+
kind: "mutation",
|
|
32476
|
+
auth: "admin"
|
|
32477
|
+
}), method(object({ baseUrl: string() }), HubAddressBookSchema, {
|
|
32478
|
+
kind: "mutation",
|
|
32479
|
+
auth: "admin"
|
|
32480
|
+
}), method(object({
|
|
32481
|
+
role: HubAddressRoleSchema,
|
|
32482
|
+
baseUrl: string().nullable(),
|
|
32483
|
+
enabled: boolean(),
|
|
32484
|
+
acceptInsecureHttp: boolean().optional()
|
|
32485
|
+
}), HubAddressBookSchema, {
|
|
32486
|
+
kind: "mutation",
|
|
32487
|
+
auth: "admin"
|
|
32488
|
+
}), method(_void(), HubAddressesSchema), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
|
|
31822
32489
|
kind: "mutation",
|
|
31823
32490
|
auth: "admin"
|
|
31824
32491
|
}), method(object({
|
|
@@ -32208,7 +32875,8 @@ var MotionStatusSchema = object({
|
|
|
32208
32875
|
* writes this slice (not even a boot seed), and neither does the runner's
|
|
32209
32876
|
* phase machine: its phase is "a session is attached" for every on-motion
|
|
32210
32877
|
* session, not motion, and it now has its own `DetectionPhaseTransition`.
|
|
32211
|
-
* A provider's `isDetected`
|
|
32878
|
+
* A provider's `isDetected` and `getStatus` answer from the hub's slice
|
|
32879
|
+
* (`hubMotionNativeProvider`).
|
|
32212
32880
|
* - **Sensors** (Home Assistant binary sensors, Homematic, Matter, Alexa
|
|
32213
32881
|
* imports) — the provider pushes both edges itself, from the upstream
|
|
32214
32882
|
* system's own state change. That is the sensor's own fact.
|
|
@@ -37364,6 +38032,16 @@ DeviceType.Camera, method(object({
|
|
|
37364
38032
|
package: array(ZoneRuleSchema).readonly()
|
|
37365
38033
|
});
|
|
37366
38034
|
SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
|
|
38035
|
+
Object.freeze({
|
|
38036
|
+
person: .5,
|
|
38037
|
+
vehicle: .5,
|
|
38038
|
+
animal: .5
|
|
38039
|
+
});
|
|
38040
|
+
Object.freeze({
|
|
38041
|
+
person: .65,
|
|
38042
|
+
vehicle: .65,
|
|
38043
|
+
animal: .65
|
|
38044
|
+
});
|
|
37367
38045
|
/**
|
|
37368
38046
|
* Accessory device helpers — shared across drivers.
|
|
37369
38047
|
*
|
|
@@ -40292,12 +40970,24 @@ Object.freeze({
|
|
|
40292
40970
|
addonId: null,
|
|
40293
40971
|
access: "view"
|
|
40294
40972
|
},
|
|
40973
|
+
"localNetwork.addCustomAddress": {
|
|
40974
|
+
capName: "local-network",
|
|
40975
|
+
capScope: "system",
|
|
40976
|
+
addonId: null,
|
|
40977
|
+
access: "create"
|
|
40978
|
+
},
|
|
40295
40979
|
"localNetwork.downloadCa": {
|
|
40296
40980
|
capName: "local-network",
|
|
40297
40981
|
capScope: "system",
|
|
40298
40982
|
addonId: null,
|
|
40299
40983
|
access: "view"
|
|
40300
40984
|
},
|
|
40985
|
+
"localNetwork.getAddresses": {
|
|
40986
|
+
capName: "local-network",
|
|
40987
|
+
capScope: "system",
|
|
40988
|
+
addonId: null,
|
|
40989
|
+
access: "view"
|
|
40990
|
+
},
|
|
40301
40991
|
"localNetwork.getAllowedAddresses": {
|
|
40302
40992
|
capName: "local-network",
|
|
40303
40993
|
capScope: "system",
|
|
@@ -40310,6 +41000,12 @@ Object.freeze({
|
|
|
40310
41000
|
addonId: null,
|
|
40311
41001
|
access: "view"
|
|
40312
41002
|
},
|
|
41003
|
+
"localNetwork.getHubAddresses": {
|
|
41004
|
+
capName: "local-network",
|
|
41005
|
+
capScope: "system",
|
|
41006
|
+
addonId: null,
|
|
41007
|
+
access: "view"
|
|
41008
|
+
},
|
|
40313
41009
|
"localNetwork.getNotificationEndpoint": {
|
|
40314
41010
|
capName: "local-network",
|
|
40315
41011
|
capScope: "system",
|
|
@@ -40346,6 +41042,12 @@ Object.freeze({
|
|
|
40346
41042
|
addonId: null,
|
|
40347
41043
|
access: "create"
|
|
40348
41044
|
},
|
|
41045
|
+
"localNetwork.removeCustomAddress": {
|
|
41046
|
+
capName: "local-network",
|
|
41047
|
+
capScope: "system",
|
|
41048
|
+
addonId: null,
|
|
41049
|
+
access: "delete"
|
|
41050
|
+
},
|
|
40349
41051
|
"localNetwork.resetAllowlistToBestMatch": {
|
|
40350
41052
|
capName: "local-network",
|
|
40351
41053
|
capScope: "system",
|
|
@@ -40358,6 +41060,12 @@ Object.freeze({
|
|
|
40358
41060
|
addonId: null,
|
|
40359
41061
|
access: "create"
|
|
40360
41062
|
},
|
|
41063
|
+
"localNetwork.setAddressRole": {
|
|
41064
|
+
capName: "local-network",
|
|
41065
|
+
capScope: "system",
|
|
41066
|
+
addonId: null,
|
|
41067
|
+
access: "create"
|
|
41068
|
+
},
|
|
40361
41069
|
"localNetwork.setAllowedAddresses": {
|
|
40362
41070
|
capName: "local-network",
|
|
40363
41071
|
capScope: "system",
|
|
@@ -41852,6 +42560,12 @@ Object.freeze({
|
|
|
41852
42560
|
addonId: null,
|
|
41853
42561
|
access: "delete"
|
|
41854
42562
|
},
|
|
42563
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": {
|
|
42564
|
+
capName: "pipeline-executor",
|
|
42565
|
+
capScope: "system",
|
|
42566
|
+
addonId: null,
|
|
42567
|
+
access: "delete"
|
|
42568
|
+
},
|
|
41855
42569
|
"pipelineExecutor.deleteModel": {
|
|
41856
42570
|
capName: "pipeline-executor",
|
|
41857
42571
|
capScope: "system",
|
|
@@ -42068,6 +42782,12 @@ Object.freeze({
|
|
|
42068
42782
|
addonId: null,
|
|
42069
42783
|
access: "view"
|
|
42070
42784
|
},
|
|
42785
|
+
"pipelineOrchestrator.applyAutoTune": {
|
|
42786
|
+
capName: "pipeline-orchestrator",
|
|
42787
|
+
capScope: "system",
|
|
42788
|
+
addonId: null,
|
|
42789
|
+
access: "create"
|
|
42790
|
+
},
|
|
42071
42791
|
"pipelineOrchestrator.applyDeviceSettingsPatch": {
|
|
42072
42792
|
capName: "pipeline-orchestrator",
|
|
42073
42793
|
capScope: "system",
|
|
@@ -42182,6 +42902,12 @@ Object.freeze({
|
|
|
42182
42902
|
addonId: null,
|
|
42183
42903
|
access: "view"
|
|
42184
42904
|
},
|
|
42905
|
+
"pipelineOrchestrator.getEffectiveShares": {
|
|
42906
|
+
capName: "pipeline-orchestrator",
|
|
42907
|
+
capScope: "system",
|
|
42908
|
+
addonId: null,
|
|
42909
|
+
access: "view"
|
|
42910
|
+
},
|
|
42185
42911
|
"pipelineOrchestrator.getGlobalMetrics": {
|
|
42186
42912
|
capName: "pipeline-orchestrator",
|
|
42187
42913
|
capScope: "system",
|
|
@@ -42218,6 +42944,12 @@ Object.freeze({
|
|
|
42218
42944
|
addonId: null,
|
|
42219
42945
|
access: "view"
|
|
42220
42946
|
},
|
|
42947
|
+
"pipelineOrchestrator.getPlacementStats": {
|
|
42948
|
+
capName: "pipeline-orchestrator",
|
|
42949
|
+
capScope: "system",
|
|
42950
|
+
addonId: null,
|
|
42951
|
+
access: "view"
|
|
42952
|
+
},
|
|
42221
42953
|
"pipelineOrchestrator.getReconcileFromDiskStatus": {
|
|
42222
42954
|
capName: "pipeline-orchestrator",
|
|
42223
42955
|
capScope: "system",
|
|
@@ -42242,6 +42974,12 @@ Object.freeze({
|
|
|
42242
42974
|
addonId: null,
|
|
42243
42975
|
access: "create"
|
|
42244
42976
|
},
|
|
42977
|
+
"pipelineOrchestrator.planAutoTune": {
|
|
42978
|
+
capName: "pipeline-orchestrator",
|
|
42979
|
+
capScope: "system",
|
|
42980
|
+
addonId: null,
|
|
42981
|
+
access: "view"
|
|
42982
|
+
},
|
|
42245
42983
|
"pipelineOrchestrator.rebalance": {
|
|
42246
42984
|
capName: "pipeline-orchestrator",
|
|
42247
42985
|
capScope: "system",
|
|
@@ -42302,12 +43040,6 @@ Object.freeze({
|
|
|
42302
43040
|
addonId: null,
|
|
42303
43041
|
access: "create"
|
|
42304
43042
|
},
|
|
42305
|
-
"pipelineOrchestrator.setAgentDetectWeight": {
|
|
42306
|
-
capName: "pipeline-orchestrator",
|
|
42307
|
-
capScope: "system",
|
|
42308
|
-
addonId: null,
|
|
42309
|
-
access: "create"
|
|
42310
|
-
},
|
|
42311
43043
|
"pipelineOrchestrator.setAgentInferenceDevices": {
|
|
42312
43044
|
capName: "pipeline-orchestrator",
|
|
42313
43045
|
capScope: "system",
|
|
@@ -42362,12 +43094,30 @@ Object.freeze({
|
|
|
42362
43094
|
addonId: null,
|
|
42363
43095
|
access: "create"
|
|
42364
43096
|
},
|
|
43097
|
+
"pipelineOrchestrator.setLoadBalancingShares": {
|
|
43098
|
+
capName: "pipeline-orchestrator",
|
|
43099
|
+
capScope: "system",
|
|
43100
|
+
addonId: null,
|
|
43101
|
+
access: "create"
|
|
43102
|
+
},
|
|
42365
43103
|
"pipelineOrchestrator.setPipelineDevicePin": {
|
|
42366
43104
|
capName: "pipeline-orchestrator",
|
|
42367
43105
|
capScope: "system",
|
|
42368
43106
|
addonId: null,
|
|
42369
43107
|
access: "create"
|
|
42370
43108
|
},
|
|
43109
|
+
"pipelineOrchestrator.setShareSource": {
|
|
43110
|
+
capName: "pipeline-orchestrator",
|
|
43111
|
+
capScope: "system",
|
|
43112
|
+
addonId: null,
|
|
43113
|
+
access: "create"
|
|
43114
|
+
},
|
|
43115
|
+
"pipelineOrchestrator.suggestShares": {
|
|
43116
|
+
capName: "pipeline-orchestrator",
|
|
43117
|
+
capScope: "system",
|
|
43118
|
+
addonId: null,
|
|
43119
|
+
access: "view"
|
|
43120
|
+
},
|
|
42371
43121
|
"pipelineOrchestrator.unassignAudio": {
|
|
42372
43122
|
capName: "pipeline-orchestrator",
|
|
42373
43123
|
capScope: "system",
|
|
@@ -44612,6 +45362,12 @@ Object.freeze({
|
|
|
44612
45362
|
addonId: null,
|
|
44613
45363
|
access: "create"
|
|
44614
45364
|
},
|
|
45365
|
+
"webrtcSession.applyDownlinkProbe": {
|
|
45366
|
+
capName: "webrtc-session",
|
|
45367
|
+
capScope: "device",
|
|
45368
|
+
addonId: null,
|
|
45369
|
+
access: "create"
|
|
45370
|
+
},
|
|
44615
45371
|
"webrtcSession.closeSession": {
|
|
44616
45372
|
capName: "webrtc-session",
|
|
44617
45373
|
capScope: "device",
|
|
@@ -47658,6 +48414,11 @@ Object.freeze({
|
|
|
47658
48414
|
form: "single",
|
|
47659
48415
|
optional: false
|
|
47660
48416
|
}],
|
|
48417
|
+
"pipelineExecutor.clearModelBoundDeviceOverrides": [{
|
|
48418
|
+
name: "deviceIds",
|
|
48419
|
+
form: "array",
|
|
48420
|
+
optional: true
|
|
48421
|
+
}],
|
|
47661
48422
|
"pipelineExecutor.runPipeline": [{
|
|
47662
48423
|
name: "deviceId",
|
|
47663
48424
|
form: "single",
|
|
@@ -48534,6 +49295,11 @@ Object.freeze({
|
|
|
48534
49295
|
form: "single",
|
|
48535
49296
|
optional: false
|
|
48536
49297
|
}],
|
|
49298
|
+
"webrtcSession.applyDownlinkProbe": [{
|
|
49299
|
+
name: "deviceId",
|
|
49300
|
+
form: "single",
|
|
49301
|
+
optional: false
|
|
49302
|
+
}],
|
|
48537
49303
|
"webrtcSession.closeSession": [{
|
|
48538
49304
|
name: "deviceId",
|
|
48539
49305
|
form: "single",
|
|
@@ -48763,6 +49529,8 @@ new Map(Object.entries({
|
|
|
48763
49529
|
"detection-blind": "device-events",
|
|
48764
49530
|
"node-online": "system",
|
|
48765
49531
|
"node-offline": "system",
|
|
49532
|
+
"node-restarting": "system",
|
|
49533
|
+
"node-updating": "system",
|
|
48766
49534
|
"node-inference-unavailable": "system",
|
|
48767
49535
|
"addon-crash-loop": "system",
|
|
48768
49536
|
"addon-update-available": "system",
|
|
@@ -48840,6 +49608,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
48840
49608
|
kinds: [
|
|
48841
49609
|
"node-offline",
|
|
48842
49610
|
"node-online",
|
|
49611
|
+
"node-restarting",
|
|
48843
49612
|
"node-inference-unavailable"
|
|
48844
49613
|
]
|
|
48845
49614
|
},
|
|
@@ -48861,6 +49630,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
48861
49630
|
label: "Server & container updates",
|
|
48862
49631
|
kinds: [
|
|
48863
49632
|
"server-update-available",
|
|
49633
|
+
"node-updating",
|
|
48864
49634
|
"server-updated",
|
|
48865
49635
|
"wrapper-update-available"
|
|
48866
49636
|
]
|
|
@@ -49008,6 +49778,7 @@ var STATE_SUMMARY_SECTION_VARS = [
|
|
|
49008
49778
|
kinds: [
|
|
49009
49779
|
"node-offline",
|
|
49010
49780
|
"node-online",
|
|
49781
|
+
"node-restarting",
|
|
49011
49782
|
"node-inference-unavailable"
|
|
49012
49783
|
]
|
|
49013
49784
|
},
|
|
@@ -49029,6 +49800,7 @@ var STATE_SUMMARY_SECTION_VARS = [
|
|
|
49029
49800
|
example: "server 1.2.377 → 1.2.378",
|
|
49030
49801
|
kinds: [
|
|
49031
49802
|
"server-update-available",
|
|
49803
|
+
"node-updating",
|
|
49032
49804
|
"server-updated",
|
|
49033
49805
|
"wrapper-update-available"
|
|
49034
49806
|
]
|
|
@@ -49061,7 +49833,7 @@ var STATE_SUMMARY_VARS = [
|
|
|
49061
49833
|
{
|
|
49062
49834
|
name: "summarySection",
|
|
49063
49835
|
label: "Summary: this section",
|
|
49064
|
-
description: "The section a per-section summary row is about
|
|
49836
|
+
description: "The section a per-section summary row is about; on a summary sent as one message, every section it reports, comma-separated.",
|
|
49065
49837
|
example: "Batterie scariche",
|
|
49066
49838
|
group: "system",
|
|
49067
49839
|
families: ["rule"],
|
|
@@ -96754,7 +97526,7 @@ function createBoundedFfmpegRunner(input) {
|
|
|
96754
97526
|
code: null,
|
|
96755
97527
|
timedOut: false,
|
|
96756
97528
|
spawnFailed: true,
|
|
96757
|
-
stderr: `no pinned ffmpeg on this node
|
|
97529
|
+
stderr: `no pinned ffmpeg on this node: ${err instanceof Error ? err.message : String(err)}`
|
|
96758
97530
|
};
|
|
96759
97531
|
}
|
|
96760
97532
|
return await new Promise((resolve) => {
|
|
@@ -116003,7 +116775,6 @@ var HAP_STREAM_PREFERENCE_OPTIONS = [
|
|
|
116003
116775
|
];
|
|
116004
116776
|
var DEFAULT_CONFIG = {
|
|
116005
116777
|
bridgeName: "CamStack Bridge",
|
|
116006
|
-
port: 0,
|
|
116007
116778
|
fixedPin: "",
|
|
116008
116779
|
interfaceName: "",
|
|
116009
116780
|
ptzPulseMs: 400,
|
|
@@ -116680,20 +117451,11 @@ var ExportHapAddon = class extends BaseAddon {
|
|
|
116680
117451
|
type: "text",
|
|
116681
117452
|
key: "bridgeName",
|
|
116682
117453
|
label: "Installation name",
|
|
116683
|
-
description: "
|
|
117454
|
+
description: "The name of the shared bridge that carries every exposed device that is not a camera (switches, sensors, locks, alarm panels) — what iOS Home lists under Add Accessory. Cameras are never bridged: each one is published as its own accessory under its device name. Set it before you add the bridge in iOS Home.",
|
|
116684
117455
|
default: DEFAULT_CONFIG.bridgeName,
|
|
116685
117456
|
requiresRestart: true,
|
|
116686
117457
|
placement: { tab: "advanced" }
|
|
116687
117458
|
}),
|
|
116688
|
-
this.field({
|
|
116689
|
-
type: "number",
|
|
116690
|
-
key: "port",
|
|
116691
|
-
label: "HAP port",
|
|
116692
|
-
description: "Local port for the HAP server. 0 = random ephemeral port (recommended).",
|
|
116693
|
-
default: DEFAULT_CONFIG.port,
|
|
116694
|
-
requiresRestart: true,
|
|
116695
|
-
placement: { tab: "advanced" }
|
|
116696
|
-
}),
|
|
116697
117459
|
this.field({
|
|
116698
117460
|
type: "text",
|
|
116699
117461
|
key: "fixedPin",
|