@camstack/types 1.2.72 → 1.2.74

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-CKWYtvXl.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)
 });
 /**
@@ -12313,9 +12457,66 @@ var NcDeviceStateConditionSchema = zod.z.object({
 	/** Any of these matches. */
 	states: zod.z.array(zod.z.string().min(1)).min(1)
 });
+/**
+* "This rule applies only while scene `sceneId` is `matched` / `diverged`."
+*
+* A GATE, not a trigger. `occupancy` and `audio` each DISCRIMINATE their rule —
+* carrying one makes the rule fire on that subject and nothing else. Scene is
+* the other shape entirely, the `deviceState` shape: it narrows a rule that
+* already has a trigger ("tell me about a person at the front door, but only
+* while the bin is still out"). That is why it composes with every delivery
+* instead of owning one, and why no new `NcDelivery` member and no new subject
+* kind exist for it — see D159.
+*
+* ── Identity ───────────────────────────────────────────────────────────────
+* `sceneId` is `SceneMonitor.id`, a `randomUUID()` minted by `createScene` —
+* globally unique, so it needs no device to disambiguate it. `deviceId` is
+* carried as a HINT for the editor and for the log line, never as part of the
+* lookup key: a rule whose hint drifted must still gate correctly.
+*
+* ── Which boolean ──────────────────────────────────────────────────────────
+* `latched` ABSENT means "whatever the scene itself says" — `SceneMonitor.emit`
+* already declares which boolean drives notification rules, and a second knob
+* that could disagree with it is exactly the D62 failure. Set it only to
+* override one rule against the scene's own default.
+*
+*  - LIVE reading (`emit`/`latched` resolve to live): passes iff
+*    `verdict === requiredState`. `unknown` — no reference for this light, view
+*    shifted, no snapshot — passes NEITHER. A scene that cannot judge is not
+*    evidence, in either direction.
+*  - LATCHED reading: passes iff `latched === (requiredState === 'diverged')`.
+*    The latch is a durable fact about the past ("it has diverged since I armed
+*    it"), so a camera that has gone dark does not clear it — that is the whole
+*    reason the operator asked for a latch.
+*
+* The gate reads an in-memory mirror (`NcSceneStateCache`) refreshed OFF the
+* event path, never the cap: D49. A mirror that has never loaded, or a scene it
+* does not carry, reads absent and the rule does NOT fire — fail closed, and
+* said out loud in the log rather than dropped in silence.
+*/
+var NcSceneConditionSchema = zod.z.object({
+	/** `SceneMonitor.id` — the uuid the cap mints. The whole lookup key. */
+	sceneId: zod.z.string().min(1),
+	/** The camera the scene lives on. A hint for the editor and the log line. */
+	deviceId: zod.z.number().int().optional(),
+	/** The state the scene must be in for the rule to fire. */
+	requiredState: zod.z.enum(["matched", "diverged"]),
+	/**
+	* Read the LATCH (`true`) or the LIVE verdict (`false`). Absent = follow the
+	* scene's own `emit` field, which is the only place that decision belongs.
+	*/
+	latched: zod.z.boolean().optional()
+});
 var NcConditionsSchema = zod.z.object({
 	/** Gate on ANOTHER device's current state (the alarm armed, a switch on). */
 	deviceState: NcDeviceStateConditionSchema.optional(),
+	/**
+	* Gate on a SCENE's state — "only while the bin is still out". Composes with
+	* every trigger (detection, occupancy, audio, sensor, package, track-end);
+	* unlike `occupancy`/`audio` it discriminates nothing. See
+	* {@link NcSceneCondition} and D159.
+	*/
+	scene: NcSceneConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: zod.z.array(zod.z.number()).optional(),
 	/** Detector class names (any overlap with the record's class set). */
@@ -12954,6 +13155,7 @@ var NcConditionDescriptorSchema = zod.z.object({
 		"occupancy",
 		"audio",
 		"deviceState",
+		"scene",
 		"systemEvent"
 	]),
 	operator: zod.z.enum([
@@ -13308,6 +13510,21 @@ var NC_CONDITION_CATALOG = [
 		phase: "P2",
 		description: "Only fire while another device is in one of the chosen states — the alarm armed, a switch on, a contact closed. A state that cannot be read does NOT fire."
 	},
+	{
+		id: "scene",
+		group: "scope",
+		label: "Scene state",
+		valueType: "scene",
+		operator: "in",
+		appliesTo: [
+			"immediate",
+			"track-end",
+			"device-event",
+			"package-event"
+		],
+		phase: "P3",
+		description: "Only fire while a scene is matched (the baseline is what we see) or diverged (it demonstrably is not) — “tell me about a person at the door, but only while the bin is still out”. A scene that cannot judge, or one this hub has not read yet, does NOT fire."
+	},
 	{
 		id: "sensorKinds",
 		group: "device",
@@ -27373,10 +27590,22 @@ 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.
+* **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.
@@ -27552,12 +27781,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({
@@ -28436,6 +28659,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",
@@ -28453,6 +28731,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`. */
@@ -35366,6 +35670,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",
@@ -38300,6 +38610,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",
@@ -38318,6 +38634,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",
@@ -38342,6 +38664,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",
@@ -41662,6 +41990,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),
@@ -41958,7 +42287,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),
@@ -42058,8 +42390,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;
@@ -42074,6 +42414,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
@@ -42098,13 +42458,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)
@@ -45294,10 +45670,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;
@@ -45441,6 +45819,7 @@ exports.NcRuleNotificationButtonSchema = NcRuleNotificationButtonSchema;
 exports.NcRulePatchSchema = NcRulePatchSchema;
 exports.NcRuleSchema = NcRuleSchema;
 exports.NcRuleTargetSchema = NcRuleTargetSchema;
+exports.NcSceneConditionSchema = NcSceneConditionSchema;
 exports.NcScheduleSchema = NcScheduleSchema;
 exports.NcScheduleWindowSchema = NcScheduleWindowSchema;
 exports.NcSnoozeInputSchema = NcSnoozeInputSchema;
@@ -45652,11 +46031,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;
@@ -45832,6 +46215,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;