camstack 1.2.145 → 1.2.147

package/dist/{chunk-W67ATFOA.js → chunk-IGFZA22D.js}

@@ -14522,7 +14522,7 @@ function date4(params) {
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../types/dist/sleep-CnLyvg3w.mjs
+// ../types/dist/sleep-DEuj7E3j.mjs
 var AUDIO_CHUNK_FORMATS = [
   "f32le",
   "pcmu",
@@ -15384,7 +15384,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
-// ../types/dist/canonical-hash-rO1sRmEK.mjs
+// ../types/dist/canonical-hash-Ch5bSjFG.mjs
 import { createHash } from "crypto";
 var DEFAULT_MAX_UNIT_BYTES = 16 * 1024 * 1024;
 
@@ -15447,7 +15447,23 @@ var VideoEncodeSchema = external_exports.object({
     "zerolatency",
     "film",
     "animation"
-  ]).optional()
+  ]).optional(),
+  /**
+  * ONE slice per access unit.
+  *
+  * `-tune zerolatency` turns on x264's sliced threads, and a frame then leaves
+  * the encoder as five NAL slices that share one RTP timestamp and carry one
+  * marker bit. A libwebrtc depacketiser sees five frame-starts and one
+  * frame-end per frame: the first pictures render and the video then freezes
+  * for good while the audio, on its own plane, plays on. Measured on this hub
+  * 2026-09-13 against the Echo, and reduced to one slice by this flag alone.
+  *
+  * A NAMED field and not a raw flag, because {@link EgressEncodeSchema} omits
+  * `outputArgs` on purpose: an opaque array is part of the sharing key, so two
+  * consumers meaning the same thing spelled differently would stop sharing one
+  * child. Absent means "whatever the encoder does" — today's behaviour.
+  */
+  singleSlicePerFrame: external_exports.boolean().optional()
 });
 var AudioEncodeSchema = external_exports.union([external_exports.literal("passthrough"), external_exports.object({
   codec: external_exports.enum([
@@ -15506,7 +15522,11 @@ var WEBRTC_EGRESS_PROFILE = {
 };
 var ALEXA_EGRESS_PROFILE = {
   ...BASE_LIVE_EGRESS_PROFILE,
-  audio: { codec: "opus" }
+  audio: { codec: "opus" },
+  video: {
+    ...BASE_LIVE_EGRESS_PROFILE.video,
+    singleSlicePerFrame: true
+  }
 };
 var wiringProbeKindSchema = external_exports.enum([
   "singleton",
@@ -18768,6 +18788,39 @@ var cameraPipelineConfigCapability = {
   exposesDeviceSettings: true,
   methods: {}
 };
+var StreamSignalSchema = external_exports.object({
+  /** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
+  code: external_exports.string().min(1),
+  /** What an operator reads in the picker. The provider's own wording. */
+  label: external_exports.string().min(1),
+  /**
+  * Whether the provider recommends this signal ON when a camera is first set
+  * up. A provider knows which of its signals are cheap and reliable; an
+  * operator should not have to discover that by trial. Reolink recommends
+  * both of its own.
+  */
+  recommended: external_exports.boolean()
+});
+var StreamSignalsStatusSchema = external_exports.object({
+  signals: external_exports.array(StreamSignalSchema),
+  lastFetchedAt: external_exports.number()
+});
+var streamSignalsCapability = {
+  name: "stream-signals",
+  scope: "device",
+  deviceNative: true,
+  mode: "singleton",
+  deviceTypes: Object.values(DeviceType),
+  runtimeState: StreamSignalsStatusSchema,
+  methods: {
+    /**
+    * What this device can emit. Empty is a valid and common answer — most
+    * cameras have nothing to offer here, and an empty list is what makes the
+    * broker's picker show nothing rather than a false choice.
+    */
+    listSignals: method(external_exports.void(), external_exports.array(StreamSignalSchema).readonly())
+  }
+};
 var StreamFormatSchema = external_exports.enum([
   "webrtc",
   "hls",
@@ -19120,6 +19173,46 @@ var streamBrokerCapability = {
   mode: "singleton",
   exposesDeviceSettings: true,
   methods: {
+    /**
+    * A device reporting that one of ITS OWN signals just fired.
+    *
+    * The provider calls this; nothing polls. The broker then decides whether
+    * to wake the source, and the decision has two terms that must BOTH hold:
+    *
+    *  - the signal is ENABLED for this camera (the operator's per-camera
+    *    choice — a camera may declare a signal the operator does not want
+    *    waking anything), and
+    *  - a consumer is actually attached and waiting on the prestream. Waking
+    *    a camera nobody is watching is the one thing a battery camera must
+    *    never do, and a signal arriving with no consumer is exactly that.
+    *
+    * Reported, never inferred: a signal that fires while the stream is
+    * already up refreshes the hold instead of starting a second one, which is
+    * what makes continuous motion keep a camera awake without stacking
+    * timers.
+    *
+    * `code` is the provider's own, from `streamSignals.listSignals`. An
+    * unknown code is REFUSED rather than treated as a wildcard wake — a
+    * provider and an operator disagreeing about a name must not become a
+    * camera that wakes for everything.
+    */
+    reportStreamSignal: method(external_exports.object({
+      deviceId: external_exports.number().int().nonnegative(),
+      /** The provider's signal code. */
+      code: external_exports.string().min(1),
+      /** Ms epoch. Absent ⇒ now. */
+      at: external_exports.number().optional()
+    }), external_exports.object({
+      /** Whether the broker acted on it, and if not, why. */
+      accepted: external_exports.boolean(),
+      reason: external_exports.enum([
+        "woke",
+        "hold-extended",
+        "not-enabled",
+        "no-consumer",
+        "unknown-code"
+      ])
+    }), { kind: "mutation" }),
     publishCameraStream: method(external_exports.object({
       deviceId: external_exports.number().int().nonnegative(),
       camStreamId: external_exports.string().min(1),
@@ -19597,6 +19690,16 @@ var PickStreamRequirementsSchema = external_exports.object({
   acceptCodecs: external_exports.array(StreamCodecSchema).readonly().optional(),
   /** Minimum vertical resolution. Streams shorter than this are dropped. */
   minHeight: external_exports.number().int().positive().optional(),
+  /**
+  * Maximum vertical resolution. Streams TALLER than this are dropped.
+  *
+  * A consumer can have a ceiling as real as its floor: Alexa documents
+  * 480p to 1080p, and a 4K stream is as unusable to an Echo as a 360p one.
+  * Without this the ceiling had to be re-implemented by every caller — and
+  * one caller implementing it privately is how a second scoring authority
+  * gets born.
+  */
+  maxHeight: external_exports.number().int().positive().optional(),
   /** Minimum horizontal resolution. */
   minWidth: external_exports.number().int().positive().optional(),
   /**
@@ -19613,7 +19716,22 @@ var PickStreamRequirementsSchema = external_exports.object({
   * transcoded" guard: if the device is already serving the consumer's
   * codec end-to-end, there's nothing to optimise.
   */
-  requireSiblingCodec: external_exports.array(StreamCodecSchema).readonly().optional()
+  requireSiblingCodec: external_exports.array(StreamCodecSchema).readonly().optional(),
+  /**
+  * Whether a stream the consumer CANNOT decode may still be picked, on the
+  * understanding that it will be transcoded.
+  *
+  * Default `false` — today's behaviour, and the right one for a bypass
+  * question ("is there a stream I can forward untouched?"). Set `true` to
+  * ask the larger question: "what is the best stream for me, transcoding if
+  * I must?" A stream that satisfies `acceptCodecs` always outranks one that
+  * does not, so a passthrough is never lost to a transcode; the answer says
+  * which it is in {@link PickedCamStreamSchema.transcodes}.
+  *
+  * This is what lets one picker serve both the bypass and the full source
+  * choice, instead of a consumer scoring privately when the bypass misses.
+  */
+  allowTranscode: external_exports.boolean().optional()
 }).readonly();
 var PickStreamPreferencesSchema = external_exports.object({
   /**
@@ -19627,12 +19745,32 @@ var PickStreamPreferencesSchema = external_exports.object({
   * picks the tallest stream; `'lowest'` picks the shortest (used by
   * memory-constrained consumers / Apple Home guest sessions).
   */
-  resolutionPreference: external_exports.enum(["highest", "lowest"]).optional()
+  resolutionPreference: external_exports.enum(["highest", "lowest"]).optional(),
+  /**
+  * The height the consumer actually wants to DELIVER.
+  *
+  * Not a constraint — an ordering. With it set, the SMALLEST stream at or
+  * above the target wins, and only if nothing reaches it does the tallest
+  * take over. Pulling 1296 lines to draw 720 on a 1280x800 Echo panel costs
+  * a decode and buys nothing, and `resolutionPreference: 'highest'` cannot
+  * express that: it says "as big as possible", which is a different wish.
+  *
+  * Ignored when absent, so every existing caller keeps its ordering.
+  */
+  targetHeight: external_exports.number().int().positive().optional()
 }).readonly();
 var PickedCamStreamSchema = external_exports.object({
   camStreamId: external_exports.string(),
   codec: external_exports.string().optional(),
   resolution: CamStreamResolutionSchema.optional(),
+  /**
+  * Whether serving this stream requires a decode + re-encode.
+  *
+  * `false` is a stream the consumer can take as it stands. Only ever `true`
+  * when the caller asked for it with `allowTranscode`, so a caller that did
+  * not ask cannot be handed a cost it never agreed to pay.
+  */
+  transcodes: external_exports.boolean(),
   /** One-line explanation of why this stream won — for logs / debug UI. */
   reason: external_exports.string()
 });
@@ -24443,6 +24581,8 @@ var NcSystemEventKindSchema = external_exports.enum([
   "device-enabled",
   "device-battery-low",
   "device-battery-normal",
+  "device-consumable-low",
+  "device-consumable-normal",
   "stream-online",
   "stream-offline",
   "node-online",
@@ -24461,6 +24601,7 @@ var NcSystemEventKindSchema = external_exports.enum([
   "addon-updated",
   "server-updated",
   "export-completed",
+  "backup-completed",
   "camera-online",
   "camera-offline",
   "camera-disabled",
@@ -27320,13 +27461,91 @@ var SummariesQueryInput = external_exports.object({
   deviceIds: external_exports.array(external_exports.number()).min(1),
   since: external_exports.number().optional(),
   until: external_exports.number().optional(),
-  limit: external_exports.number().int().min(1).max(200).default(50)
+  limit: external_exports.number().int().min(1).max(200).default(50),
+  /** The same member-wise filter {@link listRecentSummaries} takes — one
+  *  meaning of "dog" on every summary surface. */
+  classes: external_exports.array(external_exports.string().min(1).max(60)).max(40).optional()
+});
+var SummaryMemberSchema = external_exports.object({
+  trackId: external_exports.string(),
+  /**
+  * The track's class at the time it JOINED, or `null` when it was unresolved
+  * and the track no longer exists to fill it.
+  *
+  * The join, not the latest opinion: class voting can re-decide a track's
+  * class afterwards, and a group's composition is the history of who came
+  * together. A consumer counts these to badge a thumbnail — "two people and a
+  * dog" — rather than being handed a second, denormalised tally that would
+  * drift from the members it claims to describe.
+  */
+  className: external_exports.string().nullable(),
+  /** `primary` is the one member that carries the group's identity. */
+  role: external_exports.enum([
+    "primary",
+    "sibling",
+    "child"
+  ]).nullable(),
+  joinedAt: external_exports.number(),
+  /** Tier 1 — the sub-class (`dog`, `van`), resolved from the member's track
+  *  at read time. Absent when nothing resolved, never an empty string. */
+  label: external_exports.string().optional(),
+  /** Tier 2 — the instance: a person's name, a plate. Absent when the pipeline
+  *  recognised nobody, and absent for a member whose track has been pruned —
+  *  a thumbnail that names the wrong person is worse than one naming nobody. */
+  subLabel: external_exports.string().optional()
 });
-var SummariesPageSchema = external_exports.object({ summaries: external_exports.array(SummarySchema).readonly() });
 var SummaryDetailSchema = external_exports.object({
   summary: SummarySchema,
-  /** Member track ids, in absorption order. */
-  trackIds: external_exports.array(external_exports.string()).readonly()
+  /** Members in absorption order, oldest join first. */
+  members: external_exports.array(SummaryMemberSchema).readonly()
+});
+var SummaryListItemSchema = external_exports.object({
+  summary: SummarySchema,
+  /** Class counts, most numerous first; `className: null` is a member whose
+  *  class never resolved, counted so the counts add up to `memberCount`. */
+  classes: external_exports.array(external_exports.object({
+    className: external_exports.string().nullable(),
+    count: external_exports.number().int().positive()
+  })).readonly()
+});
+var SummariesPageSchema = external_exports.object({ summaries: external_exports.array(SummaryListItemSchema).readonly() });
+var RecentSummariesQueryInput = external_exports.object({
+  /** Devices to merge. An empty array yields an empty page. */
+  deviceIds: external_exports.array(external_exports.number()),
+  /** Window lower bound on `lastActiveAt` (inclusive). */
+  since: external_exports.number().optional(),
+  /** Window upper bound on `lastActiveAt` (inclusive). */
+  until: external_exports.number().optional(),
+  limit: external_exports.number().int().min(1).max(500).default(100),
+  /** Opaque continuation cursor from a previous page's `nextCursor`. */
+  cursor: external_exports.string().optional(),
+  /**
+  * Restrict to these classes — THE SAME FIELD `listRecentTracks` takes, and
+  * deliberately the same name: the events filter tree emits one list of ticked
+  * taxonomy nodes, and a summaries feed that called it something else would
+  * make the operator's one filter component produce two shapes.
+  *
+  * A question about the MEMBERS: a group matches when ANY of them does. "Show
+  * me the arrivals with a dog" has to return the group of four people who had
+  * one with them; a filter on the group's own fields could only ever answer
+  * about its primary.
+  *
+  * Matched against all THREE tiers of a member — the class (`animal`), the
+  * sub-class (`dog`) and the instance (a name, a plate) — because which tier a
+  * ticked node lives on is the taxonomy's business, not the caller's. `dog` is
+  * an event kind in the tree and a tier-1 label on an `animal` track; a filter
+  * that read only the class would answer "animal" and never "dog".
+  *
+  * ABSENT or EMPTY means no filter — absent is not a selection of none.
+  */
+  classes: external_exports.array(external_exports.string().min(1).max(60)).max(40).optional()
+});
+var RecentSummariesPageSchema = external_exports.object({
+  /** Ordered by (`lastActiveAt` DESC, id DESC). Same light item as
+  *  {@link listSummaries} — one list shape, so a card renders the same
+  *  whichever feed drew it. */
+  summaries: external_exports.array(SummaryListItemSchema).readonly(),
+  nextCursor: external_exports.string().nullable()
 });
 var RecentTracksPageSchema = external_exports.object({
   /** Merged page, ordered by (`lastSeen` DESC, `trackId` DESC). */
@@ -27678,6 +27897,11 @@ var pipelineAnalyticsCapability = {
     listRecentTracks: method(RecentTracksQueryInput, RecentTracksPageSchema),
     /** Newest first by `openedAt`, for a camera set, inside an optional window. */
     listSummaries: method(SummariesQueryInput, SummariesPageSchema),
+    /**
+    * The PAGED feed — the reel and the Events gallery. Same cursor contract as
+    * {@link listRecentTracks}, so one screen cannot hold two ideas of newest.
+    */
+    listRecentSummaries: method(RecentSummariesQueryInput, RecentSummariesPageSchema),
     /** One summary with its member track ids; `null` for an id nobody wrote. */
     getSummary: method(external_exports.object({ id: external_exports.string() }), SummaryDetailSchema.nullable()),
     clearTracks: method(external_exports.object({ deviceId: external_exports.number() }), external_exports.void(), {
@@ -32142,10 +32366,28 @@ var webrtcSessionCapability = {
     getSessionState: method(external_exports.object({
       deviceId: external_exports.number().int().nonnegative(),
       sessionId: external_exports.string()
-    }), external_exports.object({ pendingRenegotiation: external_exports.object({
-      target: WebrtcStreamTargetSchema,
-      epoch: external_exports.number()
-    }).nullable() }))
+    }), external_exports.object({
+      pendingRenegotiation: external_exports.object({
+        target: WebrtcStreamTargetSchema,
+        epoch: external_exports.number()
+      }).nullable(),
+      /**
+      * Whether the session still EXISTS.
+      *
+      * A consumer that holds a resource for the life of a session needs to
+      * be able to ask, because a session does not always end the way it
+      * began. Measured on this hub 2026-09-13: an Echo that got stuck never
+      * sent `SessionDisconnected`, so the Alexa exporter's
+      * `releaseEgressTranscode` never ran, and a 2304x1296 HEVC to 720p
+      * H.264 transcode kept running for NOBODY for more than twenty
+      * minutes. The WebRTC session had logged `WebRTC session closed`
+      * minutes earlier — the broker knew; the holder had no way to ask.
+      *
+      * `false` for a session id the provider has never heard of, which is
+      * the same answer as "it ended": either way nothing is holding it up.
+      */
+      alive: external_exports.boolean()
+    }))
   },
   /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
   mount: { kind: "server-provided" }
@@ -39867,7 +40109,29 @@ var LoggingSettingsPatchSchema = external_exports.object({
   * disarmed the channels it did not mention would make the Levels page and
   * the Diagnostics page fight over the same value.
   */
-  channels: external_exports.array(LogChannelWindowPatchSchema).readonly().optional()
+  channels: external_exports.array(LogChannelWindowPatchSchema).readonly().optional(),
+  /**
+  * How many days the analytics OPS LOG is kept — the audit trail of what
+  * retention actually deleted.
+  *
+  * It lives HERE, on the logging document, and not on the analytics addon's
+  * settings form, on the operator's instruction: every other log-ish window in
+  * this system is configured through this one document, and a retention audit
+  * configured somewhere else is a second place to look when the question is
+  * "what happened to my data".
+  *
+  * That placement has a cost worth stating: this document ships in the
+  * framework closure, so this knob needs a published `@camstack/server` while
+  * the four windows beside it (D485) reach a node on `camstack deploy`.
+  *
+  * `retention-model.ts` argued this one must NOT follow a device window,
+  * because the audit trail is the history of the SWEEP and not of the camera.
+  * That argument stands and is untouched — what changes is that 30 days stops
+  * being a constant nobody can reach. `0` keeps it forever. The floor is 1 day
+  * rather than 0-as-delete: an audit log truncated to nothing is precisely the
+  * state in which the next 9.5 GiB leak cannot be explained.
+  */
+  opsLogRetentionDays: external_exports.number().int().min(0).max(3650).optional()
 });
 var ReportedLoadContributionSchema = LoadContributionSchema.extend({ addonId: external_exports.string() });
 var ReportedFailureContributionSchema = FailureContributionSchema.extend({ addonId: external_exports.string() });
@@ -39906,6 +40170,14 @@ var LoggingSettingsStateSchema = external_exports.object({
   channels: external_exports.array(LogChannelDescriptorSchema).readonly(),
   /** The channels ARMED right now, each with its deadline. */
   activeChannels: external_exports.array(LogChannelWindowStateSchema).readonly(),
+  /**
+  * The ops-log window in days, as it is in force. `0` = kept forever.
+  *
+  * Reported rather than left to the caller's memory of what it wrote: this is
+  * the value the analytics sweep will actually use, and an operator asking how
+  * long their audit trail lives should not have to infer it from a default.
+  */
+  opsLogRetentionDays: external_exports.number().int().min(0),
   persisted: external_exports.boolean()
 });
 var systemCapability = {
@@ -44435,6 +44707,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "view"
   },
+  "pipelineAnalytics.listRecentSummaries": {
+    capName: "pipeline-analytics",
+    capScope: "device",
+    addonId: null,
+    access: "view"
+  },
   "pipelineAnalytics.listRecentTracks": {
     capName: "pipeline-analytics",
     capScope: "device",
@@ -46397,6 +46675,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "streamBroker.reportStreamSignal": {
+    capName: "stream-broker",
+    capScope: "system",
+    addonId: null,
+    access: "create"
+  },
   "streamBroker.restartProfile": {
     capName: "stream-broker",
     capScope: "system",
@@ -46481,6 +46765,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "streamSignals.listSignals": {
+    capName: "stream-signals",
+    capScope: "device",
+    addonId: null,
+    access: "view"
+  },
   "switch.setState": {
     capName: "switch",
     capScope: "device",
@@ -48262,6 +48552,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
     form: "single",
     optional: true
   }],
+  "pipelineAnalytics.listRecentSummaries": [{
+    name: "deviceIds",
+    form: "array",
+    optional: false
+  }],
   "pipelineAnalytics.listRecentTracks": [{
     name: "deviceIds",
     form: "array",
@@ -48848,6 +49143,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
     form: "single",
     optional: false
   }],
+  "streamBroker.reportStreamSignal": [{
+    name: "deviceId",
+    form: "single",
+    optional: false
+  }],
   "streamBroker.restartProfile": [{
     name: "deviceId",
     form: "single",

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runDiscover
-} from "./chunk-W67ATFOA.js";
+} from "./chunk-IGFZA22D.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-LICFWRGL.js");
+  await import("./launcher-26BZ4JHD.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-LICFWRGL.js");
+  await import("./launcher-26BZ4JHD.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-CPDHVQWB.js");
+  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-ZCOCQKSU.js");
   if (presetNamespace) {
     const spinner4 = clack.spinner();
     spinner4.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);

package/dist/{discover-CPDHVQWB.js → discover-ZCOCQKSU.js}

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