@camstack/types 1.2.74 → 1.2.76

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-D3gG7oil.js");
-const require_sleep = require("./sleep-B-mRsuDp.js");
+const require_sleep = require("./sleep-DslGLq5_.js");
 const require_canonical_hash = require("./canonical-hash-DNV8S5ET.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -9517,6 +9517,18 @@ var LlmGenerateBaseInputSchema = zod.z.object({
 * Resource ceiling = llama-server flags + idleStopMinutes ONLY (no RSS
 * watchdog — operator decision #3).
 */
+/**
+* A companion artifact that MUST land beside the main GGUF: the `mmproj`
+* projector of a vision model, or shards 2..N of a split GGUF. Carried on the
+* REF rather than looked up at install time, so what the operator approved in
+* the preview is exactly what the node downloads.
+*/
+var ManagedModelExtraFileSchema = zod.z.object({
+	url: zod.z.string(),
+	filename: zod.z.string(),
+	sizeBytes: zod.z.number(),
+	sha256: zod.z.string().optional()
+});
 var ManagedModelRefSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({
 		kind: zod.z.literal("catalog"),
@@ -9525,7 +9537,11 @@ var ManagedModelRefSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({
 		kind: zod.z.literal("url"),
 		url: zod.z.string(),
-		sha256: zod.z.string().optional()
+		sha256: zod.z.string().optional(),
+		/** Picker/status label; the file basename when absent. */
+		label: zod.z.string().optional(),
+		sizeBytes: zod.z.number().optional(),
+		extraFiles: zod.z.array(ManagedModelExtraFileSchema).optional()
 	}),
 	zod.z.object({
 		kind: zod.z.literal("path"),
@@ -9586,11 +9602,39 @@ var ManagedRuntimeConfigSchema = zod.z.object({
 		"q4_1",
 		"q4_0"
 	]).optional(),
+	/**
+	* Escape hatch for llama-server flags this schema does NOT model — `--jinja`
+	* (which most vision chat templates need and some language-only models
+	* dislike), `--cont-batching`, `--rope-scaling`, …
+	*
+	* It is NOT a second place to set the flags above. A token that collides
+	* with a typed field is REJECTED at start, naming the field that owns it
+	* (`assertNoOwnedFlags`), because two knobs writing the same argv is exactly
+	* the "two switches that disagree" failure this repo has already shipped
+	* twice (D62).
+	*/
+	extraArgs: zod.z.array(zod.z.string()).default([]),
 	/** Else lazy: first generate boots it. */
 	autoStart: zod.z.boolean().default(false),
 	/** 0 = never; frees RAM after quiet periods. */
 	idleStopMinutes: zod.z.number().int().default(30)
 });
+/**
+* Where a multi-GB install currently is. A single 0..1 fraction cannot answer
+* "is it stuck?" for an install that is three files (shards + mmproj) followed
+* by a sha256 pass over 22 GB — during which the fraction sat at 1.0 and the
+* node looked hung. Phase + file + bytes is the smallest shape that does.
+*/
+var LlmDownloadProgressSchema = zod.z.object({
+	phase: zod.z.enum(["downloading", "verifying"]),
+	/** The artifact currently moving, e.g. `mmproj-F16.gguf`. */
+	file: zod.z.string(),
+	fileIndex: zod.z.number().int(),
+	fileCount: zod.z.number().int(),
+	/** Across the WHOLE install, not the current file. */
+	downloadedBytes: zod.z.number(),
+	totalBytes: zod.z.number().optional()
+});
 var LlmRuntimeStatusSchema = zod.z.object({
 	/** Status is ALWAYS node-qualified. */
 	nodeId: zod.z.string(),
@@ -9607,6 +9651,8 @@ var LlmRuntimeStatusSchema = zod.z.object({
 	modelPath: zod.z.string().optional(),
 	modelId: zod.z.string().optional(),
 	downloadProgress: zod.z.number().min(0).max(1).optional(),
+	/** Detail behind `downloadProgress`; present for the same lifetime. */
+	download: LlmDownloadProgressSchema.optional(),
 	lastError: zod.z.string().optional(),
 	crashesInWindow: zod.z.number(),
 	/** Child RSS (sampled best-effort). */
@@ -9617,7 +9663,14 @@ var LlmNodeModelSchema = zod.z.object({
 	file: zod.z.string(),
 	sizeBytes: zod.z.number(),
 	catalogId: zod.z.string().optional(),
-	installedAt: zod.z.number().optional()
+	installedAt: zod.z.number().optional(),
+	/**
+	* Absolute path on the node. Present so a file that is on disk but matches
+	* no catalog entry — a custom Hugging Face install, or a GGUF the operator
+	* copied in by hand — is still SELECTABLE, as a `{kind:'path'}` ref. Without
+	* it the picker could list such a file and do nothing with it.
+	*/
+	path: zod.z.string().optional()
 });
 var LlmRuntimeDiskUsageSchema = zod.z.object({
 	nodeId: zod.z.string(),
@@ -9713,9 +9766,12 @@ var LlmProfileSchema = zod.z.object({
 	systemPrompt: zod.z.string().optional(),
 	/** Total generation bound — the only one a unary call has. */
 	timeoutMs: zod.z.number().int().positive().default(6e4),
-	/** Wait for response headers only. */
+	/** The TCP handshake only — "is the port even open". NOT the wait for
+	*  response headers: on the LM Studio / llama-server wire those are written
+	*  once the model has finished loading, so they belong to the bound below. */
 	connectTimeoutMs: zod.z.number().int().positive().default(1e4),
-	/** Accepted, but no output yet — a cold GPU load lives here. */
+	/** Accepted, but no output yet — response headers included, because a cold
+	*  GPU load is exactly what happens before them. */
 	firstTokenTimeoutMs: zod.z.number().int().positive().default(12e4),
 	/** Output started then stopped. */
 	idleTimeoutMs: zod.z.number().int().positive().default(6e4),
@@ -9778,6 +9834,36 @@ var ManagedModelCatalogEntrySchema = zod.z.object({
 	/** Vision models: companion projector file. */
 	mmprojUrl: zod.z.string().optional()
 });
+/**
+* The outcome of turning one operator-typed Hugging Face reference into a
+* download plan. A RESULT, never a throw: "this repo has 24 quantizations and
+* I will not pick for you" is a normal answer the UI has to render, not an
+* exception.
+*
+* `candidates` is the whole reason the refusal is usable — every string in it
+* is a tag that resolves when pasted back as `<org>/<repo>:<TAG>`.
+*/
+var HfModelResolutionSchema = zod.z.discriminatedUnion("ok", [zod.z.object({
+	ok: zod.z.literal(true),
+	/** Ready to hand to `installModel` unchanged. */
+	model: ManagedModelRefSchema,
+	label: zod.z.string(),
+	repo: zod.z.string(),
+	quantization: zod.z.string(),
+	purpose: zod.z.enum(["text", "vision"]),
+	totalBytes: zod.z.number(),
+	/** mmproj + shards, for the preview: an operator approving 23 GB should
+	*  see that 0.9 GB of it is a projector they did not name. */
+	extraFilenames: zod.z.array(zod.z.string())
+}), zod.z.object({
+	ok: zod.z.literal(false),
+	code: zod.z.string(),
+	message: zod.z.string(),
+	candidates: zod.z.array(zod.z.string()).optional(),
+	/** Set when the refusal was only the ceiling: re-calling with
+	*  `maxBytes: requiredBytes` is the operator's explicit override. */
+	requiredBytes: zod.z.number().optional()
+})]);
 var LlmRuntimeNodeSchema = zod.z.object({
 	nodeId: zod.z.string(),
 	reachable: zod.z.boolean(),
@@ -9845,6 +9931,25 @@ var llmCapability = {
 		listModelCatalog: require_sleep.method(zod.z.object({}), zod.z.array(ManagedModelCatalogEntrySchema)),
 		listRuntimeNodes: require_sleep.method(zod.z.object({}), zod.z.array(LlmRuntimeNodeSchema)),
 		listNodeModels: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), zod.z.array(LlmNodeModelSchema)),
+		/**
+		* One typed Hugging Face reference → a pinned, verified `ManagedModelRef`.
+		*
+		* Runs on the HUB, not on the target node: resolution needs egress to
+		* huggingface.co, and an agent that cannot reach it still installs fine
+		* through the model-distributor relay. Nothing is downloaded here — this is
+		* a tree read plus a HEAD, so the operator sees the size, the quantization
+		* and the mmproj BEFORE approving a multi-GB pull.
+		*/
+		resolveModelRef: require_sleep.method(zod.z.object({
+			/** `https://huggingface.co/<org>/<repo>/resolve/main/<f>.gguf`,
+			*  `<org>/<repo>/<f>.gguf`, `<org>/<repo>` or `<org>/<repo>:<QUANT>`. */
+			ref: zod.z.string(),
+			/** Explicit ceiling override, in bytes. Absent = the built-in ceiling. */
+			maxBytes: zod.z.number().positive().optional()
+		}), HfModelResolutionSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		installModel: require_sleep.method(zod.z.object({
 			nodeId: zod.z.string(),
 			model: ManagedModelRefSchema
@@ -16843,6 +16948,17 @@ var maxSessionHoldMsField = {
 	default: 12e4,
 	step: 5e3
 };
+/**
+* Quiet period that closes an `audioMode: 'on-motion'` audio window. Floor of
+* 5s so a rearm can never degenerate into per-event stream churn; default 90s
+* comfortably outlives the gap between two PIR wakes on a battery camera.
+*/
+var audioMotionWindowMsField = {
+	min: 5e3,
+	max: 6e5,
+	default: 9e4,
+	step: 5e3
+};
 var motionFpsField = {
 	min: 1,
 	max: 30,
@@ -17019,6 +17135,27 @@ var RunnerCameraConfigSchema = zod.z.object({
 	* resolved `CameraDetectionConfig`.
 	*/
 	maxSessionHoldMs: zod.z.number().min(maxSessionHoldMsField.min).max(maxSessionHoldMsField.max).optional(),
+	/**
+	* Orchestrator-side quiet period (ms) that closes an `audioMode:
+	* 'on-motion'` audio window, measured from the LAST motion event.
+	*
+	* This exists because the falling edge cannot be relied on. Camera-native
+	* providers emit motion as a RISING EDGE ONLY (Reolink's Baichuan push and
+	* its email-push SMTP path both emit `detected: true` and never the
+	* counterpart); only the frame-diff analyzer emits falls. So on an
+	* onboard-only camera a window that closed only on `detected: false` never
+	* closed at all, and `on-motion` silently behaved as `always-on` — on a
+	* battery camera, the one failure mode the mode exists to prevent.
+	*
+	* Every motion event rearms this timer WITHOUT restarting the stream, so a
+	* burst of re-fires costs nothing. A falling edge, when one does arrive,
+	* still closes earlier via `motionCooldownMs` — whichever comes first wins.
+	*
+	* Not consumed by the runner: carried here so it shares the per-camera
+	* device-settings surface with `motionCooldownMs`, exactly like
+	* `maxSessionHoldMs`.
+	*/
+	audioMotionWindowMs: zod.z.number().min(audioMotionWindowMsField.min).max(audioMotionWindowMsField.max).optional(),
 	motionFps: zod.z.number().min(motionFpsField.min).max(motionFpsField.max).default(motionFpsField.default),
 	detectionFps: zod.z.number().min(detectionFpsField.min).max(detectionFpsField.max).default(detectionFpsField.default),
 	motionStreamId: zod.z.string(),
@@ -17203,6 +17340,25 @@ var RunnerCameraDeviceUIFields = [
 		nullable: true,
 		nullLabel: "Default"
 	},
+	{
+		key: "audioMotionWindowMs",
+		type: "slider",
+		label: "Audio window after motion",
+		description: "How long audio keeps being analysed after the last motion event. Each new motion event extends the window without restarting the audio stream.",
+		min: audioMotionWindowMsField.min,
+		max: audioMotionWindowMsField.max,
+		step: audioMotionWindowMsField.step,
+		default: audioMotionWindowMsField.default,
+		showValue: true,
+		unit: "s",
+		displayScale: 1e3,
+		nullable: true,
+		nullLabel: "Default",
+		showWhen: {
+			field: "audioMode",
+			equals: "on-motion"
+		}
+	},
 	{
 		key: "onboardMotionDrivesAnalyzer",
 		type: "boolean",
@@ -27625,6 +27781,33 @@ var SCENE_CONDITIONS = [
 	"dawn",
 	"dusk"
 ];
+/**
+* What a scene does when the CURRENT light has no reference of its own.
+*
+* The lighting variants are not equally likely to exist. Almost every operator
+* captures daylight and then never stands outside at 22:00 to capture IR, and a
+* scene that is only ever going to be asked about a daytime question ("is the
+* bin still on the kerb at 08:00") does not need a night reference at all. The
+* night half must therefore be OPTIONAL, and optional means the scene keeps
+* working without it rather than degrading into a permanent complaint.
+*
+* - `skip` (default) — the check in that light is not made. Not a verdict, not
+*   an alarm, not even an `unknown`: the live state simply stays whatever the
+*   last covered light left it at, the latch is untouched, and the hysteresis
+*   run is neither spent nor cleared. The scene resumes by itself at first
+*   light. This is the only behaviour under which "I never captured IR" is a
+*   configuration choice instead of a nightly fault.
+* - `judge-anyway` — score against the OTHER conditions' references. Available
+*   for cameras whose IR frame is close enough to daylight (a floodlit
+*   driveway, an always-white-light doorbell), and wrong for everything else:
+*   cross-condition cosines are not comparable, so a day reference against a
+*   true IR frame collapses and the scene reports a theft at 21:40.
+*
+* Never applies when the scene has NO comparable reference at all — that is
+* "not armed yet", it is reported as `no-reference-for-condition`, and silence
+* there would hide a scene the operator never finished setting up.
+*/
+var SceneUncoveredPolicySchema = zod.z.enum(["skip", "judge-anyway"]);
 /** Reserved, engine-owned state id standing for "the region no longer looks
 *  like ANY captured reference". Never authored by an operator, never stored in
 *  `states[]` — it is the synthetic candidate that makes divergence a
@@ -27693,6 +27876,9 @@ var SCENE_DEFAULT_QUIET_SECONDS = 60;
 var SCENE_DEFAULT_OBSERVATION_SPACING_SEC = 120;
 var SCENE_DEFAULT_CHECK_INTERVAL_SEC = 60;
 var SCENE_DEFAULT_ANCHOR_THRESHOLD = .85;
+/** Night is OPTIONAL. A scene with only a daylight reference sits the IR hours
+*  out in silence rather than reporting a fault every night. */
+var SCENE_DEFAULT_UNCOVERED_POLICY = "skip";
 var SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = 8e3;
 var SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = 448;
 /** `resetScene({ recapture })` absent means TRUE — the operator decision. Read
@@ -27764,6 +27950,21 @@ var SceneMonitorSchema = zod.z.object({
 	*  automation can react to the bin coming back without the operator's own
 	*  alarm silently clearing itself. */
 	autoRestore: zod.z.boolean().default(false),
+	/** What to do when the current light has no reference of its own. See
+	*  {@link SceneUncoveredPolicySchema} — the default makes night OPTIONAL. */
+	onUncoveredCondition: SceneUncoveredPolicySchema.default(SCENE_DEFAULT_UNCOVERED_POLICY),
+	/**
+	* The light whose checks are currently being SAT OUT under
+	* `onUncoveredCondition: 'skip'` — `null` when the scene is checking normally.
+	*
+	* Engine-reported and advisory only: it moves no verdict, no latch and no
+	* hysteresis. It exists so the card can say *"night (IR) — checks paused,
+	* nothing captured in this light"* in the same calm voice as the coverage
+	* line, because the alternative is a scene that silently stops answering
+	* after sunset with nothing anywhere saying why. A skipped check must never
+	* read as a broken one.
+	*/
+	suspendedCondition: SceneConditionSchema.nullable().default(null),
 	/** Named cause when `verdict === 'unknown'`. */
 	unavailable: SceneUnavailableSchema.nullable(),
 	/** Conditions that have at least one comparable reference — the coverage line
@@ -27817,6 +28018,7 @@ var sceneMonitorCapability = {
 				minObservationSpacingSec: zod.z.number().int().min(0).max(3600).optional(),
 				anchorThreshold: zod.z.number().min(0).max(1).optional(),
 				autoRestore: zod.z.boolean().optional(),
+				onUncoveredCondition: SceneUncoveredPolicySchema.optional(),
 				/** `null` clears the vision-model adjudicator. */
 				confirm: SceneConfirmSchema.nullable().optional()
 			})
@@ -31027,6 +31229,15 @@ var BaseDeviceProvider = class extends require_sleep.BaseAddon {
 			labels: ["probe not implemented"]
 		};
 	}
+	/**
+	* Top-level devices restored at once in {@link onRestoreDevices}.
+	*
+	* Four covers the fleets this ships to without turning a boot into a burst a
+	* camera NVR answers with a refusal. A provider whose upstream is a single
+	* session with a serial command channel (a Baichuan hub, an NVR that
+	* serialises ISAPI) should lower it; nothing needs to raise it.
+	*/
+	restoreConcurrency = 4;
 	async restoreDevices(savedDevices) {
 		await this.onRestoreDevices(savedDevices);
 		if (savedDevices.length > 0) this.ctx.logger.info(`Restored ${savedDevices.length} ${this.providerName} device(s)`);
@@ -31058,15 +31269,15 @@ var BaseDeviceProvider = class extends require_sleep.BaseAddon {
 	*/
 	async onRestoreDevices(savedDevices) {
 		const restored = /* @__PURE__ */ new Set();
-		for (const saved of savedDevices) {
-			if (saved.parentDeviceId !== null) continue;
+		const topLevel = savedDevices.filter((saved) => saved.parentDeviceId === null);
+		const restoreOne = async (saved) => {
 			const Class = this.deviceClasses[saved.type];
 			if (!Class) {
 				this.ctx.logger.warn("No device class registered for restored type — skipping", {
 					tags: { stableId: saved.stableId },
 					meta: { type: saved.type }
 				});
-				continue;
+				return;
 			}
 			try {
 				await this.ctx.kernel.devices.create(saved.stableId, Class, {});
@@ -31080,7 +31291,15 @@ var BaseDeviceProvider = class extends require_sleep.BaseAddon {
 					}
 				});
 			}
-		}
+		};
+		let nextTopLevel = 0;
+		await Promise.all(Array.from({ length: Math.min(Math.max(1, this.restoreConcurrency), topLevel.length) }, async () => {
+			for (;;) {
+				const saved = topLevel[nextTopLevel++];
+				if (saved === void 0) return;
+				await restoreOne(saved);
+			}
+		}));
 		const childRows = savedDevices.filter((s) => s.parentDeviceId !== null);
 		for (const saved of childRows) {
 			const Class = this.deviceClasses[saved.type];
@@ -35760,6 +35979,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"llm.resolveModelRef": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llm.setDefault": {
 		capName: "llm",
 		capScope: "system",
@@ -42003,6 +42228,7 @@ function createSystemProxy(api) {
 			listModelCatalog: (input) => dispatch("llm", "listModelCatalog", "query", input),
 			listRuntimeNodes: (input) => dispatch("llm", "listRuntimeNodes", "query", input),
 			listNodeModels: (input) => dispatch("llm", "listNodeModels", "query", input),
+			resolveModelRef: (input) => dispatch("llm", "resolveModelRef", "mutation", input),
 			installModel: (input) => dispatch("llm", "installModel", "mutation", input),
 			deleteModel: (input) => dispatch("llm", "deleteModel", "mutation", input),
 			getRuntimeStatus: (input) => dispatch("llm", "getRuntimeStatus", "query", input),
@@ -45369,6 +45595,7 @@ exports.AvailableIntegrationTypeSchema = AvailableIntegrationTypeSchema;
 exports.BACKEND_TO_FORMAT = BACKEND_TO_FORMAT;
 exports.BASE_LIVE_EGRESS_PROFILE = BASE_LIVE_EGRESS_PROFILE;
 exports.BATTERY_DEVICE_PROFILE = BATTERY_DEVICE_PROFILE;
+exports.BOOT_RECOVERY_BACKOFF_MS = require_sleep.BOOT_RECOVERY_BACKOFF_MS;
 exports.BacklightModeSchema = BacklightModeSchema;
 exports.BackupDestinationInfoSchema = BackupDestinationInfoSchema;
 exports.BackupEntrySchema = BackupEntrySchema;
@@ -45630,6 +45857,7 @@ exports.HF_BASE_URL = HF_BASE_URL;
 exports.HF_REPO = HF_REPO;
 exports.HWACCEL_OPTIONS = HWACCEL_OPTIONS;
 exports.HealthStatusSchema = HealthStatusSchema;
+exports.HfModelResolutionSchema = HfModelResolutionSchema;
 exports.HistoryPointSchema = HistoryPointSchema;
 exports.HistoryResolutionEnum = HistoryResolutionEnum;
 exports.HumidifierStatusSchema = HumidifierStatusSchema;
@@ -45660,6 +45888,7 @@ exports.LinkedDeviceSchema = LinkedDeviceSchema;
 exports.LinkedDevicesModeSchema = LinkedDevicesModeSchema;
 exports.LlmDefaultSchema = LlmDefaultSchema;
 exports.LlmDefaultSelectorSchema = LlmDefaultSelectorSchema;
+exports.LlmDownloadProgressSchema = LlmDownloadProgressSchema;
 exports.LlmErrorCodeSchema = LlmErrorCodeSchema;
 exports.LlmGenerateBaseInputSchema = LlmGenerateBaseInputSchema;
 exports.LlmGenerateErrSchema = LlmGenerateErrSchema;
@@ -45700,6 +45929,7 @@ exports.METHOD_DEVICE_SELECTORS = METHOD_DEVICE_SELECTORS;
 exports.MODEL_FORMATS = MODEL_FORMATS;
 exports.MOTION_TRIGGER_FEATURE = MOTION_TRIGGER_FEATURE;
 exports.ManagedModelCatalogEntrySchema = ManagedModelCatalogEntrySchema;
+exports.ManagedModelExtraFileSchema = ManagedModelExtraFileSchema;
 exports.ManagedModelRefSchema = ManagedModelRefSchema;
 exports.ManagedRuntimeConfigSchema = ManagedRuntimeConfigSchema;
 exports.MaskGridDimsSchema = MaskGridDimsSchema;
@@ -45992,6 +46222,7 @@ exports.SCENE_DEFAULT_ANCHOR_THRESHOLD = SCENE_DEFAULT_ANCHOR_THRESHOLD;
 exports.SCENE_DEFAULT_CHECK_INTERVAL_SEC = SCENE_DEFAULT_CHECK_INTERVAL_SEC;
 exports.SCENE_DEFAULT_OBSERVATION_SPACING_SEC = SCENE_DEFAULT_OBSERVATION_SPACING_SEC;
 exports.SCENE_DEFAULT_QUIET_SECONDS = SCENE_DEFAULT_QUIET_SECONDS;
+exports.SCENE_DEFAULT_UNCOVERED_POLICY = SCENE_DEFAULT_UNCOVERED_POLICY;
 exports.SCENE_DIVERGED = SCENE_DIVERGED;
 exports.SCENE_RESET_RECAPTURES = SCENE_RESET_RECAPTURES;
 exports.SCOPE_PRESETS = SCOPE_PRESETS;
@@ -46014,6 +46245,7 @@ exports.SceneMonitorStateSchema = SceneMonitorStateSchema;
 exports.SceneMonitorStatusSchema = SceneMonitorStatusSchema;
 exports.SceneReferenceSchema = SceneReferenceSchema;
 exports.SceneUnavailableSchema = SceneUnavailableSchema;
+exports.SceneUncoveredPolicySchema = SceneUncoveredPolicySchema;
 exports.SceneVerdictSchema = SceneVerdictSchema;
 exports.ScopedTokenSchema = ScopedTokenSchema;
 exports.ScopedTokenSummarySchema = ScopedTokenSummarySchema;