camstack 1.2.63 → 1.2.66

package/dist/{chunk-SEHB4NXH.js → chunk-EJO2K6FH.js}

@@ -14522,7 +14522,7 @@ function date4(params) {
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../types/dist/sleep-L5-bG_a_.mjs
+// ../types/dist/sleep-bm0x6zZF.mjs
 var WELL_KNOWN_TABS = [
   {
     id: "overview",
@@ -15772,6 +15772,21 @@ var RelocateJobSchema = external_exports.object({
   bytesMoved: external_exports.number().int(),
   /** Total files discovered up front; null while (or when) unknown. */
   filesTotal: external_exports.number().int().nullable(),
+  /**
+  * Rows this run CORRECTED while moving them — a durable mutation the move
+  * made that nobody asked for, so it is reported where the operator reads the
+  * job rather than only in a log line.
+  *
+  * A footage segment records its byte count in its own NAME, and the durable
+  * hour row derives its aggregates from those names. A file that does not
+  * match its name therefore makes the ledger's sums — and with them quota and
+  * pressure eviction — wrong by the difference, and only a rename can fix it.
+  * On 2026-08-30 one such row also stalled a 110 749-file drain permanently.
+  *
+  * Absent on lanes where the question has no meaning: a media blob's size is
+  * in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
+  */
+  rowsReconciled: external_exports.number().int().nonnegative().optional(),
   startedAt: external_exports.number(),
   finishedAt: external_exports.number().nullable(),
   error: external_exports.string().nullable()
@@ -15814,11 +15829,18 @@ var RelocateMediaInputSchema = external_exports.object({
   /** Omitted = `move`, the pre-existing behaviour. */
   mode: MediaRelocateModeSchema.optional()
 });
-var UnstampedEventMediaCountSchema = external_exports.object({
-  media: external_exports.number().int().nonnegative(),
-  retrainFrames: external_exports.number().int().nonnegative(),
-  total: external_exports.number().int().nonnegative()
+var UnstampedRowsSchema = external_exports.object({
+  present: external_exports.boolean(),
+  rows: external_exports.number().int().nonnegative().nullable()
 });
+var UnstampedEventMediaCountSchema = external_exports.object({
+  media: UnstampedRowsSchema,
+  retrainFrames: UnstampedRowsSchema,
+  /** True when EITHER collection holds one. The refusal reads this. */
+  anyPresent: external_exports.boolean(),
+  /** Sum across both, or `null` when either lane could not be counted. */
+  total: external_exports.number().int().nonnegative().nullable()
+}).nullable();
 var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: external_exports.string().min(1) });
 var StorageMigrationClassSchema = external_exports.enum([
   "recordings",
@@ -15860,13 +15882,33 @@ var StorageMigrationParticipantSchema = external_exports.enum([
   "recorder",
   "analytics"
 ]);
+var StorageMigrationMoveProgressSchema = external_exports.object({
+  filesMoved: external_exports.number().int().nonnegative(),
+  /** The archive census — the **M** of "N of M" (D295). `null` = unknowable. */
+  filesTotal: external_exports.number().int().nonnegative().nullable(),
+  bytesMoved: external_exports.number().int().nonnegative(),
+  /** Rows the mover corrected while moving them — see `RelocateJob`. Absent on
+  *  a lane that cannot reconcile. A migration that silently rewrote durable
+  *  rows would be the same failure as one that silently skipped them. */
+  rowsReconciled: external_exports.number().int().nonnegative().optional(),
+  /** The MOVER's start, not the migration's: a drain restarted after an addon
+  *  crash gets a new mover, and a rate computed from the migration's start
+  *  would silently average in the time nothing was running. */
+  startedAt: external_exports.number(),
+  /** When the coordinator last read these numbers. Paired with `startedAt` it
+  *  is the only honest rate: both clocks are the hub's, so a UI never has to
+  *  subtract its own. */
+  observedAt: external_exports.number()
+});
 var StorageMigrationMoveSchema = external_exports.object({
   storageClass: StorageMigrationClassSchema,
   fromLocationId: external_exports.string(),
   toLocationId: external_exports.string(),
   moverJobId: external_exports.string().nullable(),
   state: RelocateJobStateSchema.nullable(),
-  error: external_exports.string().nullable()
+  error: external_exports.string().nullable(),
+  /** Last observed mover counters; `null` until the mover has been polled once. */
+  progress: StorageMigrationMoveProgressSchema.nullable()
 });
 var StorageMigrationJobSchema = external_exports.object({
   jobId: external_exports.string(),
@@ -15912,6 +15954,52 @@ var StorageMigrationPlanSchema = external_exports.object({
   })),
   findings: external_exports.array(StorageMigrationFindingSchema)
 });
+var StorageMigrationLaneSchema = external_exports.enum(["footage", "media"]);
+var StorageMigrationMoverSchema = external_exports.object({
+  lane: StorageMigrationLaneSchema,
+  job: RelocateJobSchema,
+  /** The coordinator job that armed this mover, or `null` for a mover armed
+  *  directly against the owning addon. */
+  migrationJobId: external_exports.string().nullable(),
+  /** When the hub read these counters. Stamped here so a rate is `bytesMoved`
+  *  over (`observedAt` − `job.startedAt`) with BOTH ends on the hub's clock —
+  *  a browser subtracting its own `Date.now()` from a server `startedAt` is a
+  *  rate made of two different clocks. */
+  observedAt: external_exports.number()
+});
+var StorageMigrationResidueSchema = external_exports.object({
+  storageClass: StorageMigrationClassSchema,
+  /** The location still holding the data. `'*'` for the media lane, whose rows
+  *  move from wherever they are rather than from one named source. */
+  fromLocationId: external_exports.string(),
+  /** Where a drain would move it — the class's CURRENT default. */
+  toLocationId: external_exports.string(),
+  /** Segments (footage lane) or rows (media lane) still on the source. */
+  items: external_exports.number().int().nonnegative().nullable(),
+  /** Bytes on the source; `null` when the lane counts rows rather than bytes. */
+  bytes: external_exports.number().int().nonnegative().nullable()
+});
+var StorageMigrationDrainInputSchema = external_exports.object({
+  /** The classes to drain. Each must appear in `storageMigration.residue`, so
+  *  a class whose source is already empty is refused rather than started. */
+  classes: external_exports.array(StorageMigrationClassSchema).min(1),
+  throttleMbps: external_exports.number().min(1).max(1e3).optional()
+});
+var RelocateResidueInputSchema = external_exports.object({
+  fromLocationId: external_exports.string().min(1),
+  /** Narrow to one logical class; omit for every profile on the location. */
+  footageClass: RelocateFootageClassSchema.optional()
+});
+var RelocateResidueSchema = external_exports.object({
+  segments: external_exports.number().int().nonnegative(),
+  bytes: external_exports.number().int().nonnegative()
+}).nullable();
+var RelocatableMediaCountSchema = external_exports.object({ rows: external_exports.number().int().nonnegative() }).nullable();
+var RelocatableMediaCountInputSchema = external_exports.object({
+  toLocationId: external_exports.string().min(1),
+  /** Omitted = `move`. */
+  mode: MediaRelocateModeSchema.optional()
+});
 var StorageLocationTypeSchema = external_exports.string().regex(/^[a-z][a-zA-Z0-9-]*$/);
 var StorageLocationSchema = external_exports.object({
   id: external_exports.string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/),
@@ -15955,6 +16043,7 @@ var StorageLocationSchema = external_exports.object({
   updatedAt: external_exports.number()
 });
 var StorageLocationRefSchema = external_exports.union([StorageLocationTypeSchema, external_exports.string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/)]);
+var StorageAccessSchema = external_exports.enum(["local-path", "cap-mediated"]);
 var StorageLocationDeclarationSchema = external_exports.object({
   /**
   * Global location identifier, e.g. `recordings` or `recordingsLow`.
@@ -15974,6 +16063,19 @@ var StorageLocationDeclarationSchema = external_exports.object({
   */
   cardinality: external_exports.enum(["single", "multi"]),
   /**
+  * HOW the declaring service reaches the bytes — and therefore WHICH
+  * providers may back a location of this kind. See {@link StorageAccessSchema}
+  * and {@link STORAGE_ACCESS_FALLBACK}.
+  *
+  * Absent means `'local-path'`. That default is FAIL-CLOSED on purpose: it
+  * can only over-restrict (refuse a remote provider for a kind that might
+  * have coped) and never under-restrict. Declaring `'cap-mediated'` is the
+  * permissive direction and is therefore never inferred — a repo guard
+  * (`scripts/check-storage-access-declarations.ts`) refuses to let it be
+  * reached by omission.
+  */
+  access: StorageAccessSchema.optional(),
+  /**
   * When set, the default instance for this location inherits its resolved
   * root from the named location's default instance. Useful for derivative
   * slots (e.g. `recordingsLow` → `recordings`) so operators only need to
@@ -20728,6 +20830,15 @@ var deviceManagerCapability = {
     * calls are sync. Bindings change rarely (only on wrapper toggle or
     * device add/remove) — clients invalidate via the
     * `capability.binding-changed` event.
+    *
+    * "A single round-trip" describes the CLIENT's side and used not to
+    * describe the server's: until 2026-08-30 the resolver read the persisted
+    * wrapper activations once per device, so answering this cost one
+    * settings-door RPC per device — 1 020 on the live 1 019-device hub, and
+    * it did not return in 240 s against `SystemMirror.init`'s 15 s budget.
+    * The server side is now two reads for the whole fleet. Anything PERIODIC
+    * still belongs on `getBindings` / `getBindingsBatch` (D12); this remains
+    * a warm seed.
     */
     getAllBindings: method(external_exports.object({}), external_exports.array(DeviceBindingsForDeviceSchema)),
     /**
@@ -25724,8 +25835,10 @@ var TrackSchema = external_exports.object({
   lastSeen: external_exports.number(),
   /** Frame-rate position history (subject to maxPositionHistory cap). */
   positions: external_exports.array(TrackPositionSchema).readonly(),
-  /** Periodic snapshots at snapshotIntervalMs cadence (subject to
-  *  saveThumbnails policy). */
+  /** Periodic snapshots at snapshotIntervalMs cadence — DEBUG media, produced
+  *  only while `MediaSettings.debugMediaEnabled` is on for the camera (D299;
+  *  the retired `saveThumbnails` used to gate this and the rolling
+  *  `lastFrame` together). Empty is the healthy default, not a capture gap. */
   snapshots: external_exports.array(TrackSnapshotSchema).readonly(),
   /** Deduplicated zones the track has entered at least once. Zone IDS. */
   zonesVisited: external_exports.array(external_exports.string()).readonly(),
@@ -26706,8 +26819,34 @@ var pipelineAnalyticsCapability = {
     * happens to stamp it. This count is what the migration planner's
     * non-blocking gate reads; `relocateMedia({ mode: 'seal' })` is what drives
     * it to zero.
+    *
+    * TWO indexed statements per collection, not a walk. It used to page the
+    * whole collection at 200 rows per RPC ordered by an unindexed column, so
+    * on the live hub — 1 254 576 rows — it hit the 60 s RPC deadline every
+    * time it was called, and the migration it gates could never start. The
+    * cheap question (`present`: is there at least one) is asked first and
+    * separately from the expensive one (`rows`), because only the first has
+    * to be answerable for the gate to do its job.
+    *
+    * **`null` is "not measurable", never zero** — at either level. An
+    * unreadable collection must not read as a sealed one.
     */
     countUnstampedEventMedia: method(external_exports.object({}), UnstampedEventMediaCountSchema, { auth: "admin" }),
+    /**
+    * How many rows a pass would STILL act on against `toLocationId`.
+    *
+    * One derivation, two consumers: it is the media lane's denominator (the
+    * **M** the footage lane gets from the ledger census — D295) and it is the
+    * residue behind "drain remaining". Deriving them separately is how "N of M"
+    * ends up comparing two different populations.
+    *
+    * `null` means the count could not be taken; it is never zero-filled,
+    * because a zero here reads as "nothing left to move".
+    */
+    countRelocatableMedia: method(RelocatableMediaCountInputSchema, RelocatableMediaCountSchema, {
+      kind: "query",
+      auth: "admin"
+    }),
     /** Every relocate job this addon knows about, newest first (in RAM: the
     *  move is resumable, so a lost list costs nothing but the display). */
     listRelocateMediaJobs: method(external_exports.object({}), external_exports.array(RelocateJobSchema).readonly(), {
@@ -29393,6 +29532,35 @@ var storageMigrationCapability = {
     cancel: method(external_exports.object({ jobId: external_exports.string() }), external_exports.object({ cancelled: external_exports.boolean() }), {
       kind: "mutation",
       auth: "admin"
+    }),
+    /**
+    * Every mover running RIGHT NOW, in both lanes, with its counters.
+    *
+    * `status` covers a migration's own moves — the coordinator folds their
+    * progress onto the durable job record it is already polling. This covers
+    * the other case, and it is not hypothetical: a drain armed straight against
+    * `recording.relocateFootage` (the only path that existed before
+    * {@link drain}) has no job to fold into and would otherwise be invisible.
+    */
+    movers: method(external_exports.object({}), external_exports.array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }),
+    /**
+    * What each class's SOURCE still holds, from the archive — never from the
+    * resident index (D295). Only classes with something left (or something
+    * unknown) are listed, so an empty list means there is nothing to drain and
+    * the UI has no honest button to offer.
+    */
+    residue: method(external_exports.object({}), external_exports.array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }),
+    /**
+    * Run the drain half alone, on a class whose default has ALREADY moved.
+    *
+    * It never repoints anything, which is what lets `start` keep refusing a
+    * destination that is already the default: the two verbs cannot be confused
+    * for one another, and no operator can re-repoint a migrated class through
+    * this door.
+    */
+    drain: method(StorageMigrationDrainInputSchema, external_exports.object({ jobId: external_exports.string() }), {
+      kind: "mutation",
+      auth: "admin"
     })
   }
 };
@@ -29902,7 +30070,20 @@ var VectorQueryResultSchema = external_exports.object({
   */
   scanned: external_exports.number(),
   /** True when the backend could not consider every row that passed the filter. */
-  truncated: external_exports.boolean()
+  truncated: external_exports.boolean(),
+  /**
+  * The `topK` the backend actually ran with.
+  *
+  * Every backend has a ceiling — sqlite-vec's is 4,096 — and a caller asking
+  * past it used to learn nothing but a boolean, from a WARN in the provider's
+  * own log rather than in its answer. That is how an audit asking for 20,000
+  * consumed 4,096 and reported `examined: 4096` as if it had walked the index,
+  * for weeks. `truncated` says THAT the answer was short; this says BY HOW
+  * MUCH, in the return value, where the caller cannot fail to see it.
+  *
+  * Equals the requested `topK` whenever nothing was lowered.
+  */
+  effectiveTopK: external_exports.number().int().positive()
 });
 var VectorDeleteInputSchema = external_exports.object({
   index: external_exports.string(),
@@ -29921,6 +30102,35 @@ var VectorGetResultSchema = external_exports.object({ items: external_exports.ar
   id: external_exports.string(),
   metadata: VectorMetadataSchema
 })) });
+var VectorFetchInputSchema = external_exports.object({
+  index: external_exports.string(),
+  ids: external_exports.array(external_exports.string())
+});
+var VectorFetchResultSchema = external_exports.object({ items: external_exports.array(external_exports.object({
+  id: external_exports.string(),
+  /** base64 Float32LE — the same wire form `upsert` accepts. */
+  vector: external_exports.string(),
+  metadata: VectorMetadataSchema
+})) });
+var VectorScanInputSchema = external_exports.object({
+  index: external_exports.string(),
+  /** Opaque resume point. `0` starts at the top; pass back `nextCursor`. */
+  cursor: external_exports.number().int().nonnegative().default(0),
+  limit: external_exports.number().int().positive()
+});
+var VectorScanResultSchema = external_exports.object({
+  items: external_exports.array(external_exports.object({
+    id: external_exports.string(),
+    metadata: VectorMetadataSchema
+  })),
+  /**
+  * Where the next page starts, or `null` when the walk reached the end.
+  *
+  * `null` is the ONLY end-of-index signal. A caller must not infer the end
+  * from a short page: a backend is free to return fewer rows than asked.
+  */
+  nextCursor: external_exports.number().int().nonnegative().nullable()
+});
 var VectorStatsInputSchema = external_exports.object({ index: external_exports.string() });
 var VectorStatsResultSchema = external_exports.object({
   /** Provider id, so an operator can tell brute force from an ANN index. */
@@ -29951,6 +30161,10 @@ var vectorStoreCapability = {
     query: method(VectorQueryInputSchema, VectorQueryResultSchema, { auth: "admin" }),
     /** Metadata by id, no vectors — see {@link VectorGetResultSchema}. */
     getByIds: method(VectorGetInputSchema, VectorGetResultSchema, { auth: "admin" }),
+    /** Metadata AND vectors, by named id — see {@link VectorFetchInputSchema}. */
+    fetchByIds: method(VectorFetchInputSchema, VectorFetchResultSchema, { auth: "admin" }),
+    /** One page of the whole index, unranked — see {@link VectorScanInputSchema}. */
+    scan: method(VectorScanInputSchema, VectorScanResultSchema, { auth: "admin" }),
     deleteByIds: method(VectorDeleteInputSchema, VectorDeleteResultSchema, {
       kind: "mutation",
       auth: "admin"
@@ -36412,6 +36626,20 @@ var recordingCapability = {
       kind: "query",
       auth: "admin"
     }),
+    /**
+    * What a location STILL holds, asked of the durable hour ledger.
+    *
+    * The number behind "drain remaining": segments and bytes that would still
+    * have to move off `fromLocationId`. It is a ledger aggregate — the archive
+    * — because the resident index is not the archive (D295), and a drain sized
+    * off the index is exactly what reported `done` over 80.3 GB on 2026-08-29.
+    * `null` means the archive could not be asked (no ledger on this node, or
+    * the aggregate failed) and is never conflated with an empty source.
+    */
+    getRelocateResidue: method(RelocateResidueInputSchema, RelocateResidueSchema, {
+      kind: "query",
+      auth: "admin"
+    }),
     /** Cancel a running or queued relocate job. A queued job never runs. */
     cancelRelocateJob: method(external_exports.object({ jobId: external_exports.string() }), external_exports.object({ cancelled: external_exports.boolean() }), {
       kind: "mutation",
@@ -41650,6 +41878,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "pipelineAnalytics.countRelocatableMedia": {
+    capName: "pipeline-analytics",
+    capScope: "device",
+    addonId: null,
+    access: "view"
+  },
   "pipelineAnalytics.countUnstampedEventMedia": {
     capName: "pipeline-analytics",
     capScope: "device",
@@ -42814,6 +43048,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "view"
   },
+  "recording.getRelocateResidue": {
+    capName: "recording",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "recording.getStorageMigrationMoveStatus": {
     capName: "recording",
     capScope: "system",
@@ -43360,12 +43600,30 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "create"
   },
+  "storageMigration.drain": {
+    capName: "storage-migration",
+    capScope: "system",
+    addonId: null,
+    access: "create"
+  },
+  "storageMigration.movers": {
+    capName: "storage-migration",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "storageMigration.plan": {
     capName: "storage-migration",
     capScope: "system",
     addonId: null,
     access: "view"
   },
+  "storageMigration.residue": {
+    capName: "storage-migration",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "storageMigration.start": {
     capName: "storage-migration",
     capScope: "system",
@@ -44200,6 +44458,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "delete"
   },
+  "vectorStore.fetchByIds": {
+    capName: "vector-store",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "vectorStore.getByIds": {
     capName: "vector-store",
     capScope: "system",
@@ -44212,6 +44476,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
     addonId: null,
     access: "view"
   },
+  "vectorStore.scan": {
+    capName: "vector-store",
+    capScope: "system",
+    addonId: null,
+    access: "view"
+  },
   "vectorStore.stats": {
     capName: "vector-store",
     capScope: "system",

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runDiscover
-} from "./chunk-SEHB4NXH.js";
+} from "./chunk-EJO2K6FH.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-RA6HGFNQ.js");
+  await import("./launcher-EJVL74UN.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-RA6HGFNQ.js");
+  await import("./launcher-EJVL74UN.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-LCFHENJ3.js");
+  const { discoverNodes, resolveHubFromDiscovered, filterHubNodes, DEFAULT_HUB_HTTPS_PORT } = await import("./discover-4BY6AQ3K.js");
   if (presetNamespace) {
     const spinner4 = clack.spinner();
     spinner4.start(`Discovering hub on LAN (namespace "${presetNamespace}")`);

package/dist/{discover-LCFHENJ3.js → discover-4BY6AQ3K.js}

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