camstack 1.2.154 → 1.2.155

package/dist/{chunk-G3ME646K.js → chunk-NL37AEPX.js}

@@ -14522,7 +14522,7 @@ function date4(params) {
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../types/dist/sleep-BEyvfshj.mjs
+// ../types/dist/sleep-BDR76Ykr.mjs
 var AUDIO_CHUNK_FORMATS = [
   "f32le",
   "pcmu",
@@ -18812,6 +18812,21 @@ var streamSignalsCapability = {
   mode: "singleton",
   deviceTypes: Object.values(DeviceType),
   runtimeState: StreamSignalsStatusSchema,
+  /**
+  * Runtime-state durability: **session** — mirrored in RAM, never written.
+  *
+  * The slice holds what the DEVICE says it can emit. That is a probed fact,
+  * not an operator choice: the provider re-declares it on every registration,
+  * so losing it loses nothing and persisting it would freeze an answer the
+  * camera is entitled to change. Measured the same day on the sibling case —
+  * `native-object-detection.supportedClasses` was persisted, and a firmware
+  * class the camera really detected stayed missing for the life of the row
+  * because the fix could not reach it.
+  *
+  * See `RuntimeStateDurability`. Enforced by
+  * `scripts/check-runtime-state-durability.ts`.
+  */
+  durability: "session",
   methods: {
     /**
     * What this device can emit. Empty is a valid and common answer — most
@@ -25592,6 +25607,29 @@ var NcAlarmConfigSchema = external_exports.object({
   settings: NcAlarmSettingsSchema,
   coverage: external_exports.array(NcAlarmModeCoverageSchema)
 });
+var NcClipRetentionAskSchema = external_exports.object({
+  /**
+  * The camera this ask is about. **Absent = every camera**, which is what a
+  * rule with no `conditions.devices` means: it can fire anywhere, so it is
+  * asking everywhere.
+  */
+  deviceId: external_exports.number().int().nonnegative().optional(),
+  /** Seconds of history the rule needs held for it. Never zero — a rule that
+  *  needs nothing produces no ask at all. */
+  seconds: external_exports.number().min(0).max(60),
+  /** The profile the rule cuts from, when it named one. Absent = the cheapest
+  *  assigned, which is what the cut defaults to. */
+  profile: CamProfileSchema.optional(),
+  /** Who is asking — so a retention the operator did not expect names a rule. */
+  ruleId: external_exports.string(),
+  ruleName: external_exports.string(),
+  /** Why this many seconds: the rule's own window, or the occupancy ceiling. */
+  reason: external_exports.enum(["window", "occupancy"])
+});
+var NcClipRetentionPlanSchema = external_exports.object({
+  rulesLoaded: external_exports.boolean(),
+  asks: external_exports.array(NcClipRetentionAskSchema).readonly()
+});
 var notificationRulesCapability = {
   name: "notification-rules",
   scope: "system",
@@ -25624,6 +25662,23 @@ var notificationRulesCapability = {
       auth: "admin"
     }),
     /**
+    * WHAT THE RULES ACTUALLY ASK the stream broker to retain, per camera.
+    *
+    * The notification centre owns the rules, so it is the only thing that can
+    * say how much history a camera's notifications will ever reach back for.
+    * Before this the broker guessed — a flat minute on every camera — and
+    * learned the PROFILE reactively, after the first clip had already been cut
+    * from the wrong one. This is the same ask stated once, in front.
+    *
+    * A QUERY, pulled by each node's broker, not a push: brokers are per node
+    * (a camera's ring lives wherever its stream is ingested) while this cap is
+    * a singleton, so a push would have to enumerate the cluster. The pull also
+    * makes the failure mode right — a broker that cannot reach the centre
+    * keeps the plan it has, and a plan that has never arrived is UNKNOWN
+    * rather than empty (D49: a read that fails changes nothing).
+    */
+    getClipRetentionAsks: method(external_exports.object({}), NcClipRetentionPlanSchema, { auth: "admin" }),
+    /**
     * PERMANENT per-camera mute — the notifications half of the per-camera
     * function switch group ([D61](../../../../docs/decisions/adr-0067.md)).
     *
@@ -27833,6 +27888,20 @@ var ReplayTrackSchema = external_exports.object({
   framesMatched: external_exports.number().int()
 });
 var RunReplayFrameProcessorResultSchema = external_exports.object({ tracks: external_exports.array(ReplayTrackSchema).readonly() });
+var AnalyticsLtsSeriesSchema = external_exports.enum([
+  "motion",
+  "audio-dbfs",
+  "battery",
+  "occupancy"
+]);
+var LtsBucketSchema = external_exports.object({
+  scope: external_exports.string(),
+  bucketStart: external_exports.number().int(),
+  samples: external_exports.number().int().nonnegative(),
+  sum: external_exports.number(),
+  min: external_exports.number(),
+  max: external_exports.number()
+});
 var pipelineAnalyticsCapability = {
   name: "pipeline-analytics",
   scope: "device",
@@ -27976,6 +28045,30 @@ var pipelineAnalyticsCapability = {
     getKeyEventsBatch: method(KeyEventBatchQueryInput, external_exports.array(KeyEventsForDeviceSchema).readonly()),
     /** Server-side bucketed event counts for the 24-hour timeline.
     *  Returns one entry per non-empty bucket; empty buckets are omitted. */
+    /**
+    * Read one camera's long-term series — 5-minute buckets, kept for a year.
+    *
+    * This is the history surface for every chart that used to be served from a
+    * RAM ring: the ring dies with the process, cannot answer about last night,
+    * and had a 60-minute horizon, while these rows are ~60 bytes and already
+    * written. `scope` is the series' own dimension — for `occupancy`, spell it
+    * with {@link occupancyScope} rather than by hand, and omit it to get every
+    * scope back at once (the caller then groups with
+    * {@link parseOccupancyScope}).
+    *
+    * Bounds are inclusive on the BUCKET START, so a range that ends mid-bucket
+    * still returns the bucket it lands in — the alternative is a chart whose
+    * last column silently disappears for five minutes out of every five.
+    */
+    readLongTermSeries: method(external_exports.object({
+      deviceId: external_exports.number(),
+      series: AnalyticsLtsSeriesSchema,
+      /** Omit for EVERY scope of this series in the range. */
+      scope: external_exports.string().optional(),
+      from: external_exports.number(),
+      to: external_exports.number(),
+      limit: external_exports.number().int().positive().optional()
+    }), external_exports.array(LtsBucketSchema).readonly()),
     getEventDensity: method(external_exports.object({
       deviceId: external_exports.number(),
       since: external_exports.number(),
@@ -29478,6 +29571,12 @@ var RunnerLocalMetricsSchema = external_exports.object({
   queueDepth: external_exports.number(),
   frameLazy: FrameLazyMetricsSchema.optional()
 });
+var OccupancyBurstRefusalSchema = external_exports.enum([
+  "not-attached",
+  "battery-asleep",
+  "not-watching",
+  "already-bursting"
+]);
 var pipelineRunnerCapability = {
   name: "pipeline-runner",
   scope: "system",
@@ -29514,6 +29613,50 @@ var pipelineRunnerCapability = {
     /** List the deviceIds currently attached to this runner. */
     getLocalCameras: method(external_exports.void(), external_exports.array(external_exports.number()).readonly()),
     /**
+    * Look at a camera NOW, out of band, because something just happened that
+    * only a fresh look can settle.
+    *
+    * The periodic recheck (`occupancyRecheckSec`, 300 s) exists to watch a
+    * still scene. It is the wrong instrument for a QUESTION that has just been
+    * asked: on device 617 a parked car's departure was observed, a departure
+    * strike was armed — and then the motion session ended, the strike decayed
+    * after its 30 s TTL, and the next periodic look arrived up to five minutes
+    * later with nothing left to confirm. Every one of those departures was
+    * settled by the entry ageing out 6 to 10 minutes of observed time later,
+    * and the notification's clip showed an empty space with nothing leaving
+    * it.
+    *
+    * Two numbers make the ask specific, and a caller that ignores them wastes
+    * the burst: a confirmation must land at least
+    * `DEPARTURE_CONFIRM_MIN_GAP_MS` (3 s) after the read that armed the
+    * strike — before that it is the same optical event and is refused — and
+    * `DEPARTURE_ABSENCE_MIN_READS` (5) consecutive unassociated frames are
+    * needed, while `occupancyRecheckFrames` defaults to FOUR. A burst of four
+    * can never confirm an absence; that is why two periodic looks were always
+    * required.
+    *
+    * The runner answers whether it actually started one. A refusal is NAMED,
+    * never a silent `false`: a camera that is asleep on battery (D173 — this
+    * must not become a self-initiated wake), detached, mid-session or already
+    * bursting are four different facts, and a caller told only "no" cannot
+    * tell a protection from a bug.
+    */
+    requestOccupancyBurst: method(external_exports.object({
+      deviceId: external_exports.number(),
+      /** How many frames to collect. The caller sizes this against what its
+      *  own confirmation needs; the runner clamps it to the field's range. */
+      frames: external_exports.number().int().positive().optional(),
+      /** Why, for the log. A burst nobody can attribute is a cost nobody can
+      *  defend — the periodic one at least has a timer to point at. */
+      reason: external_exports.string()
+    }), external_exports.object({
+      started: external_exports.boolean(),
+      refusedBecause: OccupancyBurstRefusalSchema.optional()
+    }), {
+      auth: "admin",
+      kind: "mutation"
+    }),
+    /**
     * Best-effort NATIVE-resolution crop of a retention-ring frame. Given the
     * `FrameHandle` that rode an inference-result event and a normalized `bbox`,
     * the runner asks the decode worker still holding that frame's NATIVE
@@ -41041,7 +41184,28 @@ var PerScopeBreakdownSchema = external_exports.object({
   /** Total tracked objects in this scope (frame / zone / unzoned). */
   totalObjects: external_exports.number().int().nonnegative(),
   /** Per-class count. Keys are macro class names (e.g. `person`, `car`). */
-  byClass: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative())
+  byClass: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
+  /**
+  * Of `totalObjects`, how many are STANDING — objects the census holds,
+  * present but not going anywhere (a parked car, a bin, a statue).
+  *
+  * The operator's question about a scene has two halves and they answer
+  * different things: "what is parked here" is stable for hours and must not
+  * flap, while "who is walking through" is the thing an alert is about. One
+  * number could only serve one of them, and `totalObjects` served the first
+  * badly — a passer-by moved it and every occupancy rule saw a change.
+  *
+  * `standing + transient === totalObjects`, always. The total keeps its old
+  * meaning exactly, so no rule written against it changes behaviour.
+  *
+  * ABSENT means UNKNOWN, never zero (D393): a snapshot from a node older than
+  * this field cannot say, and a reader that folds absence in as 0 reports "no
+  * parked objects here" about a camera whose lot is full.
+  */
+  standingObjects: external_exports.number().int().nonnegative().optional(),
+  /** Of `totalObjects`, how many are passing through. See `standingObjects` —
+  *  same absence rule. */
+  transientObjects: external_exports.number().int().nonnegative().optional()
 });
 var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
   zoneId: external_exports.string(),
@@ -44362,6 +44526,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "view"
   },
+  "notificationRules.getClipRetentionAsks": {
+    capName: "notification-rules",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "notificationRules.getConditionCatalog": {
     capName: "notification-rules",
     capScope: "system",
@@ -44872,6 +45042,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "pipelineAnalytics.readLongTermSeries": {
+    capName: "pipeline-analytics",
+    capScope: "device",
+    addonId: null,
+    access: "view"
+  },
   "pipelineAnalytics.rebuildObjectEmbeddings": {
     capName: "pipeline-analytics",
     capScope: "device",
@@ -45544,6 +45720,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "pipelineRunner.requestOccupancyBurst": {
+    capName: "pipeline-runner",
+    capScope: "system",
+    addonId: null,
+    access: "create"
+  },
   "pipelineRunner.runDetailSubtree": {
     capName: "pipeline-runner",
     capScope: "system",
@@ -48688,6 +48870,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
     form: "single",
     optional: false
   }],
+  "pipelineAnalytics.readLongTermSeries": [{
+    name: "deviceId",
+    form: "single",
+    optional: false
+  }],
   "pipelineAnalytics.rebuildObjectEmbeddings": [{
     name: "deviceId",
     form: "single",
@@ -48878,6 +49065,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
     form: "single",
     optional: false
   }],
+  "pipelineRunner.requestOccupancyBurst": [{
+    name: "deviceId",
+    form: "single",
+    optional: false
+  }],
   "pipelineRunner.runDetailSubtree": [{
     name: "deviceId",
     form: "single",

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runDiscover
-} from "./chunk-G3ME646K.js";
+} from "./chunk-NL37AEPX.js";
 import "./chunk-LMMQX4CK.js";
 
 // src/cli.ts
@@ -38,7 +38,7 @@ async function runServe(args) {
     ...typeof values.data === "string" ? { data: values.data } : {}
   };
   Object.assign(process.env, buildServeEnv(opts));
-  await import("./launcher-ZQZHWQ6F.js");
+  await import("./launcher-QNK4R2TG.js");
 }
 
 // src/commands/agent.ts
@@ -83,7 +83,7 @@ async function runAgent(args) {
     ...typeof values.port === "string" ? { port: values.port } : {}
   };
   Object.assign(process.env, buildAgentEnv(opts));
-  await import("./launcher-ZQZHWQ6F.js");
+  await import("./launcher-QNK4R2TG.js");
 }
 
 // src/commands/setup.ts
@@ -1140,7 +1140,7 @@ function isUnknown(_value) {
   return true;
 }
 async function resolveServerInteractive(presetNamespace) {
-  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-DFMZ7HZD.js");
+  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-FFHB2Q76.js");
   if (presetNamespace) {
     const spinner4 = clack.spinner();
     spinner4.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);

package/dist/{discover-DFMZ7HZD.js → discover-FFHB2Q76.js}

@@ -5,7 +5,7 @@ import {
   filterHubNodes,
   resolveHubFromDiscovered,
   runDiscover
-} from "./chunk-G3ME646K.js";
+} from "./chunk-NL37AEPX.js";
 import "./chunk-LMMQX4CK.js";
 export {
   DEFAULT_HUB_HTTPS_PORT,