@camstack/system 1.2.263 → 1.2.265

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-6hiXbrNY.js");
+const require_dist = require("../../dist-BbPssgI6.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { Nn as EventCategory, P as addonPagesCapability, in as errMsg, on as BaseAddon } from "../../dist-CQ7ItBIG.mjs";
+import { P as addonPagesCapability, Pn as EventCategory, an as errMsg, sn as BaseAddon } from "../../dist-Ck0rjYOQ.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-6hiXbrNY.js");
+const require_dist = require("../../dist-BbPssgI6.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { I as addonWidgetsCapability, Nn as EventCategory, in as errMsg, on as BaseAddon } from "../../dist-CQ7ItBIG.mjs";
+import { I as addonWidgetsCapability, Pn as EventCategory, an as errMsg, sn as BaseAddon } from "../../dist-Ck0rjYOQ.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/alerts/alerts.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-6hiXbrNY.js");
+const require_dist = require("../../dist-BbPssgI6.js");
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,4 @@
-import { L as alertsCapability, Nn as EventCategory, in as errMsg, on as BaseAddon, r as AlertSchema, yn as createEvent } from "../../dist-CQ7ItBIG.mjs";
+import { L as alertsCapability, Pn as EventCategory, an as errMsg, bn as createEvent, n as AlertSchema, sn as BaseAddon } from "../../dist-Ck0rjYOQ.mjs";
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/autotrack/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-6hiXbrNY.js");
+const require_dist = require("../../dist-BbPssgI6.js");
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/autotrack/index.mjs

@@ -1,4 +1,4 @@
-import { B as bareAddonId, Ft as ptzAutotrackCapability, Nn as EventCategory, Tn as isEvent, g as FIRST_LEVEL_MACRO_CLASSES, in as errMsg, on as BaseAddon } from "../../dist-CQ7ItBIG.mjs";
+import { B as bareAddonId, En as isEvent, It as ptzAutotrackCapability, Pn as EventCategory, an as errMsg, h as FIRST_LEVEL_MACRO_CLASSES, sn as BaseAddon } from "../../dist-Ck0rjYOQ.mjs";
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-6hiXbrNY.js");
+const require_dist = require("../../dist-BbPssgI6.js");
 let node_crypto = require("node:crypto");
 let buffer = require("buffer");
 let node_fs_promises = require("node:fs/promises");

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { Dt as mayWriteToLocation, Nn as EventCategory, Xt as storageOccupancyCapability, on as BaseAddon, z as backupCapability } from "../../dist-CQ7ItBIG.mjs";
+import { Dt as mayWriteToLocation, Pn as EventCategory, Zt as storageOccupancyCapability, sn as BaseAddon, z as backupCapability } from "../../dist-Ck0rjYOQ.mjs";
 import { randomBytes, randomUUID } from "node:crypto";
 import { Buffer as Buffer$1 } from "buffer";
 import * as fsp from "node:fs/promises";

package/dist/builtins/camera-grid/addon.d.ts

@@ -23,6 +23,7 @@ export declare class CameraGridAddon extends BaseAddon<CameraGridAddonConfig> {
      * — that only changes when an operator changes it.
      */
     private readonly planByInstanceId;
+    private activity;
     private snapshots;
     private frameSampler;
     private ffmpegBinaryPath;
@@ -43,6 +44,25 @@ export declare class CameraGridAddon extends BaseAddon<CameraGridAddonConfig> {
     private replaceTombstones;
     private reconcile;
     private silenceAnalysis;
+    /**
+     * Listen to the SOURCES, so the grid can say the same things about itself.
+     *
+     * Filtered by source id inside the handler rather than by subscribing per
+     * camera: the bus filter is per category, the set of sources changes whenever
+     * an operator drags a cell, and a per-camera subscription would have to be
+     * torn down and rebuilt on every layout save.
+     *
+     * Every handler is TOTAL — a malformed payload is ignored, never thrown out
+     * of. These are telemetry events on a shared bus (D8/D11), and a throw here
+     * would take the grid's forwarding down for every grid because one camera
+     * emitted something unexpected.
+     */
+    private subscribeSourceActivity;
+    /**
+     * Which grids show this camera. Empty for the overwhelming majority of
+     * events, which is why it is the FIRST thing every handler asks.
+     */
+    private gridsForSource;
     /**
      * Which stream each grid reads each of its sources at, asked of the BROKER.
      *

package/dist/builtins/camera-grid/grid-activity-mirror.d.ts

@@ -0,0 +1,32 @@
+/** The grid's own motion answer, in the shape the `motion` cap publishes. */
+export interface GridMotionState {
+    readonly detected: boolean;
+    /** Ms epoch of the most recent rising edge on ANY source. Null if never. */
+    readonly lastDetectedAt: number | null;
+}
+export declare class GridActivityMirror {
+    private readonly motion;
+    private readonly audio;
+    private lastDetectedAt;
+    /** One source's motion push. `detected: false` is as important as `true`. */
+    noteMotion(sourceDeviceId: number, detected: boolean, atMs: number): void;
+    /** One source's audio window. `dbfs` is the level, on the analyzer's scale. */
+    noteAudio(sourceDeviceId: number, dbfs: number, atMs: number): void;
+    /**
+     * Drop every source this grid no longer composes.
+     *
+     * A cell removed while its camera was moving would otherwise hold the grid
+     * lit until the expiry, for a picture the source is not even in.
+     */
+    keepOnly(sourceDeviceIds: readonly number[]): void;
+    /** At least one source moving, as of `nowMs`. */
+    motionAt(nowMs: number): GridMotionState;
+    /**
+     * The loudest CURRENT reading, or `null` when nothing fresh has been heard.
+     *
+     * Null and not `-Infinity`: "nobody has reported a level" is a different
+     * answer from "it is silent", and a number here would have the viewer draw a
+     * level for a grid whose sources are not being analysed at all.
+     */
+    loudestAt(nowMs: number): number | null;
+}

package/dist/builtins/camera-grid/grid-activity.d.ts

@@ -0,0 +1,50 @@
+import { FrameResult, IEventBus, IScopedLogger } from '@camstack/types';
+import { GridMotionState } from './grid-activity-mirror.js';
+import { GridMappingCell } from './grid-detection-mapping.js';
+/** Everything this needs to know about one grid, re-read on every event. */
+export interface GridActivityTarget {
+    readonly deviceId: number;
+    readonly canvas: {
+        readonly width: number;
+        readonly height: number;
+    };
+    /** Every cell this source appears in. Empty ⇒ the grid does not show it. */
+    cellsForSource(sourceDeviceId: number): readonly GridMappingCell[];
+    /** Every source this grid composes, for the mirror's housekeeping. */
+    readonly sourceDeviceIds: readonly number[];
+}
+export interface GridActivityDeps {
+    readonly eventBus: IEventBus;
+    readonly logger: IScopedLogger;
+    readonly addonId: string;
+    /** The grids that contain this source, or empty. */
+    gridsForSource(sourceDeviceId: number): readonly GridActivityTarget[];
+    readonly now: () => number;
+}
+/**
+ * One mirror per grid, and the emission that follows an update.
+ *
+ * Deliberately NOT one mirror per source: the question is always "is THIS grid
+ * lit", and a source shared by two grids answers it twice, differently, because
+ * the other cells differ.
+ */
+export declare class GridActivityForwarder {
+    private readonly deps;
+    private readonly mirrors;
+    constructor(deps: GridActivityDeps);
+    /** A source camera's motion push. */
+    onSourceMotion(sourceDeviceId: number, detected: boolean, atMs: number): void;
+    /** A source camera's audio window. */
+    onSourceAudio(sourceDeviceId: number, dbfs: number, atMs: number): void;
+    /** A source camera's detection frame, with its boxes in SOURCE pixels. */
+    onSourceDetections(frame: FrameResult): void;
+    /** The grid's own motion answer, for `motion.getStatus`. */
+    motionStatusFor(deviceId: number, nowMs: number): GridMotionState;
+    /** Drop the mirror of a grid that no longer exists. */
+    forget(deviceId: number): void;
+    private mirrorFor;
+    private source;
+    private emitMotion;
+    private emitAudio;
+    private emitDetections;
+}

package/dist/builtins/camera-grid/grid-camera-device.d.ts

@@ -1,4 +1,4 @@
-import { BaseDevice, CamStreamDescriptor, DeviceContext, DeviceFeature, GridLayoutPatch, GridLayoutView } from '@camstack/types';
+import { BaseDevice, CamStreamDescriptor, DeviceContext, DeviceFeature, GridLayoutPatch, GridLayoutView, MotionStatus } from '@camstack/types';
 import { z } from 'zod';
 import { GridSnapshotImage } from './grid-snapshot.js';
 declare const gridCameraSchema: z.ZodObject<{
@@ -21,6 +21,16 @@ export interface GridCameraRuntime {
     saveLayout(patch: GridLayoutPatch): Promise<GridLayoutView>;
     /** A frame of the composition, or `null`. Never starts one. */
     getSnapshot(deviceId: number): Promise<GridSnapshotImage | null>;
+    /**
+     * This grid's own motion, derived from its sources (`grid-activity-mirror`).
+     *
+     * The device answers `motion.getStatus` from it because the VIEWER polls that
+     * as its backstop — it subscribes to `motion.on-motion-changed` and polls the
+     * status in case an event was missed. A grid that emitted the event but could
+     * not answer the poll would light up and then, on any dropped edge, be
+     * unrecoverably dark until the next one.
+     */
+    motionStatus(deviceId: number): MotionStatus;
 }
 export declare function installGridCameraRuntime(next: GridCameraRuntime | null): void;
 export declare class GridCameraDevice extends BaseDevice<typeof gridCameraSchema> {

package/dist/builtins/camera-grid/grid-canvas.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The composed picture as a buffer this addon owns.
+ *
+ * ## Why a canvas instead of ffmpeg's `overlay`
+ *
+ * `overlay` pairs its inputs BY PTS, and ffmpeg gives every input pts 0 at ITS
+ * OWN first frame. Two sources that joined at different moments therefore
+ * compose different moments, for the life of the child, with nothing to correct
+ * it. Measured on this hub at 4-5 s between two tiles, drifting over hours as
+ * the sources' key-frame phases slide through each other (0.5 s at 13:05, 3 s
+ * at 13:50 on the same pair, 2026-09-18).
+ *
+ * It is not reachable from a flag. `-use_wallclock_as_timestamps` re-times by
+ * ARRIVAL and wrecked the pacing instead (ten stalls over a second in an 18 s
+ * run, against none). `-copyts` changes nothing, because the broker re-bases
+ * each session — both restreams report `pts_time:0` — so there is no common
+ * timeline to trim against. Serving each dial from the newest key frame it
+ * already holds does not help either: those key frames are of different ages,
+ * and pts 0 still lands on whatever arrives first.
+ *
+ * A canvas has no pairing to get wrong. When the output tick fires, each
+ * rectangle holds whatever arrived last from its source, and the OUTPUT owns
+ * the clock. The gap is zero by construction rather than by tuning, and a cell
+ * that has produced nothing yet is simply black — so the picture appears at
+ * once instead of waiting for the slowest source's first key frame.
+ *
+ * ## Why yuv420p, and why everything here must be even
+ *
+ * yuv420p is the one pixel format every consumer of a CamStack profile reads,
+ * and a plane copy in it is a strided memcpy — no arithmetic per pixel, which
+ * is the whole reason compositing can be cheaper than the filter graph it
+ * replaces.
+ *
+ * Its chroma planes are half resolution in BOTH axes. So an odd origin or an
+ * odd size would put a tile's chroma half a sample off its luma, and the result
+ * is a tile that is subtly TINTED rather than visibly broken — the kind of
+ * fault that survives review. Every rectangle is therefore required to be even,
+ * and a blit that is not is refused rather than rounded: rounding would move a
+ * cell the operator placed.
+ */
+export interface PixelSize {
+    readonly width: number;
+    readonly height: number;
+}
+export interface PixelOrigin {
+    readonly x: number;
+    readonly y: number;
+}
+/** Bytes one yuv420p frame of this size occupies. */
+export declare function yuv420pSize(width: number, height: number): number;
+/**
+ * Round DOWN to even.
+ *
+ * Down and not nearest: a tile that rounded UP would claim a row of samples the
+ * decoder was never asked to produce, and the copy would either overrun or be
+ * refused at the moment the picture is wanted.
+ */
+export declare function evenDown(value: number): number;
+export declare class GridCanvas {
+    readonly width: number;
+    readonly height: number;
+    readonly buffer: Buffer;
+    private readonly lumaBytes;
+    private readonly chromaBytes;
+    constructor(width: number, height: number);
+    /**
+     * Legible black — Y 0, chroma 128 (neutral).
+     *
+     * `Buffer.alloc` already zeroes, and zeroed CHROMA is not black: it is a
+     * strong green. A cell nobody has filled yet has to look like an empty cell,
+     * not like a fault.
+     */
+    clear(): void;
+    /**
+     * Copy one decoded tile in at `origin`.
+     *
+     * Returns false — never throws, never writes a partial tile — when the tile
+     * does not fit, is the wrong size for the dimensions it claims, or sits on an
+     * odd boundary. This runs on the output tick, so a bad frame from one source
+     * must cost that source's rectangle and nothing else.
+     */
+    blit(tile: Buffer, size: PixelSize, origin: PixelOrigin): boolean;
+}

package/dist/builtins/camera-grid/grid-compositor-child.d.ts

@@ -0,0 +1,3 @@
+import { GridChildContext } from './grid-child.js';
+import { GridSourceHandle, GridStreamChild, GridStreamPlan } from './grid-stream-session.js';
+export declare function startGridCompositorChild(ctx: GridChildContext, plan: GridStreamPlan, sources: readonly GridSourceHandle[], onEnded: (reason: string) => void): Promise<GridStreamChild>;

package/dist/builtins/camera-grid/grid-compositor-invocation.d.ts

@@ -0,0 +1,19 @@
+import { FfmpegInvocation, FfmpegVideoEncoderId } from '@camstack/types';
+import { GridTile } from './grid-tile-plan.js';
+import { PixelSize } from './grid-canvas.js';
+export interface GridTileDecoderInput {
+    readonly tile: GridTile;
+    /** A broker restream URL, acquired through `streamBroker.getStreamWithCodec`. */
+    readonly url: string;
+    readonly fps: number;
+}
+/** One tile's decoder: dial in, raw yuv420p frames out. */
+export declare function gridTileDecoderInvocation(input: GridTileDecoderInput): FfmpegInvocation;
+export interface GridCanvasEncoderInput {
+    readonly canvas: PixelSize;
+    readonly fps: number;
+    readonly encoder: FfmpegVideoEncoderId;
+    readonly bitrateKbps: number;
+}
+/** The canvas encoder: raw frames on stdin, one compressed stream out. */
+export declare function gridCanvasEncoderInvocation(input: GridCanvasEncoderInput): FfmpegInvocation;

package/dist/builtins/camera-grid/grid-compositor.d.ts

@@ -0,0 +1,36 @@
+import { GridTilePlan } from './grid-tile-plan.js';
+export interface GridCompositorDeps {
+    readonly plan: GridTilePlan;
+    /**
+     * Hand one composed frame to the encoder. `false` means the sink is not
+     * draining — the caller slows down rather than queueing raw frames, which at
+     * 345 KB each is how a stalled encoder becomes an OOM.
+     */
+    readonly write: (frame: Buffer) => boolean;
+}
+export declare class GridCompositor {
+    private readonly deps;
+    private readonly canvas;
+    /** Keyed by tile id — unique per CELL, because one camera can hold two. */
+    private readonly placed;
+    private closed;
+    constructor(deps: GridCompositorDeps);
+    /**
+     * Raw bytes from one decoder output.
+     *
+     * A tile this composition has no rectangle for is IGNORED, never thrown on: a
+     * child that outlives a layout change would otherwise take the tick down with
+     * it, and the tick is what every other cell depends on.
+     */
+    onTile(tileId: string, chunk: Buffer): void;
+    /**
+     * Compose and emit one frame. Returns what the sink said about back-pressure.
+     *
+     * Every tile is redrawn, fresh or not: a tile that produced nothing this tick
+     * is a still picture, not a hole, and clearing it would make a late source
+     * flicker. The canvas is never cleared between ticks for the same reason.
+     */
+    tick(): boolean;
+    /** After this, a tick emits nothing — a dead child must not keep writing. */
+    close(): void;
+}

package/dist/builtins/camera-grid/grid-detection-mapping.d.ts

@@ -0,0 +1,31 @@
+import { DetectionBoundingBox } from '@camstack/types';
+import { NormalizedRect } from './grid-filter-graph.js';
+/** One place a source appears: the part taken, and where that part lands. */
+export interface GridMappingCell {
+    /** The part of the source this cell shows, normalized against the SOURCE. */
+    readonly source: NormalizedRect;
+    /** Where it lands, normalized against the CANVAS. */
+    readonly cell: NormalizedRect;
+}
+export interface GridFrameSize {
+    readonly width: number;
+    readonly height: number;
+}
+export interface MapDetectionInput {
+    /** The detection's box, in ABSOLUTE pixels of the source frame. */
+    readonly bbox: DetectionBoundingBox;
+    /** The frame those pixels are measured against (`FrameResult.width/height`). */
+    readonly sourceFrame: GridFrameSize;
+    /** The composed canvas the result is measured against. */
+    readonly canvas: GridFrameSize;
+    /** Every cell this source appears in. */
+    readonly cells: readonly GridMappingCell[];
+}
+/**
+ * Where this detection lands on the canvas — once per cell that shows it.
+ *
+ * Empty is a real answer: the subject is in a part of the source this grid does
+ * not display, or the frame arrived with no size to measure against. Neither is
+ * a reason to guess.
+ */
+export declare function mapDetectionToCanvas(input: MapDetectionInput): readonly DetectionBoundingBox[];

package/dist/builtins/camera-grid/grid-tile-feed.d.ts

@@ -0,0 +1,38 @@
+/**
+ * One source's decoded tiles, of which only the LATEST is ever wanted.
+ *
+ * ## Why dropping is the point, not a compromise
+ *
+ * ffmpeg's `overlay` consumes one frame per input per output frame, so an input
+ * that got ahead of another stays ahead for the life of the child — that is the
+ * tile gap. A canvas asks a different question: "what does this camera look
+ * like NOW". Everything behind the newest frame is not a backlog to work
+ * through, it is history, and dropping it is what keeps every tile at the same
+ * moment however unevenly their frames arrive.
+ *
+ * It is also the only bound on memory here. A decoder child that outruns the
+ * output tick — or a tick that stalls — would otherwise grow an unbounded queue
+ * of raw frames, and a raw frame is 345 KB at 640x360.
+ *
+ * ## The last frame is HELD
+ *
+ * A tick that finds nothing new redraws what was there. A tile must not blink
+ * because a source was 40 ms late, and a source that has genuinely stopped is a
+ * still picture — which is legible, and which the snapshot path already treats
+ * as the honest answer for a camera that is not sending.
+ */
+export declare class GridTileFeed {
+    private readonly frameBytes;
+    private partial;
+    private newest;
+    private fresh;
+    constructor(frameBytes: number);
+    /** Feed bytes from the decoder. Any whole frames inside replace the newest. */
+    push(chunk: Buffer): void;
+    /** The newest whole frame, or `null` while none has arrived. */
+    latest(): Buffer | null;
+    /** Has a new frame arrived since the last {@link latest}? */
+    hasFresh(): boolean;
+    /** For the bound in the spec: one frame plus at most a partial one. */
+    bufferedBytes(): number;
+}

package/dist/builtins/camera-grid/grid-tile-plan.d.ts

@@ -0,0 +1,31 @@
+import { PixelOrigin, PixelSize } from './grid-canvas.js';
+import { NormalizedRect } from './grid-filter-graph.js';
+/** The one pixel format the canvas is in, so a blit is a copy and not a convert. */
+export declare const TILE_PIXEL_FORMAT = "yuv420p";
+export interface GridTilePlanCell {
+    readonly deviceId: number;
+    /** The part of the source to take, normalized against the SOURCE. */
+    readonly source: NormalizedRect;
+    /** Where it lands, normalized against the CANVAS. */
+    readonly cell: NormalizedRect;
+}
+export interface GridTilePlanInput {
+    readonly canvas: PixelSize;
+    readonly cells: readonly GridTilePlanCell[];
+}
+export interface GridTile {
+    /** Unique within this composition — the key its frames arrive under. */
+    readonly id: string;
+    readonly deviceId: number;
+    readonly size: PixelSize;
+    readonly origin: PixelOrigin;
+    /** Bytes one frame of this tile occupies — the feed's frame length. */
+    readonly frameBytes: number;
+    /** The `-vf` chain its decoder runs: crop (when cropped), scale, format. */
+    readonly filter: string;
+}
+export interface GridTilePlan {
+    readonly canvas: PixelSize;
+    readonly tiles: readonly GridTile[];
+}
+export declare function buildGridTilePlan(input: GridTilePlanInput): GridTilePlan;