@camstack/types 1.2.594 → 1.2.596
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/CHANGELOG.md +20 -0
- package/dist/addon.d.ts +1 -0
- package/dist/addon.js +156 -155
- package/dist/addon.mjs +3 -3
- package/dist/capabilities/index.d.ts +1 -1
- package/dist/capabilities/platform-probe.cap.d.ts +28 -0
- package/dist/capabilities/power-meter.cap.d.ts +16 -5
- package/dist/client.js +5 -1
- package/dist/client.mjs +5 -1
- package/dist/{composed-stable-id-BNTaDZEh.mjs → composed-stable-id-DIeNz933.mjs} +3 -0
- package/dist/{composed-stable-id-BdeYe5dD.js → composed-stable-id-DkF5-kuf.js} +3 -0
- package/dist/device/device-context.d.ts +5 -1
- package/dist/device/device-icon.d.ts +1 -0
- package/dist/device/device-type.d.ts +4 -1
- package/dist/device/hero/hero-look.d.ts +1 -0
- package/dist/device/hero/hero-scene.d.ts +1 -0
- package/dist/device/index.d.ts +1 -1
- package/dist/device/state-refresh.d.ts +15 -1
- package/dist/generated/addon-cap-facts.d.ts +1 -1
- package/dist/generated/customize-catalog.d.ts +4 -4
- package/dist/{implemented-methods-Dj_2fX8-.js → implemented-methods-DnfgAfI6.js} +1 -1
- package/dist/{implemented-methods-DXeNAPAS.mjs → implemented-methods-wFScvZ40.mjs} +1 -1
- package/dist/index.d.ts +4 -3
- package/dist/index.js +3926 -4219
- package/dist/index.mjs +81 -379
- package/dist/inference/runtime-capabilities.d.ts +13 -2
- package/dist/interfaces/addon.d.ts +9 -3
- package/dist/interfaces/platform.d.ts +32 -0
- package/dist/node.js +2 -2
- package/dist/node.mjs +2 -2
- package/dist/pipeline/second-pass/motion-crop-plan.d.ts +2 -3
- package/dist/{sleep-C9eelFbV.mjs → runtime-capabilities-Bgt5QBvO.mjs} +400 -2
- package/dist/{sleep-Bgzv_TCG.js → runtime-capabilities-wOKNm9iz.js} +495 -1
- package/package.json +1 -1
|
@@ -8,7 +8,7 @@
|
|
|
8
8
|
* Do NOT import from @camstack/server/system or @camstack/addon-pipeline.
|
|
9
9
|
*/
|
|
10
10
|
import type { ModelFormat } from '../types/models.js';
|
|
11
|
-
import type { HardwareInfo, PlatformScore } from '../interfaces/platform.js';
|
|
11
|
+
import type { HardwareInfo, NvidiaInfo, PlatformScore } from '../interfaces/platform.js';
|
|
12
12
|
export type RuntimeId = 'onnx' | 'openvino' | 'coreml' | 'edgetpu';
|
|
13
13
|
export interface DeviceOption {
|
|
14
14
|
readonly value: string;
|
|
@@ -24,6 +24,17 @@ export interface InferenceDeviceDescriptor {
|
|
|
24
24
|
readonly score: number;
|
|
25
25
|
readonly available: boolean;
|
|
26
26
|
}
|
|
27
|
+
/** The probe's facts about an NVIDIA card, before its usability is judged. */
|
|
28
|
+
export interface NvidiaProbe {
|
|
29
|
+
readonly name: string;
|
|
30
|
+
readonly memoryMB?: number;
|
|
31
|
+
}
|
|
32
|
+
/**
|
|
33
|
+
* The `HardwareInfo.nvidia` slot for a found card. Usable only when the node's
|
|
34
|
+
* ONNX Runtime lists the CUDA execution provider (`ort.get_available_providers()`,
|
|
35
|
+
* the signal the inference pool binds on); `null` = not reported = not usable.
|
|
36
|
+
*/
|
|
37
|
+
export declare function describeNvidia(probe: NvidiaProbe, onnxExecutionProviders: readonly string[] | null): NvidiaInfo;
|
|
27
38
|
/**
|
|
28
39
|
* Returns the list of supported runtime IDs for given hardware.
|
|
29
40
|
* onnx is always included (universal floor); accelerators added when hw matches.
|
|
@@ -52,7 +63,7 @@ interface ScoreRuntimesResult {
|
|
|
52
63
|
*
|
|
53
64
|
* Rules (hardware-driven only — no Python import probes):
|
|
54
65
|
* - coreml: score 95, darwin+arm64
|
|
55
|
-
* - cuda: score 85, nvidia
|
|
66
|
+
* - cuda: score 85, only for a usable `nvidia` slot (the CUDA EP exists)
|
|
56
67
|
* - openvino: score 90 if intel-npu present, else 80 if intel gpu
|
|
57
68
|
* - edgetpu: score 70, a usable Coral unit (USB or PCIe)
|
|
58
69
|
* - cpu: score 50 (universal floor, always included)
|
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import type { z } from 'zod';
|
|
2
|
+
import type { FetchDeviceOptions } from '../device/device-context.js';
|
|
2
3
|
import type { PackageRequires } from '../addon/package-requires.js';
|
|
3
4
|
import type { ScopedSettingsDeclaration, ScopedSettingsScope } from '../addon/scoped-settings.js';
|
|
4
5
|
import type { CapabilityDefinition, InferProvider } from '../capabilities/capability-definition.js';
|
|
@@ -14,7 +15,7 @@ import type { ConfigUISchema, ConfigUISchemaWithValues, FieldProbeResult } from
|
|
|
14
15
|
import type { IEventBus, ReadinessScope } from './event-bus.js';
|
|
15
16
|
import type { ICapabilityRegistry } from './kernel-abstractions.js';
|
|
16
17
|
import type { IScopedLogger } from './logging.js';
|
|
17
|
-
import type { CoralInfo } from './platform.js';
|
|
18
|
+
import type { CoralInfo, NvidiaInfo } from './platform.js';
|
|
18
19
|
import type { ICapabilityHandle } from './readiness.js';
|
|
19
20
|
import type { StorageLocationDeclaration, StorageLocationDeclarer } from './storage-location-declaration.js';
|
|
20
21
|
/** Sub-process info (inlined from deleted worker-protocol.ts) */
|
|
@@ -406,6 +407,8 @@ export interface KernelInferenceHardware {
|
|
|
406
407
|
} | null;
|
|
407
408
|
/** Coral Edge TPU hardware (USB and/or PCIe), when found — whole, units included. */
|
|
408
409
|
readonly coral?: CoralInfo | null;
|
|
410
|
+
/** An NVIDIA GPU, when found — usable or not. Never in `gpu` (the iGPU slot). */
|
|
411
|
+
readonly nvidia?: NvidiaInfo | null;
|
|
409
412
|
}
|
|
410
413
|
export interface IKernelInferenceEngine {
|
|
411
414
|
/**
|
|
@@ -716,9 +719,12 @@ export interface AddonContext<TConfig = Record<string, unknown>> {
|
|
|
716
719
|
*
|
|
717
720
|
* Bindings are cached per-addon-context: the first call resolves bindings
|
|
718
721
|
* via `deviceManager.getBindings.query`, subsequent calls reuse the cache.
|
|
719
|
-
* The cache is invalidated implicitly when the device is removed
|
|
722
|
+
* The cache is invalidated implicitly when the device is removed, and by the
|
|
723
|
+
* droppable `device.bindings-changed` event. A caller that must see a cap
|
|
724
|
+
* grafted after the first read (a shape comparison) passes `{ fresh: true }`:
|
|
725
|
+
* the bindings are re-read and the cache refreshed for later callers.
|
|
720
726
|
*/
|
|
721
|
-
fetchDevice(deviceId: number): Promise<import('../generated/device-proxy.js').DeviceProxy>;
|
|
727
|
+
fetchDevice(deviceId: number, options?: FetchDeviceOptions): Promise<import('../generated/device-proxy.js').DeviceProxy>;
|
|
722
728
|
/**
|
|
723
729
|
* HTTP **data-plane** facility — serve files/streams/large payloads through the
|
|
724
730
|
* hub's own port with the ADDON producing the bytes (real Node `req`/`res`); the
|
|
@@ -23,12 +23,44 @@ export interface HardwareInfo {
|
|
|
23
23
|
* missing, device not accessible) ⇒ the `edgetpu` runtime is withheld too.
|
|
24
24
|
*/
|
|
25
25
|
readonly coral?: CoralInfo | null;
|
|
26
|
+
/**
|
|
27
|
+
* An NVIDIA GPU, when found — usable or not. Its own slot, like `coral`: an
|
|
28
|
+
* NVIDIA card never takes `gpu`, which stays the integrated GPU (Intel / AMD),
|
|
29
|
+
* so an idle NVIDIA card cannot hide the iGPU OpenVINO runs on. Optional so
|
|
30
|
+
* reports from older nodes still validate; absent / null ⇒ no NVIDIA GPU.
|
|
31
|
+
*/
|
|
32
|
+
readonly nvidia?: NvidiaInfo | null;
|
|
26
33
|
}
|
|
27
34
|
export interface GpuInfo {
|
|
35
|
+
/** `nvidia` only from older nodes: an NVIDIA card is reported in `HardwareInfo.nvidia`. */
|
|
28
36
|
readonly type: 'nvidia' | 'amd' | 'intel' | 'apple';
|
|
29
37
|
readonly name: string;
|
|
30
38
|
readonly memoryMB?: number;
|
|
31
39
|
}
|
|
40
|
+
/**
|
|
41
|
+
* Why an NVIDIA GPU that IS present cannot run inference (D393/D315: present
|
|
42
|
+
* but unusable is never reported as absent).
|
|
43
|
+
* - `no-cuda-execution-provider`: the node's ONNX Runtime build does not list
|
|
44
|
+
* `CUDAExecutionProvider` (CamStack ships the plain `onnxruntime` wheel;
|
|
45
|
+
* planning#605).
|
|
46
|
+
*/
|
|
47
|
+
export type NvidiaUnusableReason = 'no-cuda-execution-provider';
|
|
48
|
+
/**
|
|
49
|
+
* An NVIDIA GPU. `usable` ⇔ the CUDA execution provider is available; only a
|
|
50
|
+
* usable one is offered as the `cuda` runtime / device.
|
|
51
|
+
*/
|
|
52
|
+
export type NvidiaInfo = {
|
|
53
|
+
readonly type: 'nvidia';
|
|
54
|
+
readonly name: string;
|
|
55
|
+
readonly memoryMB?: number;
|
|
56
|
+
readonly usable: true;
|
|
57
|
+
} | {
|
|
58
|
+
readonly type: 'nvidia';
|
|
59
|
+
readonly name: string;
|
|
60
|
+
readonly memoryMB?: number;
|
|
61
|
+
readonly usable: false;
|
|
62
|
+
readonly reason: NvidiaUnusableReason;
|
|
63
|
+
};
|
|
32
64
|
export interface NpuInfo {
|
|
33
65
|
readonly type: 'apple-ane' | 'intel-npu' | 'amd-xdna';
|
|
34
66
|
/** Human-readable accelerator name (e.g. `Intel AI Boost NPU`), when known. */
|
package/dist/node.js
CHANGED
|
@@ -21,8 +21,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
21
21
|
enumerable: true
|
|
22
22
|
}) : target, mod));
|
|
23
23
|
//#endregion
|
|
24
|
-
const require_composed_stable_id = require("./composed-stable-id-
|
|
25
|
-
const require_implemented_methods = require("./implemented-methods-
|
|
24
|
+
const require_composed_stable_id = require("./composed-stable-id-DkF5-kuf.js");
|
|
25
|
+
const require_implemented_methods = require("./implemented-methods-DnfgAfI6.js");
|
|
26
26
|
let node_crypto = require("node:crypto");
|
|
27
27
|
let node_fs = require("node:fs");
|
|
28
28
|
node_fs = __toESM(node_fs);
|
package/dist/node.mjs
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { s as errMsg } from "./composed-stable-id-
|
|
2
|
-
import { B as compositionSourceKey, _r as isSoftwareDecode, a as CUSTOMIZATION_BLOCK_NAME_PREFIX, ar as getFfmpegArtifact, cr as Fmp4BoxSplitter, ir as FFMPEG_RELEASE, nr as chooseFfmpegBinary, or as getFfmpegDownloadUrl, pr as buildFfmpegArgs, rr as ffmpegBinaryName, sr as canonicalHash, t as implementedMethodsOf, tr as FFMPEG_PATH_ENV } from "./implemented-methods-
|
|
1
|
+
import { s as errMsg } from "./composed-stable-id-DIeNz933.mjs";
|
|
2
|
+
import { B as compositionSourceKey, _r as isSoftwareDecode, a as CUSTOMIZATION_BLOCK_NAME_PREFIX, ar as getFfmpegArtifact, cr as Fmp4BoxSplitter, ir as FFMPEG_RELEASE, nr as chooseFfmpegBinary, or as getFfmpegDownloadUrl, pr as buildFfmpegArgs, rr as ffmpegBinaryName, sr as canonicalHash, t as implementedMethodsOf, tr as FFMPEG_PATH_ENV } from "./implemented-methods-wFScvZ40.mjs";
|
|
3
3
|
import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
|
|
4
4
|
import * as fs from "node:fs";
|
|
5
5
|
import { chmodSync, copyFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
|
|
@@ -58,9 +58,8 @@ import { type NormalizedRect, type RecoveryCrop, type RecoveryPlanInput } from '
|
|
|
58
58
|
/**
|
|
59
59
|
* Which region rule this camera's second pass runs.
|
|
60
60
|
*
|
|
61
|
-
* The selector is per camera and defaults to the shipped rule
|
|
62
|
-
*
|
|
63
|
-
* nothing until an operator moves a camera.
|
|
61
|
+
* The selector is per camera and defaults to the shipped rule: a deploy
|
|
62
|
+
* changes nothing until an operator moves a camera.
|
|
64
63
|
*/
|
|
65
64
|
export type RecoveryRecipe = 'uncovered-region' | 'motion-crop';
|
|
66
65
|
/**
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { t as EventCategory } from "./event-category-7P4A3bYA.mjs";
|
|
2
|
-
import { a as DeviceType, i as DeviceRole, s as errMsg } from "./composed-stable-id-
|
|
2
|
+
import { a as DeviceType, i as DeviceRole, s as errMsg } from "./composed-stable-id-DIeNz933.mjs";
|
|
3
3
|
import { z } from "zod";
|
|
4
4
|
//#region src/audio/audio-chunk-format.ts
|
|
5
5
|
/**
|
|
@@ -20031,6 +20031,10 @@ var CAP_STATE_LEAVES = Object.freeze({
|
|
|
20031
20031
|
"path": "power",
|
|
20032
20032
|
"valueType": "number"
|
|
20033
20033
|
},
|
|
20034
|
+
{
|
|
20035
|
+
"path": "deliveredPower",
|
|
20036
|
+
"valueType": "number"
|
|
20037
|
+
},
|
|
20034
20038
|
{
|
|
20035
20039
|
"path": "energy",
|
|
20036
20040
|
"valueType": "number"
|
|
@@ -22748,6 +22752,72 @@ function maskUrlCredentials(rawUrl) {
|
|
|
22748
22752
|
}
|
|
22749
22753
|
}
|
|
22750
22754
|
//#endregion
|
|
22755
|
+
//#region src/utils/runtime-mapping.ts
|
|
22756
|
+
/**
|
|
22757
|
+
* DEVICE-POOL backend → model format — the SSOT for the multi-device inference
|
|
22758
|
+
* DESCRIPTOR path (Python per-device pools), distinct from the former BACKEND_TO_FORMAT,
|
|
22759
|
+
* which was the removed NODE runtime map (where `coreml → onnx` because
|
|
22760
|
+
* onnxruntime-node's CoreML EP loaded `.onnx`). A device pool runs the
|
|
22761
|
+
* backend NATIVELY, so `coreml → coreml` and `edgetpu → tflite`. Consumed by
|
|
22762
|
+
* `resolveDeviceEngine` (addon-pipeline) and the orchestrator's
|
|
22763
|
+
* `parseDeviceKey`/`getNodeInferenceDevices` — the previously-duplicated
|
|
22764
|
+
* `BACKEND_FORMAT` maps (R3/node-F2). `cpu`/`cuda` floor to onnx.
|
|
22765
|
+
*/
|
|
22766
|
+
var DEVICE_BACKEND_TO_FORMAT = {
|
|
22767
|
+
openvino: "openvino",
|
|
22768
|
+
edgetpu: "tflite",
|
|
22769
|
+
coreml: "coreml",
|
|
22770
|
+
onnx: "onnx",
|
|
22771
|
+
cpu: "onnx",
|
|
22772
|
+
cuda: "onnx"
|
|
22773
|
+
};
|
|
22774
|
+
/**
|
|
22775
|
+
* Resolve a DEVICE-POOL backend to its model format via {@link DEVICE_BACKEND_TO_FORMAT},
|
|
22776
|
+
* flooring unknown backends to `onnx`. The single entry point both addons call.
|
|
22777
|
+
*/
|
|
22778
|
+
function deviceBackendToFormat(backend) {
|
|
22779
|
+
return DEVICE_BACKEND_TO_FORMAT[backend] ?? "onnx";
|
|
22780
|
+
}
|
|
22781
|
+
/**
|
|
22782
|
+
* Map DetectionRuntime to ModelFormat.
|
|
22783
|
+
* Used when the addon receives an explicit runtime (not 'auto').
|
|
22784
|
+
*/
|
|
22785
|
+
var RUNTIME_TO_FORMAT = {
|
|
22786
|
+
onnx: "onnx",
|
|
22787
|
+
coreml: "coreml",
|
|
22788
|
+
openvino: "openvino",
|
|
22789
|
+
tflite: "tflite",
|
|
22790
|
+
pytorch: "pt"
|
|
22791
|
+
};
|
|
22792
|
+
/**
|
|
22793
|
+
* Map a Python backend to the Python inference script name.
|
|
22794
|
+
*/
|
|
22795
|
+
var PYTHON_SCRIPT = {
|
|
22796
|
+
coreml: "coreml_inference.py",
|
|
22797
|
+
pytorch: "pytorch_inference.py",
|
|
22798
|
+
openvino: "openvino_inference.py"
|
|
22799
|
+
};
|
|
22800
|
+
/**
|
|
22801
|
+
* Get the model format for a given DetectionRuntime.
|
|
22802
|
+
*/
|
|
22803
|
+
function formatForRuntime(runtime) {
|
|
22804
|
+
return RUNTIME_TO_FORMAT[runtime];
|
|
22805
|
+
}
|
|
22806
|
+
/**
|
|
22807
|
+
* Get the Python inference script name for a backend.
|
|
22808
|
+
* Returns undefined if no Python script is needed (e.g., 'cpu' uses ONNX).
|
|
22809
|
+
*/
|
|
22810
|
+
function pythonScriptForBackend(backend) {
|
|
22811
|
+
return PYTHON_SCRIPT[backend];
|
|
22812
|
+
}
|
|
22813
|
+
/**
|
|
22814
|
+
* Check if a DetectionRuntime requires a Python binary.
|
|
22815
|
+
* 'coreml', 'pytorch', 'openvino' need Python; 'onnx' and 'tflite' don't.
|
|
22816
|
+
*/
|
|
22817
|
+
function requiresPython(runtime) {
|
|
22818
|
+
return runtime === "coreml" || runtime === "pytorch" || runtime === "openvino";
|
|
22819
|
+
}
|
|
22820
|
+
//#endregion
|
|
22751
22821
|
//#region src/utils/sleep.ts
|
|
22752
22822
|
/**
|
|
22753
22823
|
* Promise-based timer helpers — used everywhere the codebase needs to
|
|
@@ -22801,4 +22871,332 @@ function sleepCancellable(ms, signal) {
|
|
|
22801
22871
|
});
|
|
22802
22872
|
}
|
|
22803
22873
|
//#endregion
|
|
22804
|
-
|
|
22874
|
+
//#region src/inference/coral-units.ts
|
|
22875
|
+
/** Bus order of the enumeration: USB first (the historical key), then PCIe. */
|
|
22876
|
+
var BUS_ORDER = ["usb", "pci"];
|
|
22877
|
+
function unitDevice(bus, index) {
|
|
22878
|
+
return index === 0 ? bus : `${bus}:${index}`;
|
|
22879
|
+
}
|
|
22880
|
+
function countOn(coral, bus) {
|
|
22881
|
+
if (coral.units !== void 0) return coral.units.filter((u) => u.bus === bus).reduce((n, u) => n + Math.max(0, u.count), 0);
|
|
22882
|
+
return bus === (coral.bus === "pci" ? "pci" : "usb") ? Math.max(1, coral.count ?? 1) : 0;
|
|
22883
|
+
}
|
|
22884
|
+
/** Every usable Coral unit on a node, USB first then PCIe, in ordinal order. */
|
|
22885
|
+
function coralUsableUnits(coral) {
|
|
22886
|
+
if (coral == null) return [];
|
|
22887
|
+
const out = [];
|
|
22888
|
+
for (const bus of BUS_ORDER) {
|
|
22889
|
+
const count = countOn(coral, bus);
|
|
22890
|
+
for (let index = 0; index < count; index++) out.push({
|
|
22891
|
+
bus,
|
|
22892
|
+
index,
|
|
22893
|
+
device: unitDevice(bus, index)
|
|
22894
|
+
});
|
|
22895
|
+
}
|
|
22896
|
+
return out;
|
|
22897
|
+
}
|
|
22898
|
+
var KEY_DEVICE = /^(usb|pci)(?::(\d+))?$/;
|
|
22899
|
+
/**
|
|
22900
|
+
* Map an edgetpu key suffix (`usb`, `usb:1`, `pci`, `pci:1`) to the explicit
|
|
22901
|
+
* libedgetpu device string (`usb:0`, `usb:1`, `pci:0`, `pci:1`). Throws on any
|
|
22902
|
+
* other string — a pool must never open "whichever Edge TPU comes first".
|
|
22903
|
+
*/
|
|
22904
|
+
function edgetpuDelegateDevice(device) {
|
|
22905
|
+
const match = KEY_DEVICE.exec(device.trim());
|
|
22906
|
+
if (match === null) throw new Error(`edgetpu device "${device}" is not usb[:N] or pci[:N]`);
|
|
22907
|
+
const [, bus, ordinal] = match;
|
|
22908
|
+
return `${bus}:${ordinal ?? "0"}`;
|
|
22909
|
+
}
|
|
22910
|
+
//#endregion
|
|
22911
|
+
//#region src/inference/runtime-capabilities.ts
|
|
22912
|
+
var AUTO = {
|
|
22913
|
+
value: "auto",
|
|
22914
|
+
label: "Auto"
|
|
22915
|
+
};
|
|
22916
|
+
var CPU = {
|
|
22917
|
+
value: "cpu",
|
|
22918
|
+
label: "CPU"
|
|
22919
|
+
};
|
|
22920
|
+
var USB = {
|
|
22921
|
+
value: "usb",
|
|
22922
|
+
label: "Coral USB"
|
|
22923
|
+
};
|
|
22924
|
+
function coralUnitOption(unit) {
|
|
22925
|
+
const bus = unit.bus === "pci" ? "PCIe" : "USB";
|
|
22926
|
+
const label = unit.index === 0 ? `Coral ${bus}` : `Coral ${bus} ${unit.index + 1}`;
|
|
22927
|
+
return {
|
|
22928
|
+
value: unit.device,
|
|
22929
|
+
label
|
|
22930
|
+
};
|
|
22931
|
+
}
|
|
22932
|
+
var ONNX_CUDA_EP = "CUDAExecutionProvider";
|
|
22933
|
+
/**
|
|
22934
|
+
* The `HardwareInfo.nvidia` slot for a found card. Usable only when the node's
|
|
22935
|
+
* ONNX Runtime lists the CUDA execution provider (`ort.get_available_providers()`,
|
|
22936
|
+
* the signal the inference pool binds on); `null` = not reported = not usable.
|
|
22937
|
+
*/
|
|
22938
|
+
function describeNvidia(probe, onnxExecutionProviders) {
|
|
22939
|
+
const base = {
|
|
22940
|
+
type: "nvidia",
|
|
22941
|
+
name: probe.name,
|
|
22942
|
+
...probe.memoryMB === void 0 ? {} : { memoryMB: probe.memoryMB }
|
|
22943
|
+
};
|
|
22944
|
+
return onnxExecutionProviders?.includes(ONNX_CUDA_EP) === true ? {
|
|
22945
|
+
...base,
|
|
22946
|
+
usable: true
|
|
22947
|
+
} : {
|
|
22948
|
+
...base,
|
|
22949
|
+
usable: false,
|
|
22950
|
+
reason: "no-cuda-execution-provider"
|
|
22951
|
+
};
|
|
22952
|
+
}
|
|
22953
|
+
/**
|
|
22954
|
+
* CUDA is offered only for a USABLE NVIDIA slot. An NVIDIA GPU alone is not
|
|
22955
|
+
* enough: without the EP the pool binds the CPU provider and a `cuda` device
|
|
22956
|
+
* would be the CPU under another name. `gpu.type === 'nvidia'` (older nodes)
|
|
22957
|
+
* never counts.
|
|
22958
|
+
*/
|
|
22959
|
+
function onnxCudaAvailable(hw) {
|
|
22960
|
+
return hw?.nvidia?.usable === true;
|
|
22961
|
+
}
|
|
22962
|
+
var RUNTIMES = [
|
|
22963
|
+
{
|
|
22964
|
+
id: "onnx",
|
|
22965
|
+
supports: () => true,
|
|
22966
|
+
devices: (hw) => {
|
|
22967
|
+
if (!hw) return [CPU];
|
|
22968
|
+
const out = [CPU];
|
|
22969
|
+
if (onnxCudaAvailable(hw)) out.push({
|
|
22970
|
+
value: "cuda",
|
|
22971
|
+
label: "CUDA"
|
|
22972
|
+
});
|
|
22973
|
+
if (hw.gpu?.type === "amd" && hw.platform === "linux") out.push({
|
|
22974
|
+
value: "webgpu",
|
|
22975
|
+
label: "WebGPU (AMD iGPU)"
|
|
22976
|
+
});
|
|
22977
|
+
if (hw.npu?.type === "apple-ane") out.push({
|
|
22978
|
+
value: "coreml",
|
|
22979
|
+
label: "CoreML EP"
|
|
22980
|
+
});
|
|
22981
|
+
return out;
|
|
22982
|
+
},
|
|
22983
|
+
defaultDevice: "cpu"
|
|
22984
|
+
},
|
|
22985
|
+
{
|
|
22986
|
+
id: "openvino",
|
|
22987
|
+
supports: (hw) => hw?.arch === "x64" && hw.platform !== "darwin" && (hw.gpu?.type === "intel" || hw.gpu?.type === "amd"),
|
|
22988
|
+
devices: (hw) => {
|
|
22989
|
+
if (!hw) return [AUTO];
|
|
22990
|
+
if (hw.gpu?.type === "amd") return [CPU];
|
|
22991
|
+
const out = [AUTO, CPU];
|
|
22992
|
+
if (hw.gpu?.type === "intel") out.push({
|
|
22993
|
+
value: "gpu",
|
|
22994
|
+
label: "GPU"
|
|
22995
|
+
});
|
|
22996
|
+
if (hw.npu?.type === "intel-npu") out.push({
|
|
22997
|
+
value: "npu",
|
|
22998
|
+
label: "NPU"
|
|
22999
|
+
});
|
|
23000
|
+
return out;
|
|
23001
|
+
},
|
|
23002
|
+
defaultDevice: "auto"
|
|
23003
|
+
},
|
|
23004
|
+
{
|
|
23005
|
+
id: "coreml",
|
|
23006
|
+
supports: (hw) => hw?.platform === "darwin",
|
|
23007
|
+
devices: (hw) => {
|
|
23008
|
+
const all = {
|
|
23009
|
+
value: "all",
|
|
23010
|
+
label: "All (ANE + GPU + CPU)"
|
|
23011
|
+
};
|
|
23012
|
+
if (!hw) return [all];
|
|
23013
|
+
const out = [all];
|
|
23014
|
+
if (hw.npu?.type === "apple-ane") out.push({
|
|
23015
|
+
value: "ane",
|
|
23016
|
+
label: "Apple Neural Engine"
|
|
23017
|
+
});
|
|
23018
|
+
out.push({
|
|
23019
|
+
value: "gpu",
|
|
23020
|
+
label: "GPU"
|
|
23021
|
+
}, CPU);
|
|
23022
|
+
return out;
|
|
23023
|
+
},
|
|
23024
|
+
defaultDevice: "all"
|
|
23025
|
+
},
|
|
23026
|
+
{
|
|
23027
|
+
id: "edgetpu",
|
|
23028
|
+
supports: (hw) => coralUsableUnits(hw?.coral).length > 0,
|
|
23029
|
+
devices: (hw) => {
|
|
23030
|
+
const units = coralUsableUnits(hw?.coral);
|
|
23031
|
+
return units.length > 0 ? units.map(coralUnitOption) : [USB];
|
|
23032
|
+
},
|
|
23033
|
+
defaultDevice: "usb"
|
|
23034
|
+
}
|
|
23035
|
+
];
|
|
23036
|
+
function def(id) {
|
|
23037
|
+
const d = RUNTIMES.find((r) => r.id === id);
|
|
23038
|
+
if (!d) throw new Error(`Unknown runtime: ${id}`);
|
|
23039
|
+
return d;
|
|
23040
|
+
}
|
|
23041
|
+
/**
|
|
23042
|
+
* Returns the list of supported runtime IDs for given hardware.
|
|
23043
|
+
* onnx is always included (universal floor); accelerators added when hw matches.
|
|
23044
|
+
*/
|
|
23045
|
+
function supportedRuntimes(hw) {
|
|
23046
|
+
return RUNTIMES.filter((r) => r.supports(hw)).map((r) => r.id);
|
|
23047
|
+
}
|
|
23048
|
+
/**
|
|
23049
|
+
* Returns the device options for a given runtime and hardware probe.
|
|
23050
|
+
*/
|
|
23051
|
+
function runtimeDevices(id, hw) {
|
|
23052
|
+
return def(id).devices(hw);
|
|
23053
|
+
}
|
|
23054
|
+
/**
|
|
23055
|
+
* Returns the default device string for a given runtime.
|
|
23056
|
+
* onnx → 'cpu', openvino → 'auto', coreml → 'all'
|
|
23057
|
+
*/
|
|
23058
|
+
function defaultDeviceFor(id) {
|
|
23059
|
+
return def(id).defaultDevice;
|
|
23060
|
+
}
|
|
23061
|
+
/**
|
|
23062
|
+
* Returns the model format required for a given runtime.
|
|
23063
|
+
* Delegates to `formatForRuntime` from runtime-mapping.ts.
|
|
23064
|
+
*/
|
|
23065
|
+
function modelFormatForRuntime(id) {
|
|
23066
|
+
if (id === "edgetpu") return "tflite";
|
|
23067
|
+
return formatForRuntime(id);
|
|
23068
|
+
}
|
|
23069
|
+
/**
|
|
23070
|
+
* Scores all applicable inference backends for the given hardware.
|
|
23071
|
+
*
|
|
23072
|
+
* Rules (hardware-driven only — no Python import probes):
|
|
23073
|
+
* - coreml: score 95, darwin+arm64
|
|
23074
|
+
* - cuda: score 85, only for a usable `nvidia` slot (the CUDA EP exists)
|
|
23075
|
+
* - openvino: score 90 if intel-npu present, else 80 if intel gpu
|
|
23076
|
+
* - edgetpu: score 70, a usable Coral unit (USB or PCIe)
|
|
23077
|
+
* - cpu: score 50 (universal floor, always included)
|
|
23078
|
+
*
|
|
23079
|
+
* All hardware-matched entries are `available: true`.
|
|
23080
|
+
* Scores are sorted descending; `best` is the first available entry
|
|
23081
|
+
* (or last entry as fallback).
|
|
23082
|
+
*/
|
|
23083
|
+
function scoreRuntimes(hw) {
|
|
23084
|
+
const scores = [];
|
|
23085
|
+
if (hw.platform === "darwin" && hw.arch === "arm64") scores.push({
|
|
23086
|
+
runtime: "python",
|
|
23087
|
+
backend: "coreml",
|
|
23088
|
+
format: "coreml",
|
|
23089
|
+
score: 95,
|
|
23090
|
+
reason: "Apple Neural Engine (Python CoreML)",
|
|
23091
|
+
available: true
|
|
23092
|
+
});
|
|
23093
|
+
if (onnxCudaAvailable(hw)) scores.push({
|
|
23094
|
+
runtime: "python",
|
|
23095
|
+
backend: "cuda",
|
|
23096
|
+
format: "onnx",
|
|
23097
|
+
score: 85,
|
|
23098
|
+
reason: "NVIDIA CUDA (Python ONNX Runtime)",
|
|
23099
|
+
available: true
|
|
23100
|
+
});
|
|
23101
|
+
if (hw.gpu?.type === "intel") {
|
|
23102
|
+
const score = hw.npu?.type === "intel-npu" ? 90 : 80;
|
|
23103
|
+
scores.push({
|
|
23104
|
+
runtime: "python",
|
|
23105
|
+
backend: "openvino",
|
|
23106
|
+
format: "openvino",
|
|
23107
|
+
score,
|
|
23108
|
+
reason: "Intel OpenVINO",
|
|
23109
|
+
available: true
|
|
23110
|
+
});
|
|
23111
|
+
}
|
|
23112
|
+
if (hw.gpu?.type === "amd") {
|
|
23113
|
+
if (hw.platform === "linux") scores.push({
|
|
23114
|
+
runtime: "python",
|
|
23115
|
+
backend: "onnx",
|
|
23116
|
+
format: "onnx",
|
|
23117
|
+
score: 75,
|
|
23118
|
+
reason: "ONNX WebGPU (AMD iGPU)",
|
|
23119
|
+
available: true
|
|
23120
|
+
});
|
|
23121
|
+
scores.push({
|
|
23122
|
+
runtime: "python",
|
|
23123
|
+
backend: "openvino",
|
|
23124
|
+
format: "openvino",
|
|
23125
|
+
score: 65,
|
|
23126
|
+
reason: "OpenVINO CPU (AMD x64)",
|
|
23127
|
+
available: true
|
|
23128
|
+
});
|
|
23129
|
+
}
|
|
23130
|
+
if (coralUsableUnits(hw.coral).length > 0) scores.push({
|
|
23131
|
+
runtime: "python",
|
|
23132
|
+
backend: "edgetpu",
|
|
23133
|
+
format: "tflite",
|
|
23134
|
+
score: 70,
|
|
23135
|
+
reason: "Coral Edge TPU (Python LiteRT)",
|
|
23136
|
+
available: true
|
|
23137
|
+
});
|
|
23138
|
+
scores.push({
|
|
23139
|
+
runtime: "python",
|
|
23140
|
+
backend: "cpu",
|
|
23141
|
+
format: "onnx",
|
|
23142
|
+
score: 50,
|
|
23143
|
+
reason: "CPU (Python ONNX Runtime)",
|
|
23144
|
+
available: true
|
|
23145
|
+
});
|
|
23146
|
+
const sorted = scores.toSorted((a, b) => b.score - a.score);
|
|
23147
|
+
return {
|
|
23148
|
+
scores: sorted,
|
|
23149
|
+
best: sorted.find((s) => s.available) ?? sorted[sorted.length - 1]
|
|
23150
|
+
};
|
|
23151
|
+
}
|
|
23152
|
+
var DEVICE_FOR_BACKEND = {
|
|
23153
|
+
cuda: "gpu",
|
|
23154
|
+
edgetpu: "usb",
|
|
23155
|
+
coreml: "all",
|
|
23156
|
+
cpu: "cpu"
|
|
23157
|
+
};
|
|
23158
|
+
function device(backend, dev, format, score) {
|
|
23159
|
+
return {
|
|
23160
|
+
key: backend === "cpu" ? "cpu" : `${backend}:${dev}`,
|
|
23161
|
+
backend,
|
|
23162
|
+
device: dev,
|
|
23163
|
+
format,
|
|
23164
|
+
runtime: "python",
|
|
23165
|
+
score,
|
|
23166
|
+
available: true
|
|
23167
|
+
};
|
|
23168
|
+
}
|
|
23169
|
+
/**
|
|
23170
|
+
* Enumerate every usable inference device on a node — one descriptor PER PHYSICAL
|
|
23171
|
+
* ACCELERATOR, so the orchestrator can run and balance across all of them
|
|
23172
|
+
* CONCURRENTLY (each device is its own pool). Critically, OpenVINO is expanded
|
|
23173
|
+
* into its distinct devices (NPU / iGPU / CPU) rather than a single AUTO entry:
|
|
23174
|
+
* the Intel NPU ("AI Boost") and the iGPU are separate accelerators and run in
|
|
23175
|
+
* parallel — collapsing them to AUTO would leave one idle. NPU is scored above
|
|
23176
|
+
* the iGPU (faster for int8 detection AND frees the GPU).
|
|
23177
|
+
*/
|
|
23178
|
+
function enumerateInferenceDevices(hw) {
|
|
23179
|
+
const { scores } = scoreRuntimes(hw);
|
|
23180
|
+
const out = [];
|
|
23181
|
+
for (const s of scores) {
|
|
23182
|
+
if (s.backend === "openvino") {
|
|
23183
|
+
if (hw.npu?.type === "intel-npu") out.push(device("openvino", "npu", s.format, s.score + 2));
|
|
23184
|
+
if (hw.gpu?.type === "intel") out.push(device("openvino", "gpu", s.format, s.score));
|
|
23185
|
+
if (hw.gpu?.type === "amd") out.push(device("openvino", "cpu", s.format, s.score));
|
|
23186
|
+
continue;
|
|
23187
|
+
}
|
|
23188
|
+
if (s.backend === "edgetpu") {
|
|
23189
|
+
for (const unit of coralUsableUnits(hw.coral)) out.push(device("edgetpu", unit.device, s.format, s.score));
|
|
23190
|
+
continue;
|
|
23191
|
+
}
|
|
23192
|
+
if (s.backend === "onnx" && s.reason.startsWith("ONNX WebGPU")) {
|
|
23193
|
+
out.push(device("onnx", "webgpu", s.format, s.score));
|
|
23194
|
+
continue;
|
|
23195
|
+
}
|
|
23196
|
+
const dev = DEVICE_FOR_BACKEND[s.backend] ?? s.backend;
|
|
23197
|
+
out.push(device(s.backend, dev, s.format, s.score));
|
|
23198
|
+
}
|
|
23199
|
+
return out;
|
|
23200
|
+
}
|
|
23201
|
+
//#endregion
|
|
23202
|
+
export { CAP_STATE_LEAVES as $, findMigrationsBlocked as $a, DeclarationRefusedError as $i, registerKnownSecret as $n, secretTreeFromPaths as $r, AudioChunkFormatSchema as $t, DEVICE_SCOPED_CAPS as A, WELL_KNOWN_TAB_MAP as Aa, RECORD_DATABASES as Ai, NOT_A_DEVICE as An, HISTORY_UNIT_LABELS as Ar, allVocabActions as At, commandEffect as B, isSecretFieldView as Ba, RECORD_SWEEP_INTERVAL_MS as Bi, OnBehalfSourceSchema as Bn, CamstackError as Br, emitDownForOwnedCaps as Bt, asNumber as C, AddonMigrationDefinitionError as Ca, recordArrayItemPath as Ci, QUANTITY_BASE as Cn, SECRET_META as Cr, DEVICE_CHILDREN_BATCH_MAX as Ct, parseJsonUnknown as D, emitReadiness as Da, RECORD_BATCH_MAX as Di, historyUnitFor as Dn, DEVICE_SETTINGS_CONTRIBUTION_METHODS as Dr, t as Dt, parseJsonObject as E, createEvent as Ea, secretArrayPrefixes as Ei, displayUnitFor as En, DEFAULT_RUNTIME_STATE_DURABILITY as Er, addonPagesSourceCapability as Et, createEventBusSliceSource as F, hydrateSchema as Fa, RECORD_MAX_INDEXES as Fi, TransitionCommandSchema as Fn, isDeviceConfigCap as Fr, CAP_VOCABULARY_BY_NAME as Ft, resolveSideEffect as G, REDACTED_SECRET as Ga, globalSecretScope as Gi, assertTransactScope as Gn, readErrorI18n as Gr, DEBUG_WATCH_REARM_EVERY_MS as Gt, commandHoldMs as H, isSecretMarkerLike as Ha, arrayItemFieldPath as Hi, ruleFireOfClaim as Hn, ErrorI18nPayloadSchema as Hr, scopeKey as Ht, createLazyTrpcSource as I, resolveHydratedFieldValue as Ia, RECORD_MAX_INDEX_FIELDS as Ii, TransitionOutcomeSchema as In, method as Ir, CAP_VOCABULARY as It, HF_REPO as J, isKeychainStoredField as Ja, parseSecretRef as Ji, createSecretsAccess as Jn, classifyStoreError as Jr, DebugWatchTable as Jt, DEFAULT_TOKEN_EXPIRY as K, collectKeychainStoredKeys as Ka, isSecretRef as Ki, resolveSecretViewsIn as Kn, userError as Kr, DEBUG_WATCH_WINDOW_MS as Kt, createMirrorSource as L, SECRET_CLEAR as La, RECORD_QUERY_MAX as Li, TransitionValueSchema as Ln, optionalMethod as Lr, MODEL_FORMATS as Lt, createDeviceProxy as M, collectHydratedFieldValues as Ma, RECORD_DELETE_BATCH as Mi, DeviceTransitionSchema as Mn, event as Mr, findVocabAction as Mt, invokeTrpcLeaf as N, dehydrateConfigField as Na, RECORD_ID_MAX_LENGTH as Ni, TransitionActorKindSchema as Nn, expandCapMethods as Nr, vocabActionIdFor as Nt, hfModelUrl as O, isEvent as Oa, RECORD_BATCH_MAX_BYTES as Oi, isReadingQuantity as On, DEVICE_STATUS_METHOD as Or, VocabActionError as Ot, addonSliceHandleApi as P, dehydrateSchema as Pa, RECORD_MAX_DATA_BYTES as Pi, TransitionActorSchema as Pn, historyItemFieldPath as Pr, vocabCall as Pt, CAP_NAMES as Q, AddonMigrationsBlockedError as Qa, BatchTooLargeError as Qi, knownSecretCount as Qn, parseSecretStatePath as Qr, isDebugChannelName as Qt, createSliceHandle as R, classifySecretWrite as Ra, RECORD_SECRET_COLLECTION_PREFIX as Ri, CommandOriginClaimSchema as Rn, resolveCapMount as Rr, ReadinessRegistry as Rt, asJsonObject as S, switchRecordsOverMigrationApi as Sa, parseSecretPath as Si, DISPLAY_PREFERENCES as Sn, defineRecordKinds as Sr, deviceOpsCapability as St, parseJsonArray as T, runAddonMigrations as Ta, recordSecretRef as Ti, baseUnitOf as Tn, isZodSecret as Tr, AddonPageDeclarationSchema as Tt, effectConditionHolds as U, makeSecretMarker as Ua, buildSecretRef as Ui, makeInMemoryRecords as Un, FORBIDDEN_MESSAGE_PREFIX as Ur, DEBUG_CHANNEL_PREFIX as Ut, commandEffects as V, isSecretMarker as Va, SECRET_REF_SCHEME as Vi, RuleFireOriginSchema as Vn, ErrorCodeSchema as Vr, readinessKey as Vt, isCommand as W, toSecretFieldView as Wa, formatSecretScope as Wi, createRecordsAccess as Wn, forbiddenError as Wr, DEBUG_WATCH_HARD_CAP_MS as Wt, CAP_ADVANCE_FIELDS as X, omitTransientConfig as Xa, linksOfKind as Xi, clearKnownSecrets as Xn, normalizeAddonInitResult as Xr, createDebugEmitter as Xt, RUNTIME_DEFAULTS as Y, isSecretConfigField as Ya, linkField as Yi, MIN_SCRUBBED_LENGTH as Yn, migrationSet as Yr, __resetDebugInterestForTests as Yt, CAP_METHOD_TIMEOUTS_MS as Z, schemaDeclaresAnyField as Za, optionalLinkField as Zi, forgetKnownSecret as Zn, mergeSecretStatePaths as Zr, getDebugInterest as Zt, pythonScriptForBackend as _, defaultIntegrationDepsOver as _a, isInstanceEnabled as _i, makeProfileBrokerId as _n, RecordKindNameSchema as _r, switchRefusesSetState as _t, runtimeDevices as a, RECORDS_ERROR_CODES as aa, transformSecretWrite as ai, CamStreamKindSchema as an, PEER_BYTES_TICKET_TTL_MS as ar, defineCustomActions as at, asBoolean as b, rowsDepsOver as ba, collectSecretLeaves as bi, selectAssignedProfileSlots as bn, assertValidDeclaration as br, MIGRATION_API_VERSION as bt, coralUsableUnits as c, RecordTooLargeError as ca, resolveDeviceSettings as ci, DecodedAudioChunkSchema as cn, DATAPLANE_SECRET_HEADER as cr, CAP_COMMAND_ORIGIN_CONTEXT_KEY as ct, sleepCancellable as d, RevConflictError as da, createDurableState as di, ProfileSlotSchema as dn, defineEntryKind as dr, nodePin as dt, FilterRequiredError as ea, secretTreeFromSchema as ei, AudioStreamPickSchema as en, AUDIO_CHUNK_FORMATS as eo, scrubKnownSecrets as er, CAP_METHOD_NOT_IMPLEMENTED as et, DEVICE_BACKEND_TO_FORMAT as f, TransactRefusedError as fa, moveRegistrySwitchToBody as fi, ProfileSlotStatusSchema as fn, entryBody as fr, readCommandOrigin as ft, formatForRuntime as g, recordsErrorFromMessage as ga, RecordIntegrationInstances as gi, SubscribeAudioChunksResultSchema as gn, RecordKindDeclarationSchema as gr, SWITCH_SETTABLE_GATE as gt, deviceBackendToFormat as h, asRecordsError as ha, registrySwitchToBodyMigration as hi, SubscribeAudioChunksInputSchema as hn, RecordIndexSchema as hr, viewerUiCapability as ht, modelFormatForRuntime as i, PlaintextSecretError as ia, resolveSecretMarkers as ii, CamProfileSchema as in, PEER_BYTES_STALL_MS as ir, customAction as it, isDeviceScopedCap as j, collectHydratedFieldEntries as ja, RECORD_DEFAULT_MAX_DATA_BYTES as ji, DeviceCommandSettledEventSchema as jn, PROVIDER_PIN_FIELD as jr, assertDeviceOffers as jt, BOOT_RECOVERY_BACKOFF_MS as k, WELL_KNOWN_TABS as ka, RECORD_CLASSES as ki, readingMeta as kn, HISTORY_DEFAULT_MIN_INTERVAL_MS as kr, actionEffect as kt, edgetpuDelegateDevice as l, RecordUniqueViolationError as la, resolvedValues as li, FrameHandleSchema as ln, SHARE_VIEW_KINDS as lr, CAP_NODE_PIN_CONTEXT_KEY as lt, RUNTIME_TO_FORMAT as m, UnknownRecordKindError as ma, registrySwitchToBodyId as mi, StreamSourceSchema as mn, RecordFieldPathSchema as mr, toNodeId as mt, describeNvidia as n, InvalidRecordError as na, collectSecretMarkerRefs as ni, BrokerStatusSchema as nn, expandAudioChunkToF32le as no, PEER_BYTES_CHUNK_BYTES as nr, CALLER_STAMPED_CAPABILITIES as nt, scoreRuntimes as o, RecordNotFoundError as oa, SCOPED_SETTINGS_SCOPES as oi, CamStreamResolutionSchema as on, PeerBytesTicketSchema as or, describeCustomActions as ot, PYTHON_SCRIPT as p, UnindexedFilterError as pa, registrySwitchPortsOver as pi, StreamSourceEntrySchema$1 as pn, EntryDescriptorSchema as pr, readNodePin as pt, HF_BASE_URL as q, collectSecretConfigKeys as qa, normalizeSecretOwner as qi, REVALIDATE_AFTER_MS as qn, BaseAddon as qr, DebugInterest as qt, enumerateInferenceDevices as r, NoCallerError as ra, isSecretRefOwnedBy as ri, CAM_PROFILE_ORDER as rn, isAudioChunkFormat as ro, PEER_BYTES_MAX_OUTSTANDING as rr, withoutCallerStamp as rt, supportedRuntimes as s, RecordSecretUnavailableError as sa, nodeIdOfScopedKey as si, CameraStreamSchema as sn, CALLER_USERNAME_HEADER as sr, deviceCustomAction as st, defaultDeviceFor as t, ForeignSecretMarkerError as ta, KeychainWriteRefusedError as ti, BrokerStatsSchema as tn, audioChunkBytesPerSample as to, shortSecretRefHash as tr, isCapMethodAbsent as tt, sleep as u, RecordsError as ua, normalizeNodeId as ui, ProfileRtspEntrySchema as un, DisposerChain as ur, commandOrigin as ut, requiresPython as v, integrationRowsApiOver as va, secretViewsOf as vi, makeSourceBrokerId as vn, RecordRetentionSchema as vr, PipelineRunResultBridge as vt, asString as w, defineAddonMigrations as wa, recordSecretCollection as wi, ReadingQuantitySchema as wn, collectZodSecretPaths as wr, adminUiCapability as wt, asJsonArray as x, secretsOverMigrationApi as xa, mapSecretLeaves as xi, DEFAULT_DISPLAY_PREFERENCE as xn, declarationsOf as xr, RawStateResultSchema as xt, maskUrlCredentials as y, recordsOverMigrationApi as ya, REMOVE_LEAF as yi, parseProfileBrokerId as yn, StoredRecordKindDeclarationSchema as yr, PipelineStepInputSchema as yt, auditedFields as z, isSecretClear as za, RECORD_SETTINGS_MAX_ROWS as zi, OnBehalfSchema as zn, systemMethod as zr, ReadinessTimeoutError as zt };
|