@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/camera-grid/grid-frame-sample.d.ts

@@ -1,27 +1,53 @@
-import { spawn as nodeSpawn } from 'node:child_process';
-import { GridStreamLogger } from './grid-stream-session.js';
+/**
+* ONE JPEG out of a composition that is already running.
+*
+* ## Why this is not the ffmpeg primitive
+*
+* `FfmpegProcess` + `buildFfmpegArgs` own the STREAM job: a long-lived encode
+* with a hardware cascade, a first-data deadline and a bounded restart. This is
+* the other kind — run-to-completion, no encode plan worth sharing, finishes or
+* is killed — which is the class `scripts/check-ffmpeg-primitive.ts` already
+* carves out by name for `recorder/still/still-frame-service.ts` ("single-JPEG
+* still grab") and `builtins/snapshot/snapshot.addon.ts` ("keyframe snapshot
+* grab"). It is the same job as those two, on a pipe instead of a URL.
+*
+* ## Why a pipe and not the grid's own URL
+*
+* Dialling the relay would be a CONSUMER, and a consumer of a cold grid starts
+* the composition — N broker acquisitions for a thumbnail, which is the one
+* thing the operator ruled out. Reading the bytes of a session that is ALREADY
+* running costs nothing: the child is up, the packets are being produced, and
+* this just takes a copy of them.
+*
+* Bounded on both ends. A composition whose first key frame is far away must
+* not hold an ffmpeg (or this promise) open for ever, so the grab has a
+* deadline and the child is killed at it — a snapshot that did not arrive is
+* `null`, and `null` is a real answer.
+*/
+import { spawn as nodeSpawn } from "node:child_process";
+import type { GridStreamLogger } from "./grid-stream-session.js";
 export type GridSpawn = typeof nodeSpawn;
 export interface GridFrameSamplerOptions {
-    readonly binaryPath: string;
-    readonly logger: GridStreamLogger;
-    readonly timeoutMs?: number;
-    /** Injectable for tests. */
-    readonly spawnFn?: GridSpawn;
+	readonly binaryPath: string;
+	readonly logger: GridStreamLogger;
+	readonly timeoutMs?: number;
+	/** Injectable for tests. */
+	readonly spawnFn?: GridSpawn;
 }
 /** How a caller feeds the sampler: it hands over chunks and a way to stop. */
 export interface GridFrameSource {
-    /** Start receiving MPEG-TS chunks. Returns the handle that stops them. */
-    attach(onChunk: (chunk: Buffer) => void): {
-        close(): void;
-    } | null;
+	/** Start receiving MPEG-TS chunks. Returns the handle that stops them. */
+	attach(onChunk: (chunk: Buffer) => void): {
+		close(): void;
+	} | null;
 }
 export declare class GridFrameSampler {
-    private readonly options;
-    constructor(options: GridFrameSamplerOptions);
-    /**
-     * @returns the JPEG, or `null` — a grab that produced nothing, could not be
-     * attached, or ran out of time. Every one of those is logged with the
-     * device: a branch that accepts the request and produces nothing must say so.
-     */
-    sample(deviceId: number, source: GridFrameSource): Promise<Buffer | null>;
+	private readonly options;
+	constructor(options: GridFrameSamplerOptions);
+	/**
+	* @returns the JPEG, or `null` — a grab that produced nothing, could not be
+	* attached, or ran out of time. Every one of those is logged with the
+	* device: a branch that accepts the request and produces nothing must say so.
+	*/
+	sample(deviceId: number, source: GridFrameSource): Promise<Buffer | null>;
 }

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

@@ -1,52 +1,22 @@
-import { z } from 'zod';
-/**
- * One source camera, the part of its picture taken, and where that part lands
- * on the composite's canvas. Both rectangles are NORMALIZED so a source that
- * changes resolution does not silently start cutting the wrong region.
- */
-declare const GridCellSchema: z.ZodObject<{
-    deviceId: z.ZodNumber;
-    source: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-    }, z.core.$strip>;
-    cell: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type GridCellConfig = z.infer<typeof GridCellSchema>;
-declare const GridInstanceSchema: z.ZodObject<{
-    id: z.ZodString;
-    cameraStableId: z.ZodString;
-    name: z.ZodString;
-    enabled: z.ZodBoolean;
-    fps: z.ZodNumber;
-    publishedProfiles: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        high: "high";
-        mid: "mid";
-        low: "low";
-    }>>>;
-    cells: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        deviceId: z.ZodNumber;
-        source: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-        }, z.core.$strip>;
-        cell: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type GridInstance = z.infer<typeof GridInstanceSchema>;
+type NormalizedRect = {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+};
+export type GridCellConfig = {
+	deviceId: number;
+	source: NormalizedRect;
+	cell: NormalizedRect;
+};
+export type GridInstance = {
+	id: string;
+	cameraStableId: string;
+	name: string;
+	enabled: boolean;
+	fps: number;
+	publishedProfiles: Array<"high" | "mid" | "low">;
+	cells: GridCellConfig[];
+};
 export declare function readGridInstances(raw: readonly Record<string, unknown>[], onInvalid?: (message: string) => void): readonly GridInstance[];
 export {};

package/dist/builtins/camera-grid/grid-last-frame-store.d.ts

@@ -1,58 +1,58 @@
-import { GridLastFrameStore } from './grid-snapshot.js';
-import { GridStreamLogger } from './grid-stream-session.js';
+import type { GridLastFrameStore } from "./grid-snapshot.js";
+import type { GridStreamLogger } from "./grid-stream-session.js";
 /**
- * Exactly the filesystem this store touches, so a caller can hand it a
- * different one and a spec can hand it a broken one.
- *
- * The four calls are `node:fs/promises`' own shapes, narrowed to the single
- * overload used here — that is what makes `promises` assignable to it with no
- * cast.
- */
+* Exactly the filesystem this store touches, so a caller can hand it a
+* different one and a spec can hand it a broken one.
+*
+* The four calls are `node:fs/promises`' own shapes, narrowed to the single
+* overload used here — that is what makes `promises` assignable to it with no
+* cast.
+*/
 export interface GridFrameFs {
-    mkdir(dir: string, options: {
-        readonly recursive: true;
-    }): Promise<string | undefined>;
-    writeFile(path: string, data: Buffer): Promise<void>;
-    rename(from: string, to: string): Promise<void>;
-    readFile(path: string): Promise<Buffer>;
+	mkdir(dir: string, options: {
+		readonly recursive: true;
+	}): Promise<string | undefined>;
+	writeFile(path: string, data: Buffer): Promise<void>;
+	rename(from: string, to: string): Promise<void>;
+	readFile(path: string): Promise<Buffer>;
 }
 export interface GridLastFrameFileStoreOptions {
-    /** `ctx.dataDir` — the addon's exclusive directory. */
-    readonly dataDir: string;
-    /** Where a dropped frame is named. A silent drop reads as "never happened". */
-    readonly logger: GridStreamLogger;
-    readonly minIntervalMs?: number;
-    /** Injectable for tests; `Date.now` otherwise. */
-    readonly now?: () => number;
-    /** Injectable for tests; `node:fs/promises` otherwise. */
-    readonly fs?: GridFrameFs;
-    /** The bound on how long the caller waits on the disk. */
-    readonly deadlineMs?: number;
+	/** `ctx.dataDir` — the addon's exclusive directory. */
+	readonly dataDir: string;
+	/** Where a dropped frame is named. A silent drop reads as "never happened". */
+	readonly logger: GridStreamLogger;
+	readonly minIntervalMs?: number;
+	/** Injectable for tests; `Date.now` otherwise. */
+	readonly now?: () => number;
+	/** Injectable for tests; `node:fs/promises` otherwise. */
+	readonly fs?: GridFrameFs;
+	/** The bound on how long the caller waits on the disk. */
+	readonly deadlineMs?: number;
 }
 export declare class GridLastFrameFileStore implements GridLastFrameStore {
-    private readonly dir;
-    private readonly minIntervalMs;
-    private readonly now;
-    private readonly fs;
-    private readonly deadlineMs;
-    private readonly logger;
-    /** Last write per device, so the throttle survives without touching disk. */
-    private readonly lastWriteMs;
-    constructor(options: GridLastFrameFileStoreOptions);
-    put(deviceId: number, jpeg: Buffer): Promise<void>;
-    get(deviceId: number): Promise<Buffer | null>;
-    /**
-     * Run one piece of disk work, and answer `fallback` whether it REFUSES or
-     * never answers at all.
-     *
-     * The `try/catch` this replaces covered only the first of those. Measured on
-     * the CI runner (Linux, root, in a container) 2026-09-20: `fs.mkdir` with
-     * `recursive: true` under a parent that cannot hold a directory never
-     * settles — procfs answers ENOENT and Node's recursive mkdir retries the
-     * child forever — and `put` is AWAITED on the snapshot answer path, so the
-     * grid's snapshot RPC never answered either. An exception is not the only
-     * way the disk says no.
-     */
-    private bounded;
-    private pathFor;
+	private readonly dir;
+	private readonly minIntervalMs;
+	private readonly now;
+	private readonly fs;
+	private readonly deadlineMs;
+	private readonly logger;
+	/** Last write per device, so the throttle survives without touching disk. */
+	private readonly lastWriteMs;
+	constructor(options: GridLastFrameFileStoreOptions);
+	put(deviceId: number, jpeg: Buffer): Promise<void>;
+	get(deviceId: number): Promise<Buffer | null>;
+	/**
+	* Run one piece of disk work, and answer `fallback` whether it REFUSES or
+	* never answers at all.
+	*
+	* The `try/catch` this replaces covered only the first of those. Measured on
+	* the CI runner (Linux, root, in a container) 2026-09-20: `fs.mkdir` with
+	* `recursive: true` under a parent that cannot hold a directory never
+	* settles — procfs answers ENOENT and Node's recursive mkdir retries the
+	* child forever — and `put` is AWAITED on the snapshot answer path, so the
+	* grid's snapshot RPC never answered either. An exception is not the only
+	* way the disk says no.
+	*/
+	private bounded;
+	private pathFor;
 }

package/dist/builtins/camera-grid/grid-layout-native-provider.d.ts

@@ -1,8 +1,34 @@
-import { GridLayoutPatch, GridLayoutView, ICameraGridLayoutSettingsProvider } from '@camstack/types';
+/**
+* The `camera-grid-layout` provider, contribution included.
+*
+* ## Why the section lives on the DEVICE provider and not on the addon
+*
+* `camera-grid-layout` is registered per device, through
+* `DeviceContext.registerNativeCap`. `child-cap-dispatch` resolves a call that
+* carries a `deviceId` to the device-scoped provider FIRST, and when the method
+* is absent there it throws rather than falling back to the singleton — the
+* fallback exists only for a collection cap's list method. Every contribution
+* method carries a `deviceId` by definition, so an addon-level wrapper is
+* simply never reached: it registered, it type-checked, and the live hub
+* answered HTTP 500 with
+*   `method 'getDeviceSettingsContribution' not found on provider
+*    'camera-grid-layout'`.
+*
+* That is why the whole provider is built here, in one place, and handed to
+* `registerNativeCap` as a single object. `exposesDeviceSettings` widens
+* `InferProvider` and not `InferNativeProvider`, so the type below is the wider
+* one; registering it is safe because a native registration only ever needs a
+* SUBSET of what this carries.
+*
+* The refusal (D526) rides along: a device the addon cannot name as a grid gets
+* `null`, so a camera that is not a grid gets no section at all rather than a
+* panel that renders its own emptiness.
+*/
+import { type GridLayoutPatch, type GridLayoutView, type ICameraGridLayoutSettingsProvider } from "@camstack/types";
 /** What the provider needs from the running addon — nothing more. */
 export interface GridLayoutSource {
-    /** The grid behind a device, or `null` — "answered: not a grid". */
-    getLayout(deviceId: number): GridLayoutView | null;
-    saveLayout(patch: GridLayoutPatch): Promise<GridLayoutView>;
+	/** The grid behind a device, or `null` — "answered: not a grid". */
+	getLayout(deviceId: number): GridLayoutView | null;
+	saveLayout(patch: GridLayoutPatch): Promise<GridLayoutView>;
 }
 export declare function buildGridLayoutNativeProvider(source: GridLayoutSource): ICameraGridLayoutSettingsProvider;

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

@@ -1,24 +1,34 @@
-import { FfmpegVideoEncoderId } from '@camstack/types';
-import { GridInstance } from './grid-instances.js';
-import { GridStreamPlan } from './grid-stream-session.js';
+/**
+* A persisted grid row → the composition plan the stream session runs.
+*
+* The one piece of real work here is the source→ordinal mapping. The operator
+* authors cells against CAMERAS; ffmpeg addresses them by INPUT ORDINAL, and a
+* camera used by two cells must be ONE input. Two views of one camera — a wide
+* shot and a crop of the same street — is the case a composite is asked for
+* most often, and decoding it twice doubles the expensive half of the job for
+* no extra picture.
+*/
+import type { FfmpegVideoEncoderId } from "@camstack/types";
+import type { GridInstance } from "./grid-instances.js";
+import type { GridStreamPlan } from "./grid-stream-session.js";
 export interface GridPlanEncodeContext {
-    readonly encoder: FfmpegVideoEncoderId;
-    readonly decodeHwAccel: string | null;
-    /**
-     * The canvas to compose onto. REQUIRED, and never authored: each profile
-     * derives its own from the cells and its sources' size
-     * (`grid-canvas-derivation.ts`). It used to fall back to two numbers the
-     * operator typed into the editor, and that field is gone — it silently
-     * decided both what the composite cost and how sharp it was.
-     *
-     * The geometry needs no second version of itself: every rectangle is
-     * normalized on both sides (D519), so the same fractions land correctly on a
-     * canvas of any size.
-     */
-    readonly canvas: {
-        readonly width: number;
-        readonly height: number;
-    };
+	readonly encoder: FfmpegVideoEncoderId;
+	readonly decodeHwAccel: string | null;
+	/**
+	* The canvas to compose onto. REQUIRED, and never authored: each profile
+	* derives its own from the cells and its sources' size
+	* (`grid-canvas-derivation.ts`). It used to fall back to two numbers the
+	* operator typed into the editor, and that field is gone — it silently
+	* decided both what the composite cost and how sharp it was.
+	*
+	* The geometry needs no second version of itself: every rectangle is
+	* normalized on both sides (D519), so the same fractions land correctly on a
+	* canvas of any size.
+	*/
+	readonly canvas: {
+		readonly width: number;
+		readonly height: number;
+	};
 }
 /** `null` when the grid has nothing to compose — the normal freshly-created state. */
 export declare function gridPlanFor(instance: GridInstance, encode: GridPlanEncodeContext): GridStreamPlan | null;

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

@@ -1,13 +1,53 @@
-import { CamProfile } from '@camstack/types';
-import { PixelSize } from './grid-canvas.js';
-import { NormalizedRect } from './grid-filter-graph.js';
 /**
- * One id per profile, for every grid, forever.
- *
- * D519's reason is what keeps `high`'s id bare: a newly-spelled id mints a
- * second cam-stream and orphans whatever profile assignment the operator had
- * made. `grid` was `high` on the live hub before any of this and still is.
- */
+* A grid publishes one composition PER PROFILE, each made of the matching
+* profile of every source, on the canvas that profile implies.
+*
+* ## The shape, and the two wrong ones before it
+*
+* D519 shipped a single `high` stream. Then came one composition per profile,
+* on a SCALED copy of a canvas the operator typed in — and the operator's
+* adaptive tore one down and built another at every rung, because each was a
+* whole separate composition with its own decodes and its own key-frame waits
+* (hub log, 2026-09-18: `mid` at 13:03:18, `low` at 13:03:28). D528 then
+* collapsed it to ONE output to stop the rebuilds, and that lost the adaptive
+* a rung to stand on.
+*
+* The rebuild was never the profiles' fault. It was that a rebuild used to mean
+* a blank screen for as long as the slowest source took to produce a key frame.
+* With the composition driven by an output clock (D530) a rebuild shows the
+* picture at once and fills the cells in, so three matched profiles cost what
+* they are worth and nothing more.
+*
+* ## 1:1, and the canvas follows
+*
+* A grid's `low` composes its sources' `low`; its `high` their `high`. Nothing
+* is chosen and nothing is mapped — which is what lets a viewer's adaptive do
+* its ordinary job without knowing a grid is a grid.
+*
+* The canvas is not typed in either: each profile derives its own from the
+* cells and the sources' size AT THAT PROFILE (`grid-canvas-derivation.ts`).
+* So the three outputs are each 1:1 with what they are made of, and the cost of
+* a rung is the cost of the pictures in it.
+*
+* ## What is refused
+*
+* A profile is offered only when EVERY source serves it. Not "at least one": a
+* cell whose source has no `low` cannot be filled, and a composition with a
+* hole reads to an operator as a broken camera, not as an unassigned profile
+* three cameras away. An UNKNOWN answer is a refusal, never an offer (D315).
+* The refusal names the sources, because "the grid has no low" is not a finding
+* — "615 has no low" is.
+*/
+import type { CamProfile } from "@camstack/types";
+import type { PixelSize } from "./grid-canvas.js";
+import type { NormalizedRect } from "./grid-filter-graph.js";
+/**
+* One id per profile, for every grid, forever.
+*
+* D519's reason is what keeps `high`'s id bare: a newly-spelled id mints a
+* second cam-stream and orphans whatever profile assignment the operator had
+* made. `grid` was `high` on the live hub before any of this and still is.
+*/
 export declare const GRID_CAM_STREAM_ID = "grid";
 /** Every profile a grid can compose, in descending quality. */
 export declare const GRID_PROFILES: readonly CamProfile[];
@@ -15,50 +55,50 @@ export declare const GRID_PROFILES: readonly CamProfile[];
 export declare function gridCamStreamId(profile: CamProfile): string;
 /** One stream a camera serves, with the size the canvas is derived from. */
 export interface ServedProfile {
-    readonly profile: CamProfile;
-    readonly width: number;
-    readonly height: number;
+	readonly profile: CamProfile;
+	readonly width: number;
+	readonly height: number;
 }
 /** One cell: which part of which source, and where it lands. */
 export interface GridSourceCell {
-    readonly deviceId: number;
-    readonly source: NormalizedRect;
-    readonly cell: NormalizedRect;
+	readonly deviceId: number;
+	readonly source: NormalizedRect;
+	readonly cell: NormalizedRect;
 }
 export interface GridProfilePlansInput {
-    readonly cells: readonly GridSourceCell[];
-    /**
-     * Which profiles the operator wants published. A profile that is not in here
-     * is still SIZED and reported — the editor shows what it would come out as,
-     * so turning it on is a decision made with the number in view — but it is not
-     * offered to the broker.
-     */
-    readonly publishedProfiles: readonly CamProfile[];
-    /**
-     * Which streams this source serves, or `null` when nobody could say. `null`
-     * is not an empty list: an unanswerable question is a refusal, and saying so
-     * separately keeps "we did not ask" out of the catalog.
-     */
-    readonly profilesServedBy: (deviceId: number) => readonly ServedProfile[] | null;
+	readonly cells: readonly GridSourceCell[];
+	/**
+	* Which profiles the operator wants published. A profile that is not in here
+	* is still SIZED and reported — the editor shows what it would come out as,
+	* so turning it on is a decision made with the number in view — but it is not
+	* offered to the broker.
+	*/
+	readonly publishedProfiles: readonly CamProfile[];
+	/**
+	* Which streams this source serves, or `null` when nobody could say. `null`
+	* is not an empty list: an unanswerable question is a refusal, and saying so
+	* separately keeps "we did not ask" out of the catalog.
+	*/
+	readonly profilesServedBy: (deviceId: number) => readonly ServedProfile[] | null;
 }
 export type GridProfilePlan = {
-    readonly profile: CamProfile;
-    readonly offered: true;
-    readonly canvas: PixelSize;
-    /** False ⇒ serviceable, sized, and deliberately not published. */
-    readonly published: boolean;
+	readonly profile: CamProfile;
+	readonly offered: true;
+	readonly canvas: PixelSize;
+	/** False ⇒ serviceable, sized, and deliberately not published. */
+	readonly published: boolean;
 } | {
-    readonly profile: CamProfile;
-    readonly offered: false;
-    /** The sources that cannot serve it. Empty only when there are none at all. */
-    readonly missingSources: readonly number[];
+	readonly profile: CamProfile;
+	readonly offered: false;
+	/** The sources that cannot serve it. Empty only when there are none at all. */
+	readonly missingSources: readonly number[];
 };
 /**
- * What this grid can honestly publish, per profile, with the canvas or the
- * refusal.
- *
- * Every profile gets a row whether it is offered or not: an absent row says
- * nothing, and the caller logging a refusal needs the reason more than the
- * caller publishing an offer needs the offer.
- */
+* What this grid can honestly publish, per profile, with the canvas or the
+* refusal.
+*
+* Every profile gets a row whether it is offered or not: an absent row says
+* nothing, and the caller logging a refusal needs the reason more than the
+* caller publishing an offer needs the offer.
+*/
 export declare function gridProfilePlans(input: GridProfilePlansInput): readonly GridProfilePlan[];

package/dist/builtins/camera-grid/grid-row-normalization.d.ts

@@ -1,10 +1,10 @@
 export interface NormalizedGridRows {
-    readonly rows: readonly Record<string, unknown>[];
-    /** `true` when the rows differ from what was read, i.e. they must be persisted. */
-    readonly changed: boolean;
+	readonly rows: readonly Record<string, unknown>[];
+	/** `true` when the rows differ from what was read, i.e. they must be persisted. */
+	readonly changed: boolean;
 }
 /**
- * @param mintId a UUID factory — injected so the normalization is testable
- * without reaching for `crypto`.
- */
+* @param mintId a UUID factory — injected so the normalization is testable
+* without reaching for `crypto`.
+*/
 export declare function normalizeGridRows(raw: readonly Record<string, unknown>[], mintId: () => string): NormalizedGridRows;

package/dist/builtins/camera-grid/grid-sentry-sources.d.ts

@@ -1,64 +1,64 @@
 /**
- * Which URL a grid dials for one source: the live stream, or the SENTRY one.
- *
- * ## What "sentryMuted" turned out to be
- *
- * The operator asked for a stream that *"non esiste ancora"* [does not exist yet]. It half did.
- * `SENTRY_PATH_SUFFIX` has existed since the sentry shipped. What did not exist is the
- * WRITER that turns an acquired restream url into that dial, and the broker
- * telling a consumer whether one is on offer. Both are now in
- * `addon-pipeline/src/stream-broker`: `withSentryIntent`, and `sentryUrl` on
- * the `getStreamWithCodec` result.
- *
- * ## It is NOT muted, and this comment used to say it was
- *
- * `parseRestreamPath` answered `muted: true` for `/sentry` when this was
- * written, and D525 changed it to `false` the next day: the mute belonged to
- * the PLACEHOLDER, not to the path. The track is announced and FILLED — silence
- * while the still picture is served, the camera's own RTP the instant media
- * flows — because a decision taken from a string is taken once and RTSP cannot
- * renegotiate, so `true` there meant a sentry consumer could never receive
- * audio, awake or asleep.
- *
- * A grid takes no audio from any source (`audio: 'none'`), so nothing about the
- * composite changes either way. The correction is here because the old sentence
- * described the design that was REPLACED, which is the one kind of comment that
- * reads as verification.
- *
- * ## The rule, and the fallback it refuses
- *
- * An offered sentry is TAKEN. There is no sleep check and no fallback, and that
- * is deliberate: "use the sentry if the camera is asleep, otherwise the live
- * stream" reads reasonable and is exactly the wake. Whether a battery camera is
- * asleep right now is a fact that changes between the read and the dial, and
- * the dial is what wakes it. The ONE question asked is the one the broker
- * already owns — is this camera offered a sentry at all — and the broker only
- * offers it to a battery camera that declares the signals cap.
- *
- * ## What the operator sees
- *
- * A cell whose source is asleep composes that camera's last picture, held, for
- * as long as it sleeps — visible, legible, and obviously not moving. The two
- * alternatives are the ones D519 and the sentry both exist to refuse: dropping
- * the cell (a hole an operator files as a broken grid) and dialling the camera
- * (eleven seconds of battery for five seconds of video, measured on device 640).
- */
+* Which URL a grid dials for one source: the live stream, or the SENTRY one.
+*
+* ## What "sentryMuted" turned out to be
+*
+* The operator asked for a stream that *"non esiste ancora"* [does not exist yet]. It half did.
+* `SENTRY_PATH_SUFFIX` has existed since the sentry shipped. What did not exist is the
+* WRITER that turns an acquired restream url into that dial, and the broker
+* telling a consumer whether one is on offer. Both are now in
+* `addon-pipeline/src/stream-broker`: `withSentryIntent`, and `sentryUrl` on
+* the `getStreamWithCodec` result.
+*
+* ## It is NOT muted, and this comment used to say it was
+*
+* `parseRestreamPath` answered `muted: true` for `/sentry` when this was
+* written, and D525 changed it to `false` the next day: the mute belonged to
+* the PLACEHOLDER, not to the path. The track is announced and FILLED — silence
+* while the still picture is served, the camera's own RTP the instant media
+* flows — because a decision taken from a string is taken once and RTSP cannot
+* renegotiate, so `true` there meant a sentry consumer could never receive
+* audio, awake or asleep.
+*
+* A grid takes no audio from any source (`audio: 'none'`), so nothing about the
+* composite changes either way. The correction is here because the old sentence
+* described the design that was REPLACED, which is the one kind of comment that
+* reads as verification.
+*
+* ## The rule, and the fallback it refuses
+*
+* An offered sentry is TAKEN. There is no sleep check and no fallback, and that
+* is deliberate: "use the sentry if the camera is asleep, otherwise the live
+* stream" reads reasonable and is exactly the wake. Whether a battery camera is
+* asleep right now is a fact that changes between the read and the dial, and
+* the dial is what wakes it. The ONE question asked is the one the broker
+* already owns — is this camera offered a sentry at all — and the broker only
+* offers it to a battery camera that declares the signals cap.
+*
+* ## What the operator sees
+*
+* A cell whose source is asleep composes that camera's last picture, held, for
+* as long as it sleeps — visible, legible, and obviously not moving. The two
+* alternatives are the ones D519 and the sentry both exist to refuse: dropping
+* the cell (a hole an operator files as a broken grid) and dialling the camera
+* (eleven seconds of battery for five seconds of video, measured on device 640).
+*/
 /** What `streamBroker.getStreamWithCodec` handed back for one source. */
 export interface GridSourceAcquisition {
-    readonly url: string;
-    /**
-     * The sentry counterpart, when the BROKER offers one. Absent and `null` mean
-     * the same thing — this camera has no sentry — and neither is ever resolved
-     * into the live url by guessing.
-     */
-    readonly sentryUrl?: string | null;
-    readonly pipelineKey: string;
+	readonly url: string;
+	/**
+	* The sentry counterpart, when the BROKER offers one. Absent and `null` mean
+	* the same thing — this camera has no sentry — and neither is ever resolved
+	* into the live url by guessing.
+	*/
+	readonly sentryUrl?: string | null;
+	readonly pipelineKey: string;
 }
 export interface GridSourceDial {
-    readonly url: string;
-    /** The key the acquisition was issued under — releasing anything else leaks a dial. */
-    readonly pipelineKey: string;
-    /** What this cell is actually reading. Logged, so a still cell is never a mystery. */
-    readonly mode: 'live' | 'sentry';
+	readonly url: string;
+	/** The key the acquisition was issued under — releasing anything else leaks a dial. */
+	readonly pipelineKey: string;
+	/** What this cell is actually reading. Logged, so a still cell is never a mystery. */
+	readonly mode: "live" | "sentry";
 }
 export declare function gridSourceDial(acquired: GridSourceAcquisition): GridSourceDial;