@camstack/types 1.2.71 → 1.2.73

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-DbVrpKVz.js");
+const require_sleep = require("./sleep-B-mRsuDp.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");
@@ -9438,6 +9438,35 @@ var LlmImageSchema = zod.z.object({
 	bytes: zod.z.instanceof(Uint8Array),
 	mimeType: zod.z.string()
 });
+/**
+* Retry policy. `enabled: false` is NOT the same as `maxAttempts: 1` in intent —
+* the flag is what a consumer table flips, the count is what the operator tunes.
+* A retry doubles the wall time of a call, so the two gates that run inside a
+* notification's budget keep it off (see `CONSUMER_RETRY_POLICY` in addon-ai).
+*/
+var LlmRetryPolicySchema = zod.z.object({
+	enabled: zod.z.boolean().default(false),
+	/** Total attempts INCLUDING the first. 1 = no retry. */
+	maxAttempts: zod.z.number().int().min(1).max(5).default(1)
+});
+/**
+* The four bounds, as ONE vocabulary.
+*
+* These were three magic constants inside the test chat (`connect` 10 s,
+* `first token` 120 s, `idle` 60 s) plus a separate `timeoutMs` on the profile.
+* They are the same four questions on every call path, so they are profile
+* fields with defaults — and each still names a DIFFERENT failure:
+*   - `connect`      — the endpoint never accepted the request (port closed).
+*   - `firstToken`   — accepted, nothing produced yet (cold model loading).
+*   - `idle`         — tokens started then stopped (a stall, model proven up).
+*   - `total`        — the whole generation, the only bound a unary call has.
+*/
+var LlmTimeoutDefaults = {
+	totalMs: 6e4,
+	connectMs: 1e4,
+	firstTokenMs: 12e4,
+	idleMs: 6e4
+};
 var LlmGenerateBaseInputSchema = zod.z.object({
 	/** Collection routing (the notification-output posture). */
 	addonId: zod.z.string().optional(),
@@ -9452,7 +9481,28 @@ var LlmGenerateBaseInputSchema = zod.z.object({
 	jsonSchema: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
 	/** Per-call override of the profile default. */
 	maxTokens: zod.z.number().int().positive().optional(),
-	temperature: zod.z.number().optional()
+	temperature: zod.z.number().optional(),
+	/** Per-call override of the profile default (nucleus sampling). */
+	topP: zod.z.number().min(0).max(1).optional(),
+	/** Per-call override of the profile default (top-k sampling). */
+	topK: zod.z.number().int().positive().optional(),
+	/** Per-call override of `profile.timeoutMs` — the total generation bound. */
+	timeoutMs: zod.z.number().int().positive().optional(),
+	/** Per-call override; beats both the consumer table and the profile. */
+	retry: LlmRetryPolicySchema.optional(),
+	/**
+	* Caller-minted id that makes this generation CANCELLABLE.
+	*
+	* Without it a caller that stops waiting cannot stop the work: the gates race
+	* the call against 8 s and free their own slot when the timer wins, while the
+	* generation upstream keeps running to `profile.timeoutMs` — 60 s by default,
+	* on a single-threaded local model. The per-camera bound then counts WAITS,
+	* not generations, and the real load is unbounded.
+	*
+	* `AbortSignal` cannot cross a process boundary; an id can. Pass one here and
+	* `llm.cancel({ requestId })` tears the socket down.
+	*/
+	requestId: zod.z.string().optional()
 });
 //#endregion
 //#region src/capabilities/llm-runtime.cap.ts
@@ -9493,8 +9543,49 @@ var ManagedRuntimeConfigSchema = zod.z.object({
 	gpuLayers: zod.z.number().int().default(0),
 	/** Default: cpus-2, clamped ≥1 (resolved node-side). */
 	threads: zod.z.number().int().optional(),
-	/** Concurrent slots. */
+	/** Concurrent slots (`--parallel`). */
 	parallel: zod.z.number().int().default(1),
+	/** Logical batch size (`-b`). Larger = faster prompt ingest, more RAM. */
+	batchSize: zod.z.number().int().positive().optional(),
+	/** Physical batch / micro-batch (`-ub`). */
+	ubatchSize: zod.z.number().int().positive().optional(),
+	/**
+	* `--flash-attn`. Cuts KV-cache memory on the backends that implement it and
+	* is a no-op elsewhere, so it is offered rather than assumed.
+	*/
+	flashAttention: zod.z.boolean().default(false),
+	/**
+	* `--mlock`. Pins the weights in RAM so the OS cannot page them out mid
+	* inference. Costs the full model size in resident memory — which is exactly
+	* what the RAM budget is counting.
+	*/
+	mlock: zod.z.boolean().default(false),
+	/**
+	* `--no-mmap`. Reads the whole GGUF up front instead of mapping it. Slower to
+	* start, but avoids the page-fault stalls a network or spinning-disk model
+	* store produces on every first token.
+	*/
+	noMmap: zod.z.boolean().default(false),
+	/** `--cache-type-k` / `--cache-type-v` — quantising the KV cache is the
+	*  cheapest way to fit a longer context in the same RAM. */
+	cacheTypeK: zod.z.enum([
+		"f32",
+		"f16",
+		"q8_0",
+		"q5_1",
+		"q5_0",
+		"q4_1",
+		"q4_0"
+	]).optional(),
+	cacheTypeV: zod.z.enum([
+		"f32",
+		"f16",
+		"q8_0",
+		"q5_1",
+		"q5_0",
+		"q4_1",
+		"q4_0"
+	]).optional(),
 	/** Else lazy: first generate boots it. */
 	autoStart: zod.z.boolean().default(false),
 	/** 0 = never; frees RAM after quiet periods. */
@@ -9600,10 +9691,44 @@ var LlmProfileSchema = zod.z.object({
 	baseUrl: zod.z.string().optional(),
 	/** ConfigUISchema type:'password' — never round-trips (spec §5). */
 	apiKey: zod.z.string().optional(),
+	/** Vision on/off. A vision call against a `false` profile is REFUSED, never
+	*  degraded to text — that shipped once and produced a confident answer to a
+	*  question about a picture nobody sent. */
 	supportsVision: zod.z.boolean(),
 	temperature: zod.z.number().min(0).max(2).optional(),
+	/** Nucleus sampling. Every wire we speak has it. */
+	topP: zod.z.number().min(0).max(1).optional(),
+	/** Top-k sampling. Carried only by the wires that have it — NEITHER OpenAI
+	*  wire does, and the client drops it there (measured: the request body gets
+	*  `top_p` and no `top_k`). The profile editor hides the field wherever it
+	*  would change nothing; `KINDS_WITH_TOP_K` is the single owner of that list. */
+	topK: zod.z.number().int().positive().optional(),
 	maxTokens: zod.z.number().int().positive().optional(),
+	/** Prompt context window. Advisory for cloud kinds (they enforce their own);
+	*  for `managed-local` it is the llama.cpp `--ctx-size` the runtime starts
+	*  the model with, so it is the one field that changes a PROCESS. */
+	contextLength: zod.z.number().int().positive().optional(),
+	/** Default system prompt. A caller's `system` REPLACES it (never appends —
+	*  two system prompts fighting is worse than either alone). */
+	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. */
+	connectTimeoutMs: zod.z.number().int().positive().default(1e4),
+	/** Accepted, but no output yet — a cold GPU load lives here. */
+	firstTokenTimeoutMs: zod.z.number().int().positive().default(12e4),
+	/** Output started then stopped. */
+	idleTimeoutMs: zod.z.number().int().positive().default(6e4),
+	/** Profile-level default. The per-consumer table and a per-call override
+	*  both beat it — see `resolveRetryPolicy`. */
+	retry: LlmRetryPolicySchema.default({
+		enabled: false,
+		maxAttempts: 1
+	}),
+	/** Whether this profile may use tools. The tool-call plumbing rides the
+	*  library; the REGISTRY of callable tools is ours and is empty in v1, so a
+	*  `true` here buys the wiring, not behaviour, until tools are registered. */
+	toolsEnabled: zod.z.boolean().default(false),
 	extraHeaders: zod.z.record(zod.z.string(), zod.z.string()).optional(),
 	/** kind === 'managed-local' only (spec §4). */
 	runtime: ManagedRuntimeConfigSchema.optional()
@@ -9676,6 +9801,17 @@ var llmCapability = {
 	methods: {
 		generate: require_sleep.method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
 		generateVision: require_sleep.method(GenerateVisionInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		/**
+		* Stop a generation started with a `requestId`.
+		*
+		* Idempotent and always successful: cancelling an id that already finished,
+		* never existed, or was cancelled a moment ago is a no-op. A caller that has
+		* given up must never have to handle an error from giving up.
+		*/
+		cancel: require_sleep.method(zod.z.object({
+			addonId: zod.z.string().optional(),
+			requestId: zod.z.string()
+		}), zod.z.void(), { kind: "mutation" }),
 		listProfileKinds: require_sleep.method(zod.z.object({}), zod.z.array(LlmProfileKindDescriptorSchema)),
 		listProfiles: require_sleep.method(zod.z.object({}), zod.z.array(LlmProfileSchema)),
 		upsertProfile: require_sleep.method(zod.z.object({ profile: LlmProfileSchema }), LlmProfileSchema, {
@@ -12125,28 +12261,36 @@ var NC_AUDIO_DBFS_FLOOR = -96;
 /**
 * Audio condition (IMMEDIATE trigger) — a rule on SOUND, not on a picture.
 *
-* Operator-approved vocabulary (2026-08-12, option A — the same one the
-* reference notifier uses, so an operator moving between them re-uses what
-* they already know): a rule matches when, over a sampling window of
-* `samplingSeconds`, at least `hitPercent`% of the audio samples in that
-* window are HITS. A sample is a hit when it satisfies BOTH present filters:
-*
-*  - `dbThreshold` — its level is at or above this many dBFS (see
-*    {@link NC_AUDIO_DBFS_FLOOR}: negative-going, `0` = full scale);
-*  - `labels` — the classifier put at least one of these labels on it.
-*
-* Both are OPTIONAL and independent, which is the point of the shape: a
-* loudness rule ("something loud at 3am") needs no model to be right, and a
-* label rule ("a dog barked") needs no threshold. **Fail-closed when NEITHER
-* is given** — a window in which every sample is trivially a hit would fire on
-* silence, so the engine refuses such a condition rather than notifying on
-* nothing (the schema cannot express "at least one of" without becoming a
-* ZodEffects the cap path would have to special-case).
-*
-* `hitPercent` is over the samples the window actually HOLDS, and the window
-* must be FULL before it can match — a window that has been open for two
-* seconds of its ten is 100% of nothing, and firing on it would make
-* `samplingSeconds` decorative.
+* **TWO EXCLUSIVE MODES** (operator decision 2026-08-14, D157). Which one a
+* rule is in is not a stored field — it is WHICH FILTER the rule carries, so
+* there is no second switch that can disagree with the first and every rule
+* authored before the decision migrates for free (`audioModeOf`):
+*
+*  - **LABEL mode — `labels` present.** The rule fires on the FIRST frame the
+*    classifier labels with one of them. No window, no percentage:
+*    `hitPercent` and `samplingSeconds` are ignored, and the rule's own
+*    `throttle` cooldown is the only brake. The per-label confidence floor is
+*    the analyzer's (`classificationMinScore`, per device) — a label only
+*    reaches this condition if the classifier was already confident enough.
+*  - **LEVEL mode — `dbThreshold` present, no labels.** The sampling window IS
+*    the condition: at least `hitPercent`% of the samples over
+*    `samplingSeconds` must be at or above `dbThreshold` dBFS (see
+*    {@link NC_AUDIO_DBFS_FLOOR}: negative-going, `0` = full scale). The window
+*    must be FULL before it can match — a window open for two of its ten
+*    seconds is 100% of nothing.
+*
+* **Why label mode has no window.** It had one, and it never fired: the
+* analyzer emits ~1 audio frame per second but YAMNet only LABELS one to three
+* of them per episode, even through continuous crying. The measured maximum
+* `hitPercent` over the whole live history was 40 — under the shipped default
+* of 60, so a label rule could not fire at all, ever. A percentage of frames is
+* the wrong question to ask of a sparse classifier.
+*
+* **Fail-closed when NEITHER is given** — every sample would be a trivial hit
+* and the rule would fire on silence. The schema cannot express "exactly one
+* of" without becoming a ZodEffects the cap path would have to special-case, so
+* the exclusivity is enforced where every editor writes (`patchAudio`) and a
+* legacy rule carrying both resolves to LABEL (the mode that fires).
 *
 * Labels are the audio macro classes (`AUDIO_MACRO_LABELS` / the NC taxonomy's
 * `audio-*` ids). Both spellings are accepted — the matcher normalizes the
@@ -12154,13 +12298,13 @@ var NC_AUDIO_DBFS_FLOOR = -96;
 * an operator who typed `dog` mean the same thing.
 */
 var NcAudioConditionSchema = zod.z.object({
-	/** Audio macro labels; absent = any sound (level-only rule). */
+	/** LABEL MODE: audio macro labels. Present ⇒ fires on the first labelled frame. */
 	labels: zod.z.array(zod.z.string().min(1)).min(1).optional(),
-	/** Level floor in dBFS (negative-going, `0` = full scale); absent = any level. */
+	/** LEVEL MODE: floor in dBFS (negative-going, `0` = full scale). */
 	dbThreshold: zod.z.number().min(-96).max(0).optional(),
-	/** Percentage of the window's samples that must be hits (1–100). */
+	/** LEVEL MODE ONLY: percentage of the window's samples that must be hits (1–100). */
 	hitPercent: zod.z.number().int().min(1).max(100).default(60),
-	/** Length of the sampling window in seconds. */
+	/** LEVEL MODE ONLY: length of the sampling window in seconds. */
 	samplingSeconds: zod.z.number().int().min(1).max(300).default(10)
 });
 /**
@@ -27373,14 +27517,64 @@ var recordingExportCapability = {
 * thing except the comparator: `similarity` (CLIP cosine at the same ROI coords
 * vs condition-tagged references) and `llm` (vision-LLM judgment over the crop).
 *
-* D14 device-config archetype (`deviceConfig.ui.kind:'widget'`) — the framework
-* derives the device-detail contribution; the provider carries NO hand-written
-* settings-contribution methods. `status.kind:'push'` — the engine pushes on
-* every hysteresis flip / availability change; consumers never poll.
-*/
-/** Extensible condition tag. Seeded 'day' | 'night'; open by design so more can
-*  be added without a wire break (matching falls back to any-condition refs). */
+* **No `deviceConfig`, deliberately.** This shipped as the D14 widget archetype,
+* which put a "Scenes" tab on one camera's detail page. That is the wrong shape
+* for the thing: a scene is a standing question about the property ("is the bin
+* still out"), and the operator's question is "which of my scenes have tripped",
+* across every camera at once — not "what does camera 617 think". Buried one
+* camera deep it also could not be found. The surface is now a top-level admin
+* page (`/scenes`, `pages/Scenes.tsx`) that lists every scene on every camera and
+* picks the camera inside the create flow, the same shape Events and Faces have.
+*
+* The consequence to keep in mind: `host/scene-monitor-editor` is gone from
+* `HOST_WIDGETS` too. `scripts/check-host-widget-resolves.ts` asserts BOTH
+* directions, so a registration nobody declares fails exactly as loudly as a
+* declaration nobody registers. The editor is imported directly by the page.
+*
+* `status.kind:'push'` — the engine pushes on every hysteresis flip /
+* availability change; consumers never poll.
+*/
+/** Extensible condition tag. Seeded 'day' | 'ir' (the two variants the operator
+*  captures) plus 'night' | 'dawn' | 'dusk' from the resolver's sun-times band.
+*  Open by design so more can be added without a wire break.
+*
+*  Matching does NOT fall back across conditions: cross-condition cosines are
+*  not comparable, so "I have never seen this scene in this light" is reported
+*  as `unknown`, never guessed. A day reference scored against an IR frame
+*  collapses the cosine and would latch a false alarm every single night. */
 var SceneConditionSchema = zod.z.string();
+/** The conditions the resolver can produce. Seeds for the UI's coverage line;
+*  the wire type stays an open string. */
+var SCENE_CONDITIONS = [
+	"day",
+	"ir",
+	"night",
+	"dawn",
+	"dusk"
+];
+/** 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
+*  first-class hysteresis input rather than a bare `return`. */
+var SCENE_DIVERGED = "__diverged__";
+/** `matched` = the baseline is what we see; `diverged` = it demonstrably is not;
+*  `unknown` = we cannot judge (no reference for this condition, encoder model
+*  changed, view shifted, no snapshot). `unknown` is a real value, not a null,
+*  and never counts toward hysteresis in either direction. */
+var SceneVerdictSchema = zod.z.enum([
+	"matched",
+	"diverged",
+	"unknown"
+]);
+/** Why a scene cannot judge. Named, because this feature's failure mode is
+*  silence that reads as "nothing has happened". */
+var SceneUnavailableSchema = zod.z.enum([
+	"no-reference-for-condition",
+	"view-shifted",
+	"no-vision-profile",
+	"encoder-model-changed",
+	"no-snapshot"
+]);
 /** One captured reference — condition-tagged, model-version-gated. `embedding`
 *  is `number[]` (Float32Array does NOT survive MsgPack/UDS). */
 var SceneReferenceSchema = zod.z.object({
@@ -27388,7 +27582,14 @@ var SceneReferenceSchema = zod.z.object({
 	modelId: zod.z.string(),
 	condition: SceneConditionSchema,
 	capturedAt: zod.z.number(),
-	thumbnailMediaId: zod.z.string().optional()
+	thumbnailMediaId: zod.z.string().optional(),
+	/** Whole-frame (downscaled) embedding captured alongside the ROI crop. The
+	*  anti-view-shift anchor: a bumped camera, a PTZ preset or a re-aim makes the
+	*  normalized rect frame a different piece of world, and the scene would
+	*  diverge forever with a perfectly plausible cosine. Checked LAZILY, only
+	*  when hysteresis is about to flip — one extra encode per candidate
+	*  transition, not per poll. */
+	anchorEmbedding: zod.z.array(zod.z.number()).optional()
 });
 var SceneMonitorStateSchema = zod.z.object({
 	id: zod.z.string(),
@@ -27410,6 +27611,38 @@ var SceneCheckSchema = zod.z.discriminatedUnion("mode", [zod.z.object({
 	profileId: zod.z.string().optional(),
 	hysteresisCount: zod.z.number().int().positive()
 })]);
+/** Defaults, as CONSTANTS rather than only as Zod `.default()`. A Zod default
+*  does NOT run on the addon→addon cap path, so every runtime seam reads these
+*  as absent-with-a-constant (the `NcConfirmSchema` lesson, three production
+*  failures in one day). The schema defaults and these values are the same
+*  numbers on purpose. */
+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;
+var SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = 8e3;
+var SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = 448;
+/** `resetScene({ recapture })` absent means TRUE — the operator decision. Read
+*  at the seam, because a Zod `.optional()` carries no default at all. */
+var SCENE_RESET_RECAPTURES = true;
+/**
+* Vision-model adjudication of a candidate flip. Field names deliberately
+* mirror `NcConfirmSchema` so an operator meets one vocabulary, not two.
+*
+* `onTimeout` defaults to **'hold'**, the OPPOSITE of `NcConfirmGate`'s
+* fail-open: a notification suppressed is the worse error there, but a vision
+* model that timed out has not told us the bin is gone, and a latch is a
+* stateful claim that costs the operator a trip to reset.
+*/
+var SceneConfirmSchema = zod.z.object({
+	enabled: zod.z.boolean().default(false),
+	prompt: zod.z.string().min(1).max(1e3),
+	profileId: zod.z.string().optional(),
+	timeoutMs: zod.z.number().int().min(1e3).max(2e4).default(SCENE_CONFIRM_DEFAULT_TIMEOUT_MS),
+	maxImagePx: zod.z.number().int().min(64).max(2048).default(448),
+	/** What a timeout / unavailable model means for the PENDING flip. */
+	onTimeout: zod.z.enum(["flip", "hold"]).default("hold")
+});
 var SceneMonitorSchema = zod.z.object({
 	id: zod.z.string(),
 	label: zod.z.string(),
@@ -27428,7 +27661,41 @@ var SceneMonitorSchema = zod.z.object({
 	lastConfidence: zod.z.number().nullable(),
 	currentCondition: SceneConditionSchema.nullable(),
 	availability: zod.z.enum(["ok", "unavailable"]),
-	unavailableReason: zod.z.string().nullable()
+	unavailableReason: zod.z.string().nullable(),
+	/** Which state is "the initial screen". `null` until the first capture. */
+	baselineStateId: zod.z.string().nullable(),
+	/** Which boolean drives notification rules and any export. */
+	emit: zod.z.enum(["latched", "live"]).default("latched"),
+	/** Live: does the region match the baseline RIGHT NOW. */
+	verdict: SceneVerdictSchema,
+	/** Has it been `diverged` at least once since `armedAt` — the operator's boolean. */
+	latched: zod.z.boolean(),
+	/** Last reset (or creation). */
+	armedAt: zod.z.number(),
+	divergedAt: zod.z.number().nullable(),
+	restoredAt: zod.z.number().nullable(),
+	/** A check is only COUNTED when the device has been quiet this long. Motion
+	*  during the window DISCARDS the observation — a car pulling up in front of
+	*  the bin must not be able to spend hysteresis credit. */
+	quietSeconds: zod.z.number().int().min(0).max(3600).default(60),
+	/** An observation only advances the pending count when it is at least this
+	*  far from the previously counted one, so N agreeing checks span real time
+	*  rather than N adjacent polls inside one occlusion. */
+	minObservationSpacingSec: zod.z.number().int().min(0).max(3600).default(120),
+	/** Vision-model adjudication of a candidate flip. Similarity primary only. */
+	confirm: SceneConfirmSchema.optional(),
+	/** Whole-frame anchor cosine below which a flip is REFUSED as `view-shifted`. */
+	anchorThreshold: zod.z.number().min(0).max(1).default(SCENE_DEFAULT_ANCHOR_THRESHOLD),
+	/** Clear the latch on its own when the scene matches again? Default false —
+	*  `restoredAt` and the `scene-restored` edge are recorded regardless, so an
+	*  automation can react to the bin coming back without the operator's own
+	*  alarm silently clearing itself. */
+	autoRestore: zod.z.boolean().default(false),
+	/** Named cause when `verdict === 'unknown'`. */
+	unavailable: SceneUnavailableSchema.nullable(),
+	/** Conditions that have at least one comparable reference — the coverage line
+	*  ("day ✓ · ir ✓ · dusk ✗") that turns a silent fallback into a visible fact. */
+	coveredConditions: zod.z.array(SceneConditionSchema)
 });
 var SceneMonitorStatusSchema = zod.z.object({
 	monitors: zod.z.array(SceneMonitorSchema),
@@ -27441,12 +27708,6 @@ var sceneMonitorCapability = {
 	kind: "wrapper",
 	defaultActive: true,
 	deviceTypes: [require_sleep.DeviceType.Camera],
-	deviceConfig: { ui: {
-		kind: "widget",
-		widgetId: "host/scene-monitor-editor",
-		tab: "scenes",
-		label: "Scenes"
-	} },
 	methods: {
 		listScenes: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), SceneMonitorStatusSchema),
 		createScene: require_sleep.method(zod.z.object({
@@ -27477,7 +27738,14 @@ var sceneMonitorCapability = {
 					"both"
 				]).optional(),
 				checkIntervalSec: zod.z.number().optional(),
-				check: SceneCheckSchema.optional()
+				check: SceneCheckSchema.optional(),
+				emit: zod.z.enum(["latched", "live"]).optional(),
+				quietSeconds: zod.z.number().int().min(0).max(3600).optional(),
+				minObservationSpacingSec: zod.z.number().int().min(0).max(3600).optional(),
+				anchorThreshold: zod.z.number().min(0).max(1).optional(),
+				autoRestore: zod.z.boolean().optional(),
+				/** `null` clears the vision-model adjudicator. */
+				confirm: SceneConfirmSchema.nullable().optional()
 			})
 		}), zod.z.void(), {
 			kind: "mutation",
@@ -27518,6 +27786,26 @@ var sceneMonitorCapability = {
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* Clear the latch, re-arm, and — by default — RE-CAPTURE the baseline for
+		* the CURRENT condition. The bin never goes back in exactly the same spot;
+		* "reset" in the operator's head means *this is the new normal*, and
+		* re-capture is what makes the feature self-healing against slow drift
+		* instead of failing silently weeks later.
+		*
+		* Reachable from three surfaces on this one mutation: the scene card, a
+		* notification button (an `onTrigger` sequence with a `kind:'cap'` step —
+		* no new Notification-Center code at all), and tRPC for scripts.
+		*/
+		resetScene: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			monitorId: zod.z.string(),
+			/** Defaults to TRUE at the provider seam — see `SCENE_RESET_RECAPTURES`. */
+			recapture: zod.z.boolean().optional()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	},
 	status: {
@@ -28298,6 +28586,61 @@ var NetworkAddressSchema = zod.z.object({
 	family: zod.z.string(),
 	internal: zod.z.boolean()
 });
+/**
+* Provenance of the site coordinates, and the whole reason this is not just two
+* numbers.
+*
+*   - `operator-set` — a human typed it, or accepted a detection. Authoritative;
+*     nothing overwrites it.
+*   - `derived-from-ip` — the hub geolocated its own public IP once, because a
+*     default that is right to a few kilometres beats the coarse UTC clock split
+*     the sun-times consumers otherwise fall back to.
+*
+* The UI shows which one it is. An operator who cannot tell a guess from their
+* own input will eventually trust the guess.
+*/
+var SiteLocationSourceSchema = zod.z.enum(["operator-set", "derived-from-ip"]);
+/**
+* Where the installation physically is — a fact of the SITE, not of any addon.
+*
+* It used to live in `pipeline-analytics`' global settings, which made a
+* property of the building a property of one analytics addon. Anything that
+* needs sun-times (scene condition variants today; anything solar tomorrow)
+* reads it from here.
+*/
+var SiteLocationSchema = zod.z.object({
+	/** WGS84 decimal degrees. */
+	latitude: zod.z.number().min(-90).max(90),
+	longitude: zod.z.number().min(-180).max(180),
+	source: SiteLocationSourceSchema,
+	/** Epoch ms the value was last written. */
+	updatedAt: zod.z.number(),
+	/**
+	* Human-readable place the geo-IP service reported ("Napoli, IT"). Display
+	* only — never parsed, never matched on. Absent for an operator-typed value.
+	*/
+	label: zod.z.string().optional()
+});
+/**
+* The read shape: the location plus the honest state of the one-shot derivation.
+*
+* `derivationAttemptedAt` is what makes the "one call, ever" contract
+* inspectable. When it is set and `location` is null, the geo-IP lookup ran and
+* failed; the hub will NOT try again on its own — the fallback is declared
+* (consumers degrade to their own last resort) and the operator either types the
+* coordinates or presses detect.
+*/
+var SiteLocationStatusSchema = zod.z.object({
+	location: SiteLocationSchema.nullable(),
+	derivationAttemptedAt: zod.z.number().nullable(),
+	/** Why the last derivation failed, for the UI to show instead of a shrug. */
+	derivationError: zod.z.string().nullable()
+});
+/** `null` clears the location and re-arms nothing — the derivation stays spent. */
+var SetSiteLocationInputSchema = zod.z.object({
+	latitude: zod.z.number().min(-90).max(90),
+	longitude: zod.z.number().min(-180).max(180)
+}).nullable();
 var systemCapability = {
 	name: "system",
 	scope: "system",
@@ -28315,6 +28658,32 @@ var systemCapability = {
 		forceRetentionCleanup: require_sleep.method(zod.z.void(), zod.z.void(), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* The site coordinates, deriving a default from the hub's public IP on the
+		* FIRST read that finds nothing stored.
+		*
+		* The derivation is one-shot and bounded: one outbound request, a few
+		* seconds, its outcome persisted either way. A hub with no internet pays it
+		* once and never again, and neither boot nor any consumer is blocked on it —
+		* the caller gets `location: null` and degrades exactly as it did before this
+		* method existed.
+		*/
+		getSiteLocation: require_sleep.method(zod.z.void(), SiteLocationStatusSchema),
+		/** Operator input. Always lands as `source: 'operator-set'`. */
+		setSiteLocation: require_sleep.method(SetSiteLocationInputSchema, SiteLocationStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Re-run the geo-IP derivation now. The ONLY way a spent or failed
+		* derivation is retried — there is no timer, and no read path retries.
+		* Overwrites an existing `derived-from-ip` value; refuses to clobber an
+		* `operator-set` one.
+		*/
+		detectSiteLocation: require_sleep.method(zod.z.void(), SiteLocationStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
 		})
 	},
 	/** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
@@ -35228,6 +35597,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"llm.cancel": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llm.deleteModel": {
 		capName: "llm",
 		capScope: "system",
@@ -37478,6 +37853,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"sceneMonitor.resetScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"sceneMonitor.updateScene": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -38156,6 +38537,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.detectSiteLocation": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"system.featureFlags": {
 		capName: "system",
 		capScope: "system",
@@ -38174,6 +38561,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"system.getSiteLocation": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"system.health": {
 		capName: "system",
 		capScope: "system",
@@ -38198,6 +38591,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.setSiteLocation": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"terminalSession.adoptLegacyMonitor": {
 		capName: "terminal-session",
 		capScope: "system",
@@ -40417,6 +40816,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"sceneMonitor.resetScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"sceneMonitor.updateScene": [{
 		name: "deviceId",
 		form: "single",
@@ -41513,6 +41917,7 @@ function createSystemProxy(api) {
 		llm: {
 			generate: (input) => dispatch("llm", "generate", "mutation", input),
 			generateVision: (input) => dispatch("llm", "generateVision", "mutation", input),
+			cancel: (input) => dispatch("llm", "cancel", "mutation", input),
 			listProfileKinds: (input) => dispatch("llm", "listProfileKinds", "query", input),
 			listProfiles: (input) => dispatch("llm", "listProfiles", "query", input),
 			upsertProfile: (input) => dispatch("llm", "upsertProfile", "mutation", input),
@@ -41809,7 +42214,10 @@ function createSystemProxy(api) {
 			networkAddresses: (input) => dispatch("system", "networkAddresses", "query", input),
 			getRetentionConfig: (input) => dispatch("system", "getRetentionConfig", "query", input),
 			setRetentionConfig: (input) => dispatch("system", "setRetentionConfig", "mutation", input),
-			forceRetentionCleanup: (input) => dispatch("system", "forceRetentionCleanup", "mutation", input)
+			forceRetentionCleanup: (input) => dispatch("system", "forceRetentionCleanup", "mutation", input),
+			getSiteLocation: (input) => dispatch("system", "getSiteLocation", "query", input),
+			setSiteLocation: (input) => dispatch("system", "setSiteLocation", "mutation", input),
+			detectSiteLocation: (input) => dispatch("system", "detectSiteLocation", "mutation", input)
 		},
 		terminalSession: {
 			listProfiles: (input) => dispatch("terminalSession", "listProfiles", "query", input),
@@ -41909,8 +42317,16 @@ var NC_AUDIO_DB_STEP = 3;
 * an absent `dbThreshold` means "any level" and stays absent until asked for,
 * and a stepper seeded at the -96 floor would need thirty taps to reach a
 * threshold that can actually fire.
+*
+* **It was -30 and -30 is a trap.** dBFS is negative-going, so a HIGHER number
+* is a NARROWER filter, and the sounds this hub is actually asked about are not
+* loud: measured on the live installation, real crying sits between -55 and
+* -26 dBFS. A floor at -30 therefore rejects most of the very sound the
+* operator turned the filter on for, and the rule looks broken rather than
+* mis-seeded. The offered floor is the QUIET end of that measured band; the
+* editor says which way the number runs rather than leaving it to be inferred.
 */
-var NC_AUDIO_DB_OFFERED = -30;
+var NC_AUDIO_DB_OFFERED = -55;
 var NC_AUDIO_HIT_PERCENT_MIN = 1;
 var NC_AUDIO_HIT_PERCENT_MAX = 100;
 var NC_AUDIO_SAMPLING_MIN_SEC = 1;
@@ -41925,6 +42341,26 @@ function audioOrDefaults(value) {
 	return value ?? NC_AUDIO_DEFAULTS;
 }
 /**
+* Which mode this condition is in — the ONE place that question is answered.
+*
+* The mode is NOT a stored field, deliberately. It is which filter the rule
+* carries, so every rule authored before the modes existed migrates for free
+* and there is no second switch that can disagree with the first (the failure
+* this repo has shipped twice). `null` = neither filter, which the engine
+* refuses (see {@link audioIsFailClosed}).
+*
+* A LEGACY rule carrying BOTH resolves to `label`: it is the mode that fires,
+* and the alternative is silently keeping a window the operator can no longer
+* see in the editor. Nothing new can reach this branch — {@link patchAudio}
+* clears the other filter on every write.
+*/
+function audioModeOf(value) {
+	if (value === void 0) return null;
+	if (value.labels !== void 0 && value.labels.length > 0) return "label";
+	if (value.dbThreshold !== void 0) return "level";
+	return null;
+}
+/**
 * True when the condition names NEITHER a level floor NOR any label. The engine
 * refuses such a rule (every sample is a hit, so the window fires on silence) —
 * an editor warns instead of letting the operator ship a rule that never
@@ -41949,13 +42385,29 @@ function has(patch, key) {
 * The result is always in-bounds for `NcAudioConditionSchema`, and a cleared
 * filter is OMITTED rather than written as an explicit `undefined` (which
 * survives a merge patch as a deliberate erase and reads as authored).
+*
+* **The two modes are exclusive here, structurally.** Writing labels drops any
+* stored `dbThreshold`; writing a `dbThreshold` drops the labels. The schema
+* cannot say "exactly one of" without becoming a ZodEffects the cap path would
+* have to special-case, so the exclusivity lives in the ONE function every
+* editor writes through — which also means a legacy both-filters rule is
+* normalized the first time it is touched, onto the mode {@link audioModeOf}
+* already reads it as.
+*
+* Switching to `level` with nothing stored seeds {@link NC_AUDIO_DB_OFFERED}:
+* a level rule with no floor is fail-closed, and handing the operator a mode
+* that cannot fire is the trap this whole change exists to remove.
 */
 function patchAudio(current, patch) {
 	const base = audioOrDefaults(current);
-	const labels = has(patch, "labels") ? patch.labels : base.labels;
-	const dbThreshold = has(patch, "dbThreshold") ? patch.dbThreshold : base.dbThreshold;
+	const wantedLabels = has(patch, "labels") ? patch.labels : base.labels;
+	const wantedDb = has(patch, "dbThreshold") ? patch.dbThreshold : base.dbThreshold;
+	const hasLabels = wantedLabels !== void 0 && wantedLabels.length > 0;
+	const mode = patch.mode ?? (has(patch, "labels") && hasLabels ? "label" : has(patch, "dbThreshold") && wantedDb !== void 0 ? "level" : hasLabels ? "label" : wantedDb !== void 0 ? "level" : null);
+	const labels = mode === "label" && hasLabels ? wantedLabels : void 0;
+	const dbThreshold = mode !== "level" ? void 0 : wantedDb ?? (patch.mode === "level" ? -55 : void 0);
 	return {
-		...labels !== void 0 && labels.length > 0 ? { labels: [...labels] } : {},
+		...labels !== void 0 ? { labels: [...labels] } : {},
 		...dbThreshold !== void 0 ? { dbThreshold: clampInt(dbThreshold, NC_AUDIO_DB_MIN, 0) } : {},
 		hitPercent: clampInt(patch.hitPercent ?? base.hitPercent, 1, 100),
 		samplingSeconds: clampInt(patch.samplingSeconds ?? base.samplingSeconds, 1, 300)
@@ -45145,10 +45597,12 @@ exports.LlmNodeModelSchema = LlmNodeModelSchema;
 exports.LlmProfileKindDescriptorSchema = LlmProfileKindDescriptorSchema;
 exports.LlmProfileKindSchema = LlmProfileKindSchema;
 exports.LlmProfileSchema = LlmProfileSchema;
+exports.LlmRetryPolicySchema = LlmRetryPolicySchema;
 exports.LlmRuntimeCompleteInputSchema = LlmRuntimeCompleteInputSchema;
 exports.LlmRuntimeDiskUsageSchema = LlmRuntimeDiskUsageSchema;
 exports.LlmRuntimeNodeSchema = LlmRuntimeNodeSchema;
 exports.LlmRuntimeStatusSchema = LlmRuntimeStatusSchema;
+exports.LlmTimeoutDefaults = LlmTimeoutDefaults;
 exports.LlmUsageRollupSchema = LlmUsageRollupSchema;
 exports.LlmUsageSchema = LlmUsageSchema;
 exports.LocateSegmentResultSchema = LocateSegmentResultSchema;
@@ -45457,6 +45911,15 @@ exports.RunnerFrameSourceSchema = RunnerFrameSourceSchema;
 exports.RunnerInferenceDeviceSchema = RunnerInferenceDeviceSchema;
 exports.RunnerLocalLoadSchema = RunnerLocalLoadSchema;
 exports.RunnerLocalMetricsSchema = RunnerLocalMetricsSchema;
+exports.SCENE_CONDITIONS = SCENE_CONDITIONS;
+exports.SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX;
+exports.SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = SCENE_CONFIRM_DEFAULT_TIMEOUT_MS;
+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_DIVERGED = SCENE_DIVERGED;
+exports.SCENE_RESET_RECAPTURES = SCENE_RESET_RECAPTURES;
 exports.SCOPE_PRESETS = SCOPE_PRESETS;
 exports.SCRUB_THUMBNAIL_PRESETS = SCRUB_THUMBNAIL_PRESETS;
 exports.SCRUB_THUMBNAIL_PRESET_LABELS = SCRUB_THUMBNAIL_PRESET_LABELS;
@@ -45471,10 +45934,13 @@ exports.SYSTEM_CAP_NAMES = SYSTEM_CAP_NAMES;
 exports.SYSTEM_SCOPE_DEVICE_METHODS = SYSTEM_SCOPE_DEVICE_METHODS;
 exports.SceneCheckSchema = SceneCheckSchema;
 exports.SceneConditionSchema = SceneConditionSchema;
+exports.SceneConfirmSchema = SceneConfirmSchema;
 exports.SceneMonitorSchema = SceneMonitorSchema;
 exports.SceneMonitorStateSchema = SceneMonitorStateSchema;
 exports.SceneMonitorStatusSchema = SceneMonitorStatusSchema;
 exports.SceneReferenceSchema = SceneReferenceSchema;
+exports.SceneUnavailableSchema = SceneUnavailableSchema;
+exports.SceneVerdictSchema = SceneVerdictSchema;
 exports.ScopedTokenSchema = ScopedTokenSchema;
 exports.ScopedTokenSummarySchema = ScopedTokenSummarySchema;
 exports.ScoredObjectEventSchema = ScoredObjectEventSchema;
@@ -45491,11 +45957,15 @@ exports.ServerRollbackInfoSchema = ServerRollbackInfoSchema;
 exports.ServerUpdateActionResultSchema = ServerUpdateActionResultSchema;
 exports.ServerUpdateCheckResultSchema = ServerUpdateCheckResultSchema;
 exports.ServerUpdateStateSchema = ServerUpdateStateSchema;
+exports.SetSiteLocationInputSchema = SetSiteLocationInputSchema;
 exports.SettingsPatchSchema = SettingsPatchSchema;
 exports.SettingsRecordSchema = SettingsRecordSchema;
 exports.SettingsSchemaWithValuesSchema = SettingsSchemaWithValuesSchema;
 exports.SettingsUpdateResultSchema = SettingsUpdateResultSchema;
 exports.ShmRingStatsSchema = ShmRingStatsSchema;
+exports.SiteLocationSchema = SiteLocationSchema;
+exports.SiteLocationSourceSchema = SiteLocationSourceSchema;
+exports.SiteLocationStatusSchema = SiteLocationStatusSchema;
 exports.SmokeStatusSchema = SmokeStatusSchema;
 exports.SmtpStatusSchema = SmtpStatusSchema;
 exports.SnapshotImageSchema = SnapshotImageSchema;
@@ -45671,6 +46141,7 @@ exports.audioCodecCapability = audioCodecCapability;
 exports.audioIsFailClosed = audioIsFailClosed;
 exports.audioLabelChoices = audioLabelChoices;
 exports.audioMetricsCapability = audioMetricsCapability;
+exports.audioModeOf = audioModeOf;
 exports.audioOrDefaults = audioOrDefaults;
 exports.audioPlanFromEncodeProfile = require_canonical_hash.audioPlanFromEncodeProfile;
 exports.authProviderCapability = authProviderCapability;