camstack 1.2.47 → 1.2.49

package/dist/{chunk-AOLS4UFV.js → chunk-U5U3EPIG.js}

@@ -15560,6 +15560,46 @@ var CameraSwitchGroupSchema = external_exports.object({
   /** Unix ms when the group was composed server-side. */
   fetchedAt: external_exports.number()
 });
+var LogChannelLevelSchema = external_exports.enum([
+  "info",
+  "warn",
+  "error"
+]);
+var LogChannelDescriptorSchema = external_exports.object({
+  /**
+  * Dotted `area.thing`, unique across the workspace. `area` is conventionally
+  * the addon's short name so an operator reading a channel list can tell who
+  * owns it without a second lookup.
+  */
+  name: external_exports.string().min(3).regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "a channel name is dotted lower-kebab, e.g. area.thing"),
+  /** One sentence: what the operator will SEE after arming it. */
+  description: external_exports.string().min(1),
+  /** The level its lines are emitted at. Never below `info`. */
+  defaultLevel: LogChannelLevelSchema,
+  /**
+  * Whether this channel can be narrowed to a camera.
+  *
+  * `true` is a PROMISE with two halves, and both must hold: the gate is
+  * consulted with the numeric device id, AND every line the channel admits
+  * carries `tags: { deviceId }` with that same numeric id. The second half is
+  * what makes `| json | deviceId="617"` work in Loki — `loki-payload.ts`
+  * keeps `deviceId` out of the stream labels for cardinality, so the tag in
+  * the body is the only way to filter.
+  *
+  * A channel whose lines carry the device only in `meta` (or not at all) is
+  * declared `false`. Declaring it `true` anyway would be a lie the UI repeats:
+  * the operator narrows to one camera, sees nothing, and concludes the code
+  * path was never taken.
+  */
+  perDevice: external_exports.boolean()
+});
+var LogChannelWindowSchema = external_exports.object({
+  channel: external_exports.string().min(1),
+  /** Epoch ms the window closes at. */
+  armedUntilMs: external_exports.number(),
+  /** `null` = every camera. A non-empty list narrows to those numeric ids. */
+  deviceIds: external_exports.array(external_exports.number().int()).readonly().nullable()
+});
 var OpsLogDomainSchema = external_exports.enum(["recording", "events"]);
 var OpsLogOpSchema = external_exports.enum([
   "prune",
@@ -19047,6 +19087,21 @@ var MutationFilterSchema = external_exports.object({
   whereBetween: external_exports.record(external_exports.string(), external_exports.tuple([external_exports.unknown(), external_exports.unknown()])).optional(),
   whereNot: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 });
+var AggregateFieldSchema = external_exports.object({
+  /** Result key. */
+  as: external_exports.string().min(1),
+  /** Column to aggregate. Must be a real column of a declared collection. */
+  field: external_exports.string().min(1),
+  op: external_exports.enum([
+    "sum",
+    "min",
+    "max"
+  ])
+});
+var AggregateResultSchema = external_exports.object({
+  count: external_exports.number().int(),
+  values: external_exports.record(external_exports.string(), external_exports.number().nullable())
+});
 var SettingsRecordSchema = external_exports.object({
   id: external_exports.string(),
   data: external_exports.record(external_exports.string(), external_exports.unknown())
@@ -19174,6 +19229,32 @@ var settingsStoreCapability = {
       collection: external_exports.string(),
       filter: QueryFilterSchema.optional()
     }), external_exports.number()),
+    /**
+    * `COUNT(*)` and one `SUM` / `MIN` / `MAX` per requested field, in ONE
+    * statement, over the rows `filter` selects.
+    *
+    * Exists because "how much is there" was being answered by materialising
+    * "what is there". The recorder's storage-pressure sweep asked its in-RAM
+    * footage index for bytes/count/oldest/newest across a set of storage
+    * locations twice a minute, and the only way to answer that from a map is
+    * to visit every row — 7.1 M of them on the live hub, ~15 M row visits a
+    * minute on the main thread, which is also why the whole archive had to
+    * stay resident to be visited. The question is a sum; nothing needs to be
+    * materialised to answer it.
+    *
+    * **The engine REFUSES a field it cannot serve**, exactly as
+    * `query.columns` does and unlike a PREDICATE, which is skipped when
+    * unresolvable. A dropped predicate over-matches and the caller sees extra
+    * rows; a dropped aggregate returns a NUMBER that is wrong and looks
+    * exactly like a real one. That asymmetry is what this repo has already
+    * paid for once in `count`.
+    */
+    aggregate: method(external_exports.object({
+      namespace: external_exports.string().optional(),
+      collection: external_exports.string(),
+      fields: external_exports.array(AggregateFieldSchema).readonly(),
+      filter: QueryFilterSchema.optional()
+    }), AggregateResultSchema),
     /** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
     histogram: method(external_exports.object({
       namespace: external_exports.string().optional(),
@@ -19332,6 +19413,15 @@ var dataStoreProviderCapability = {
       collection: external_exports.string(),
       filter: QueryFilterSchema.optional()
     }), external_exports.number(), { auth: "admin" }),
+    /** `COUNT(*)` plus one SUM/MIN/MAX per field, in one statement. Mirror of
+    *  `settings-store.aggregate` — see it for why an unresolvable field is
+    *  refused rather than dropped. */
+    aggregate: method(external_exports.object({
+      namespace: external_exports.string().optional(),
+      collection: external_exports.string(),
+      fields: external_exports.array(AggregateFieldSchema).readonly(),
+      filter: QueryFilterSchema.optional()
+    }), AggregateResultSchema, { auth: "admin" }),
     /** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
     histogram: method(external_exports.object({
       namespace: external_exports.string().optional(),
@@ -20409,6 +20499,39 @@ var deviceManagerCapability = {
     /** List children of a parent device (by parent numeric id). */
     getChildren: method(external_exports.object({ parentDeviceId: external_exports.number() }), external_exports.array(DeviceInfoSchema)),
     /**
+    * `getChildren` for a NAMED SET of parents, in one call.
+    *
+    * The accessory reconcile in `device-cap-proxy.ts` asks this question once
+    * per registered device — every `BaseDevice` inherits a
+    * `getAccessoryChildren()` that returns `[]`, so even a leaf accessory
+    * pays a round-trip to learn it has nothing to prune. Measured on the live
+    * hub 2026-08-27 over a 120-second boot window, fleet of 1 017 devices:
+    * `DeviceRowStore.list < DeviceRowStore.listByParent < getChildren` at
+    * **1 024 calls** returning **919 rows in total** — 1 024 RPCs and 1 024
+    * indexed scans to move less than one row each. `listByParentMany`
+    * collapses the scans; this collapses the RPCs.
+    *
+    * Keyed by parent id as a STRING — a JSON object cannot key by number
+    * (same reason as `getDeviceStatusAggregateBatch`). The per-parent value
+    * is exactly what `getChildren` returns for that parent.
+    *
+    * A parent with no children — or one the fleet does not know — is ABSENT
+    * from the record, never an invented empty row: the same contract as
+    * `DeviceRowStore.getMany`/`listByParentMany`. An EMPTY `parentDeviceIds`
+    * reads nothing at all rather than degrading to "every device".
+    *
+    * `parentDeviceIds` is capped at {@link DEVICE_CHILDREN_BATCH_MAX} — see
+    * that constant for why. A caller with more parents than that sends more
+    * than one call; it never sends one pathological one.
+    *
+    * Version skew: this is a NEW method, not a new field on `getChildren`, so
+    * a hub that predates it answers NOT_FOUND rather than silently stripping
+    * an unknown input key and answering a DIFFERENT question. The kernel-side
+    * loader degrades to per-parent `getChildren` on that error — see
+    * `children-batch-loader.ts`.
+    */
+    getChildrenBatch: method(external_exports.object({ parentDeviceIds: external_exports.array(external_exports.number()).max(256) }), external_exports.record(external_exports.string(), external_exports.array(DeviceInfoSchema))),
+    /**
     * Resolve the devices LINKED to a camera — the single policy authority
     * both consumers call (viewer devices panel + pipeline-analytics event
     * kinds/ingest). Device-tree children are ALWAYS included; mode 'auto'
@@ -21454,6 +21577,38 @@ var llmCapability = {
     })
   }
 };
+var LogChannelApplyResultSchema = external_exports.object({
+  /** How many declared channels are armed in this process after the call. */
+  armed: external_exports.number().int().min(0),
+  /**
+  * Names the document armed that this process does not declare. Reported
+  * rather than swallowed: a name here is either a typo or an addon that has
+  * not booted, and both deserve a line instead of silence.
+  */
+  unknown: external_exports.array(external_exports.string()).readonly()
+});
+var logChannelsCapability = {
+  name: "log-channels",
+  scope: "system",
+  mode: "collection",
+  internal: true,
+  methods: {
+    /** The channels this addon declares. Inert: no value, no state. */
+    list: method(external_exports.void(), external_exports.array(LogChannelDescriptorSchema).readonly()),
+    /**
+    * Refresh this process's mirror from the document's FULL set of armed
+    * windows.
+    *
+    * Full and not incremental on purpose: the document is the authority, so a
+    * channel it does not name is disarmed here. An incremental apply would
+    * let a disarm get lost in transit and leave a channel running that
+    * nobody can see is running.
+    */
+    apply: method(external_exports.object({ windows: external_exports.array(LogChannelWindowSchema).readonly() }), LogChannelApplyResultSchema, { kind: "mutation" })
+  },
+  /** In-process only — enumerated through `addons.listCapabilityProviders`. */
+  mount: { kind: "skip" }
+};
 var LogLevelSchema = external_exports.enum([
   "debug",
   "info",
@@ -36581,17 +36736,39 @@ var SetSiteLocationInputSchema = external_exports.object({
   latitude: external_exports.number().min(-90).max(90),
   longitude: external_exports.number().min(-180).max(180)
 }).nullable();
+var TransportPlaneSchema = external_exports.enum([
+  "http",
+  "ws",
+  "mesh",
+  "unknown"
+]);
+var TransportPlaneCountsSchema = external_exports.object({
+  http: external_exports.number(),
+  ws: external_exports.number(),
+  mesh: external_exports.number(),
+  unknown: external_exports.number()
+});
 var RequestCensusGroupSchema = external_exports.object({
+  plane: TransportPlaneSchema,
   procedure: external_exports.string(),
   userAgent: external_exports.string(),
   ip: external_exports.string(),
   principal: external_exports.string(),
   calls: external_exports.number(),
+  subscriptions: external_exports.number(),
   perMin: external_exports.number()
 });
 var RequestCensusProcedureSchema = external_exports.object({
   procedure: external_exports.string(),
   calls: external_exports.number(),
+  /**
+  * The same total, split by transport. THIS is the row that answers the
+  * question the census exists for: one look at `deviceManager.listAll` says
+  * which plane carried the 4 960, without joining two log lines by eye.
+  */
+  planes: TransportPlaneCountsSchema,
+  /** Subscription STARTS on this procedure. Never folded into `calls`. */
+  subscriptions: external_exports.number(),
   perMin: external_exports.number()
 });
 var RequestCensusSnapshotSchema = external_exports.object({
@@ -36611,14 +36788,45 @@ var RequestCensusSnapshotSchema = external_exports.object({
   */
   procedureCalls: external_exports.number(),
   /**
+  * `procedureCalls` split by transport. The four keys sum to
+  * `procedureCalls` by construction - {@link RequestCensusSnapshotSchema}'s
+  * `planesExplainTotal` is that identity, checked rather than assumed.
+  */
+  planes: TransportPlaneCountsSchema,
+  /**
+  * True iff `planes` sums to `procedureCalls`. False means a call was counted
+  * on no plane at all - which is a RESULT (a plane is missing from the
+  * instrument), not a failure, and it has to be visible to be read as one.
+  */
+  planesExplainTotal: external_exports.boolean(),
+  /**
   * tRPC WebSocket connections opened during the window. NOT calls - the WS
-  * transport resolves one context per connection - but the number that says
-  * whether a plane this census cannot see was busy while HTTP was quiet.
+  * adapter resolves one context per connection - kept because a plane's call
+  * count of zero against 37 open connections says something different from a
+  * plane with no connections at all.
   */
   wsConnections: external_exports.number(),
+  /**
+  * Client frames the WS plane looked at. `wsMessages` far above
+  * `planes.ws + subscriptions` means most traffic is not operations
+  * (keepalives, connection params) - which is itself an answer.
+  */
+  wsMessages: external_exports.number(),
+  /**
+  * Subscription STARTS across every plane, excluded from `procedureCalls` on
+  * purpose: one live-events stream opened at boot and held for six hours is
+  * one subscription, and counting it as a call would let a quiet plane
+  * masquerade as the storm.
+  */
+  subscriptions: external_exports.number(),
+  /** `subscription.stop` frames. Starts minus stops is what is still open. */
+  subscriptionStops: external_exports.number(),
   distinctGroups: external_exports.number(),
-  /** Calls counted in the totals whose group attribution was shed at the
-  *  cardinality bound. */
+  /**
+  * Operations counted in the totals whose CALLER attribution was shed at the
+  * cardinality bound. Unrelated to the `unknown` PLANE: these calls know
+  * which transport they arrived on, they just lost their group row.
+  */
   unattributedCalls: external_exports.number(),
   procedures: external_exports.array(RequestCensusProcedureSchema).readonly(),
   groups: external_exports.array(RequestCensusGroupSchema).readonly()
@@ -36646,6 +36854,14 @@ var LoggingLevelLayerSchema = external_exports.object({
   scope: LoggingScopeKindSchema,
   /** The node this layer speaks for; `null` on the cluster layer. */
   nodeId: external_exports.string().nullable(),
+  /**
+  * The declared channel this layer speaks for; `null` on every layer but
+  * `component`. Never folded into `nodeId`: a component level is CLUSTER-WIDE
+  * by design — the convention this repo settled on is one orchestrator-wide
+  * setting, never per node (D52) — so a component layer that carried a node
+  * would invite a per-node copy of a value that has no per-node meaning.
+  */
+  component: external_exports.string().nullable(),
   /** Explicitly set here, or `null` when this layer inherits. */
   level: LogLevelSchema$1.nullable()
 });
@@ -36671,6 +36887,38 @@ var DiagnosticWindowPatchSchema = external_exports.object({
   /** Cadence of the diagnostic's aggregated report line. Clamped by the server. */
   reportEveryMs: external_exports.number().int().positive().optional()
 });
+var LogChannelWindowStateSchema = external_exports.object({
+  channel: external_exports.string(),
+  armed: external_exports.boolean(),
+  /** Epoch ms the window closes at. 0 when disarmed. */
+  armedUntilMs: external_exports.number(),
+  /** Ms left before it expires on its own. 0 when disarmed. */
+  remainingMs: external_exports.number(),
+  /**
+  * The cameras it is narrowed to, or `null` for every camera.
+  *
+  * A channel declared `perDevice: false` can only ever report `null` here:
+  * its lines do not carry `tags: { deviceId }`, so narrowing them would
+  * produce a filter that silently matches nothing. The server REFUSES such a
+  * patch rather than quietly widening it — ignoring the request would teach
+  * the operator that per-camera filtering works on that channel when it does
+  * not.
+  */
+  deviceIds: external_exports.array(external_exports.number().int()).readonly().nullable()
+});
+var LogChannelWindowPatchSchema = external_exports.object({
+  channel: external_exports.string().min(1),
+  armMs: external_exports.number().int().min(0),
+  /**
+  * Narrow to these numeric device ids. Absent or `null` = every camera.
+  *
+  * Numeric because the repo's own rule makes it possible: every log line
+  * about a device carries `tags: { deviceId }` with the numeric id. That rule
+  * was paid for with a 22% thumbnail gap and a 3-hour media blackout both
+  * diagnosed by hand, and this is the first thing that collects on it.
+  */
+  deviceIds: external_exports.array(external_exports.number().int()).readonly().nullable().optional()
+});
 var LoggingSettingsPatchSchema = external_exports.object({
   /**
   * Absent leaves the level untouched. `null` CLEARS the explicit value at the
@@ -36681,19 +36929,50 @@ var LoggingSettingsPatchSchema = external_exports.object({
   * Only the diagnostics NAMED here change. An armed window that is not listed
   * keeps running — a patch is never a full replacement.
   */
-  diagnostics: external_exports.array(DiagnosticWindowPatchSchema).readonly().optional()
+  diagnostics: external_exports.array(DiagnosticWindowPatchSchema).readonly().optional(),
+  /**
+  * Only the channels NAMED here change. An armed channel that is not listed
+  * keeps running — same rule as `diagnostics`, because a patch that silently
+  * 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()
+});
+var GetLoggingSettingsInputSchema = external_exports.object({
+  scopeNodeId: external_exports.string().optional(),
+  /**
+  * The declared CHANNEL this document is addressed at, when the caller wants
+  * the `component` layer. Absent = the node/cluster hierarchy only.
+  *
+  * Naming it separately rather than overloading `scopeNodeId` keeps the two
+  * axes from collapsing: a component level is cluster-wide, a node level is
+  * not, and one selector for both would make "which of these two did I just
+  * set" unanswerable — the exact ambiguity `explicit` exists to remove.
+  */
+  scopeComponent: external_exports.string().optional()
 });
-var GetLoggingSettingsInputSchema = external_exports.object({ scopeNodeId: external_exports.string().optional() });
 var SetLoggingSettingsInputSchema = external_exports.object({
   scopeNodeId: external_exports.string().optional(),
+  scopeComponent: external_exports.string().optional(),
   patch: LoggingSettingsPatchSchema
 });
 var LoggingSettingsStateSchema = external_exports.object({
   /** The layer this document was read at. `null` = the cluster layer. */
   scopeNodeId: external_exports.string().nullable(),
+  /** The channel this document was read at. `null` = no component layer. */
+  scopeComponent: external_exports.string().nullable(),
   effective: LoggingEffectiveSchema,
   explicit: LoggingExplicitSchema,
   activeWindows: external_exports.array(DiagnosticWindowSchema).readonly(),
+  /**
+  * Every channel the cluster's addons DECLARE, gathered from the
+  * `log-channels` providers. Not stored anywhere: assembled per read, so a
+  * channel added by a redeployed addon appears without anybody editing a
+  * list, and a channel whose addon is gone stops being offered.
+  */
+  channels: external_exports.array(LogChannelDescriptorSchema).readonly(),
+  /** The channels ARMED right now, each with its deadline. */
+  activeChannels: external_exports.array(LogChannelWindowStateSchema).readonly(),
   persisted: external_exports.boolean()
 });
 var systemCapability = {
@@ -38604,6 +38883,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "view"
   },
+  "dataStoreProvider.aggregate": {
+    capName: "data-store-provider",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "dataStoreProvider.count": {
     capName: "data-store-provider",
     capScope: "system",
@@ -39018,6 +39303,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "view"
   },
+  "deviceManager.getChildrenBatch": {
+    capName: "device-manager",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "deviceManager.getConfigSchema": {
     capName: "device-manager",
     capScope: "system",
@@ -40068,6 +40359,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "logChannels.apply": {
+    capName: "log-channels",
+    capScope: "system",
+    addonId: null,
+    access: "create"
+  },
+  "logChannels.list": {
+    capName: "log-channels",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "logDestination.query": {
     capName: "log-destination",
     capScope: "system",
@@ -42222,6 +42525,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "settingsStore.aggregate": {
+    capName: "settings-store",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "settingsStore.count": {
     capName: "settings-store",
     capScope: "system",
@@ -43801,6 +44110,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
     form: "single",
     optional: false
   }],
+  "deviceManager.getChildrenBatch": [{
+    name: "parentDeviceIds",
+    form: "array",
+    optional: false
+  }],
   "deviceManager.getConfigSchema": [{
     name: "deviceId",
     form: "single",

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runDiscover
-} from "./chunk-AOLS4UFV.js";
+} from "./chunk-U5U3EPIG.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-GJBWLSRW.js");
+  await import("./launcher-Y5UOZ2NP.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-GJBWLSRW.js");
+  await import("./launcher-Y5UOZ2NP.js");
 }
 
 // src/commands/setup.ts
@@ -1130,7 +1130,7 @@ function isUnknown(_value) {
   return true;
 }
 async function resolveServerInteractive(presetNamespace) {
-  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-2BTHVGDZ.js");
+  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-WF63I2OT.js");
   if (presetNamespace) {
     const spinner4 = clack.spinner();
     spinner4.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);

package/dist/{discover-2BTHVGDZ.js → discover-WF63I2OT.js}

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