camstack 1.2.35 → 1.2.37

package/dist/{chunk-CJBTSCQF.js → chunk-OR2CMMOE.js}

@@ -15602,7 +15602,7 @@ var RecordingBandSchema = external_exports.object({
   postBufferSec: external_exports.number().min(0).optional()
 });
 var DEFAULT_EVENTS_BAND_BUFFER_SEC = {
-  preBufferSec: 10,
+  preBufferSec: 15,
   postBufferSec: 30
 };
 var VISIT_MERGE_GAP_MS = DEFAULT_EVENTS_BAND_BUFFER_SEC.postBufferSec * 1e3;
@@ -22016,128 +22016,103 @@ var COCO_TO_MACRO = {
 var AUDIO_MACRO_LABELS = [
   {
     id: "speech",
-    name: "Speech",
-    icon: "\u{1F5E3}\uFE0F"
+    name: "Speech"
   },
   {
     id: "scream",
-    name: "Scream / Shout",
-    icon: "\u{1F631}"
+    name: "Scream / Shout"
   },
   {
     id: "crying",
-    name: "Crying / Baby",
-    icon: "\u{1F622}"
+    name: "Crying / Baby"
   },
   {
     id: "laughter",
-    name: "Laughter",
-    icon: "\u{1F602}"
+    name: "Laughter"
   },
   {
     id: "music",
-    name: "Music",
-    icon: "\u{1F3B5}"
+    name: "Music"
   },
   {
     id: "dog",
-    name: "Dog",
-    icon: "\u{1F415}"
+    name: "Dog"
   },
   {
     id: "cat",
-    name: "Cat",
-    icon: "\u{1F408}"
+    name: "Cat"
   },
   {
     id: "bird",
-    name: "Bird",
-    icon: "\u{1F426}"
+    name: "Bird"
   },
   {
     id: "animal",
-    name: "Animal (other)",
-    icon: "\u{1F43E}"
+    name: "Animal (other)"
   },
   {
     id: "alarm",
-    name: "Alarm / Siren",
-    icon: "\u{1F6A8}"
+    name: "Alarm / Siren"
   },
   {
     id: "doorbell",
-    name: "Doorbell / Knock",
-    icon: "\u{1F514}"
+    name: "Doorbell / Knock"
   },
   {
     id: "glass_breaking",
-    name: "Glass Breaking",
-    icon: "\u{1F4A5}"
+    name: "Glass Breaking"
   },
   {
     id: "gunshot",
-    name: "Gunshot / Explosion",
-    icon: "\u{1F4A3}"
+    name: "Gunshot / Explosion"
   },
   {
     id: "vehicle",
-    name: "Vehicle",
-    icon: "\u{1F697}"
+    name: "Vehicle"
   },
   {
     id: "siren",
-    name: "Emergency Siren",
-    icon: "\u{1F691}"
+    name: "Emergency Siren"
   },
   {
     id: "fire",
-    name: "Fire / Smoke",
-    icon: "\u{1F525}"
+    name: "Fire / Smoke"
   },
   {
     id: "water",
-    name: "Water",
-    icon: "\u{1F4A7}"
+    name: "Water"
   },
   {
     id: "wind",
-    name: "Wind / Weather",
-    icon: "\u{1F32C}\uFE0F"
+    name: "Wind / Weather"
   },
   {
     id: "door",
-    name: "Door",
-    icon: "\u{1F6AA}"
+    name: "Door"
   },
   {
     id: "footsteps",
-    name: "Footsteps",
-    icon: "\u{1F463}"
+    name: "Footsteps"
   },
   {
     id: "crowd",
-    name: "Crowd / Chatter",
-    icon: "\u{1F465}"
+    name: "Crowd / Chatter"
   },
   {
     id: "telephone",
-    name: "Telephone",
-    icon: "\u{1F4DE}"
+    name: "Telephone"
   },
   {
     id: "engine",
-    name: "Engine / Motor",
-    icon: "\u2699\uFE0F"
+    name: "Engine / Motor"
   },
   {
     id: "tools",
-    name: "Tools / Construction",
-    icon: "\u{1F528}"
+    name: "Tools / Construction"
   },
   {
     id: "silence",
-    name: "Silence",
-    icon: "\u{1F92B}"
+    name: "Silence"
   }
 ];
 var YAMNET_TO_MACRO = {
@@ -24251,6 +24226,35 @@ var TrackSchema = external_exports.object({
   */
   hasFace: external_exports.boolean().optional(),
   /**
+  * This track has a face row IN THE GALLERY: a crop **and** an embedding — a
+  * face an operator could ASSIGN to an identity.
+  *
+  * The STRICT twin of {@link hasFace}, and the pair only earns its keep
+  * because the two disagree. `hasFace` is stamped at the TOP of the face
+  * branch, before every gate, and means no more than "a face detector produced
+  * a face detail". This one is stamped at the single moment the gallery row
+  * LANDS — after `FaceRecognizer.onTrackEnd` successfully persists it, i.e.
+  * past the embedding-magnitude verdict, the `minFacePx` detection gate, the
+  * candidate gate, the imageless-track drop (no crop was ever captured) and
+  * the crop-store drop. Everything between the detector and that insert can
+  * legitimately refuse the face, so a flag written any earlier promises the
+  * operator something to assign and delivers nothing.
+  *
+  * **Independent of recognition.** A face collected but never auto-matched is
+  * still assignable — it is in fact the face an operator most wants to reach —
+  * so this is NOT gated on `recognizedIdentityId`. Recognition lands in
+  * `subLabel`; this says only that the raw material exists.
+  *
+  * **Set once, never cleared.** A track that produced a gallery row produced
+  * one; deleting the row later is the gallery's business, not this flag's.
+  *
+  * **Absent ≠ false**, the same rule as {@link hasFace}: every row written
+  * before the column omits it, and so does every server that predates the
+  * field. A consumer must test `=== true` and render nothing otherwise —
+  * never infer "no assignable face".
+  */
+  hasEmbeddedFace: external_exports.boolean().optional(),
+  /**
   * This subject CONTAINS a folded rider — a person the rider-pairing step
   * ([D34](../decisions/adr-0034.md)) removed from the frame BEFORE the tracker,
   * so the passage is tracked once and as a VEHICLE.
@@ -26011,6 +26015,32 @@ var DetailResultSchema = external_exports.object({
   /** FRAME-space bbox (already mapped back from crop space). */
   bbox: NativeCropBboxSchema.optional(),
   embedding: external_exports.string().optional(),
+  /**
+  * L2 magnitude of the RAW pre-normalization embedding. Additive and optional
+  * so an older runner that does not send it degrades to "unmeasurable", which
+  * the consuming gate treats as accept — never as reject.
+  */
+  embeddingMagnitude: external_exports.number().optional(),
+  /**
+  * Model that produced `embedding` — the SAME contract `labelModelId` has for
+  * `label`, and for the same reason: the producing node is the only side that
+  * knows which model actually ran, and re-deriving it downstream is exactly
+  * the inference this model exists to forbid.
+  *
+  * Additive and optional, so a runner that predates it degrades to
+  * "unmeasurable" rather than to a wrong answer — the consumer falls back to
+  * its previous assumption instead of refusing.
+  *
+  * Its absence was not cosmetic. `FaceRecognizer` needs the probe's model id
+  * to use `face-matcher`'s same-model gate (`sample.modelId !== probe.modelId`);
+  * with nothing on the wire it took the id from the GALLERY, so the gate
+  * compared the gallery against itself and could never fire. That turned the
+  * one guard protecting the face feature space into a tautology, and it is
+  * why swapping `face-embedding`'s model would NOT have stranded the enrolled
+  * gallery as the catalog comment predicts — it would have scored the new
+  * model's vectors against the old model's samples in one cosine space.
+  */
+  embeddingModelId: external_exports.string().optional(),
   label: external_exports.string().optional(),
   /**
   * The tier `label` occupies, copied VERBATIM from the producing step's
@@ -26987,6 +27017,13 @@ var CameraStatusSchema = external_exports.object({
   /** Unix timestamp (ms) when this snapshot was composed server-side. */
   fetchedAt: external_exports.number()
 });
+var INFERENCE_DEVICE_EXCLUSION_REASONS = [
+  "disabled",
+  "unavailable",
+  "cannot-host-camera-root",
+  "accelerator-preferred"
+];
+var InferenceDeviceExclusionReasonSchema = external_exports.enum(INFERENCE_DEVICE_EXCLUSION_REASONS);
 var NodeInferenceDeviceSchema = external_exports.object({
   /** Stable per-node device key, e.g. `openvino:npu`, `edgetpu:usb`, `cpu`. */
   key: external_exports.string(),
@@ -27017,7 +27054,17 @@ var NodeInferenceDeviceSchema = external_exports.object({
   * available per format; this is the stored selection that becomes the
   * default for EVERY camera landing on this accelerator.
   */
-  steps: external_exports.record(external_exports.string(), DeviceStepConfigSchema).optional()
+  steps: external_exports.record(external_exports.string(), DeviceStepConfigSchema).optional(),
+  /**
+  * `null` when the device IS a camera-root candidate on this node; otherwise
+  * the reason the dispatcher drops it. Computed by the SAME
+  * `resolveInferenceDeviceEligibility` the dispatcher runs, so this view can
+  * never disagree with the election — deriving it in the UI from
+  * `enabled`/`available` would silently miss `cannot-host-camera-root` (needs
+  * the node's model catalog) and `accelerator-preferred` (needs the node-wide
+  * "an accelerator is serving" predicate).
+  */
+  exclusion: InferenceDeviceExclusionReasonSchema.nullable()
 });
 var NodeInferenceDevicesSchema = external_exports.object({
   nodeId: external_exports.string(),
@@ -27816,6 +27863,7 @@ var snapshotCapability = {
         isBattery: external_exports.boolean(),
         reason: external_exports.enum([
           "disabled",
+          "offline",
           "sleeping",
           "unreachable",
           "waking"
@@ -27906,9 +27954,17 @@ var snapshotCapability = {
       sleeping: external_exports.boolean(),
       /** Current device state rendered over the cached frame. State images
       *  remain authoritative even when their photographic background is
-      *  old; null means the link must carry a current camera frame. */
+      *  old; null means the link must carry a current camera frame.
+      *
+      *  **This is the ONLY source a surface may derive an inactive tile
+      *  from.** A client that reads a device's `online`/`disabled` flags and
+      *  draws its own verdict will disagree with the pixels it is painting
+      *  — the frame comes from here, and so must the sentence over it
+      *  (D190). Pair with `ageMs` for the age of the photograph behind the
+      *  state. */
       stateReason: external_exports.enum([
         "disabled",
+        "offline",
         "sleeping",
         "unreachable",
         "waking"
@@ -32018,7 +32074,35 @@ var ConnectionEndpointSchema = external_exports.object({
   */
   priority: external_exports.number()
 });
-var GetConnectionEndpointsResultSchema = external_exports.object({ endpoints: external_exports.array(ConnectionEndpointSchema).readonly() });
+var LocalPortSourceEnum = external_exports.enum([
+  "server-config",
+  "server-env",
+  "caller-hint",
+  "default"
+]);
+var AdvertisedLocalPortSchema = external_exports.object({
+  port: external_exports.number().int().min(1).max(65535),
+  source: LocalPortSourceEnum
+});
+var GetConnectionEndpointsResultSchema = external_exports.object({
+  endpoints: external_exports.array(ConnectionEndpointSchema).readonly(),
+  /**
+  * The port the hub built the LAN/loopback URLs with, and where that number
+  * came from.
+  *
+  * Returned rather than merely applied, because "the URL is right" and "the
+  * client can KNOW the URL is right" are different properties. A client that
+  * only sees a corrected URL cannot distinguish a hub that fixed the port from
+  * a hub that echoed the port the client sent, so it cannot decide whether to
+  * race the candidate or discard it. With `source` it can: anything but
+  * `caller-hint` is the hub's own socket.
+  *
+  * Absent on hubs predating this field — a client that finds it missing is
+  * talking to an echoing hub and must degrade exactly as it does for
+  * `caller-hint`.
+  */
+  localPort: AdvertisedLocalPortSchema
+});
 var NotificationEndpointSchema = external_exports.object({
   /** The operator's explicit choice, or null for AUTO. */
   baseUrl: external_exports.string().nullable(),
@@ -32060,10 +32144,35 @@ var localNetworkCapability = {
     * Honours `getAllowedAddresses()` when set — addresses outside
     * the allowlist are dropped (the public tunnel + loopback are
     * always included as escape hatches).
+    *
+    * **The port is the hub's, not the caller's** (D62 — a function's fact
+    * belongs to whoever already owns it). This method used to take a `port`
+    * and echo it onto every LAN and loopback URL it advertised, which made
+    * every client a second authority on a socket only the hub binds. A viewer
+    * configured with a port-less public URL (`https://camstack.example.top`)
+    * infers 443 from the scheme, asks with 443, and was handed
+    * `https://192.168.1.9:443` for a hub listening on 4443. That candidate
+    * cannot ever answer, and losing its race reads in the log exactly like
+    * "the LAN was tried and it was slower" — so an operator sitting on his own
+    * WiFi stayed on the public tunnel for weeks, with the LAN candidate born
+    * dead on every single connect.
+    *
+    * The hub now resolves its own listen port and reports it as `localPort`,
+    * with the SOURCE of the number, so a client can tell a fact from an echo.
+    *
+    * Out of scope on purpose: a LAN URL that is not the hub's own socket (a
+    * reverse proxy in front of it on another port) is not this method's to
+    * invent either — pin it with `setNotificationEndpoint` / a configured
+    * origin, which is an operator statement rather than a guess.
     */
     getConnectionEndpoints: method(external_exports.object({
-      /** Local hub HTTP port to use in base URLs. */
-      port: external_exports.number().int().min(1).max(65535),
+      /**
+      * LEGACY HINT — do not send from new code. Kept optional so clients
+      * written against the echoing contract keep working; the hub uses it
+      * only when it cannot read its own port, and says so via
+      * `localPort.source === 'caller-hint'`.
+      */
+      port: external_exports.number().int().min(1).max(65535).optional(),
       /** Include `http(s)://127.0.0.1:<port>` as the lowest-priority
       *  candidate. Default `true`. */
       includeLoopback: external_exports.boolean().optional(),
@@ -36554,6 +36663,7 @@ var BATTERY_DEVICE_PROFILE = {
   settings: {}
 };
 var BATTERY_UNREACHABLE_AFTER_MS = 360 * 6e4;
+var OPERATOR_WRITTEN_STALE_MS = 10 * 6e4;
 var METHOD_ACCESS_MAP = Object.freeze({
   "accessories.setChildHidden": {
     capName: "accessories",
@@ -43935,7 +44045,6 @@ var NC_AUDIO_DEFAULTS = {
   hitPercent: 60,
   samplingSeconds: 10
 };
-var ICON_BY_ID = new Map(AUDIO_MACRO_LABELS.flatMap((macro2) => macro2.icon === void 0 ? [] : [[macro2.id, macro2.icon]]));
 var NC_BASE_CONDITION_KEYS = ["devices", "classes"];
 var BASE_CONDITION_SET = new Set(NC_BASE_CONDITION_KEYS);
 var NC_AUDIO_SEED = {
@@ -44053,6 +44162,40 @@ var TimelapseRuleSchema = TimelapseRuleInputSchema.extend({
   createdAt: external_exports.number(),
   updatedAt: external_exports.number()
 });
+var CLUSTER_MODEL_SCOPED_STEPS = [{
+  stepId: "face-embedding",
+  label: "Face recognition model",
+  defaultModelId: "arcface-r100",
+  indexName: "the enrolled face gallery",
+  options: [
+    {
+      id: "arcface-r100",
+      label: "ArcFace (ResNet34)"
+    },
+    {
+      id: "auraface-r100",
+      label: "AuraFace R100"
+    },
+    {
+      id: "inception-resnet-v1",
+      label: "Inception ResNet V1"
+    }
+  ]
+}, {
+  stepId: "clip-embedding",
+  label: "Semantic search model",
+  defaultModelId: "mobileclip-s1",
+  indexName: "the object semantic-search index",
+  options: [{
+    id: "mobileclip-s1",
+    label: "MobileCLIP S1"
+  }, {
+    id: "mobileclip-s2",
+    label: "MobileCLIP S2"
+  }]
+}];
+var DEFAULT_CLUSTER_STEP_MODELS = Object.freeze(Object.fromEntries(CLUSTER_MODEL_SCOPED_STEPS.map((s) => [s.stepId, s.defaultModelId])));
+var ChosenModelIdSchema = external_exports.string().min(1);
 var DetailCropConventionSchema = external_exports.object({
   /**
   * Fraction of the box's own size added on EACH side before cutting.
@@ -44077,6 +44220,12 @@ var DEFAULT_DETAIL_CROP_CONVENTION = {
   paddingRatio: 0.15,
   square: false
 };
+var FULL_IMAGE_BBOX = Object.freeze({
+  x: 0,
+  y: 0,
+  w: 1,
+  h: 1
+});
 var DETAIL_CROP_PADDING_FIELD = {
   min: 0,
   max: 1,

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runDiscover
-} from "./chunk-CJBTSCQF.js";
+} from "./chunk-OR2CMMOE.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-IU5FZCJX.js");
+  await import("./launcher-6VDFMPM6.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-IU5FZCJX.js");
+  await import("./launcher-6VDFMPM6.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-HYDSUPIC.js");
+  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-Y3C7HOBU.js");
   if (presetNamespace) {
     const spinner4 = clack.spinner();
     spinner4.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);

package/dist/{discover-HYDSUPIC.js → discover-Y3C7HOBU.js}

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