@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/backup-orchestrator/run-queue.d.ts

@@ -1,103 +1,103 @@
-export type BackupRunState = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
-export type BackupRunPhase = 'queued' | 'building' | 'uploading' | 'done';
+export type BackupRunState = "queued" | "running" | "succeeded" | "failed" | "cancelled";
+export type BackupRunPhase = "queued" | "building" | "uploading" | "done";
 /** What a trigger asks for — the queue keys joining on this. */
 export interface BackupRunRequest {
-    readonly destinations?: readonly string[];
-    readonly locations?: readonly string[];
-    readonly label?: string;
-    readonly retentionCount?: number;
+	readonly destinations?: readonly string[];
+	readonly locations?: readonly string[];
+	readonly label?: string;
+	readonly retentionCount?: number;
 }
 /** Immutable snapshot of one run — the wire shape of `backup.listRuns`. */
 export interface BackupRunSnapshot {
-    readonly id: string;
-    readonly state: BackupRunState;
-    readonly phase: BackupRunPhase;
-    readonly destinationIds: readonly string[];
-    readonly label?: string;
-    readonly requestedAt: number;
-    readonly startedAt?: number;
-    readonly finishedAt?: number;
-    readonly stagedBytes: number;
-    readonly archiveSizeBytes?: number;
-    readonly uploadedBytes: number;
-    readonly completedDestinationIds: readonly string[];
-    readonly failedDestinationIds: readonly string[];
-    readonly error?: string;
-    /**
-     * 1-based place in the execution queue — 1 = runs next. Present only
-     * while `state === 'queued'`, and derived from the queue's OWN
-     * pending order at read time (never from timestamps), so a consumer
-     * can only ever show the order the executor will actually honour.
-     */
-    readonly queuePosition?: number;
+	readonly id: string;
+	readonly state: BackupRunState;
+	readonly phase: BackupRunPhase;
+	readonly destinationIds: readonly string[];
+	readonly label?: string;
+	readonly requestedAt: number;
+	readonly startedAt?: number;
+	readonly finishedAt?: number;
+	readonly stagedBytes: number;
+	readonly archiveSizeBytes?: number;
+	readonly uploadedBytes: number;
+	readonly completedDestinationIds: readonly string[];
+	readonly failedDestinationIds: readonly string[];
+	readonly error?: string;
+	/**
+	* 1-based place in the execution queue — 1 = runs next. Present only
+	* while `state === 'queued'`, and derived from the queue's OWN
+	* pending order at read time (never from timestamps), so a consumer
+	* can only ever show the order the executor will actually honour.
+	*/
+	readonly queuePosition?: number;
 }
 /**
- * Progress sink handed to the executor. Every update replaces the
- * stored snapshot (no shared mutable state leaks out of the queue).
- */
+* Progress sink handed to the executor. Every update replaces the
+* stored snapshot (no shared mutable state leaks out of the queue).
+*/
 export interface BackupRunProgress {
-    setPhase(phase: BackupRunPhase): void;
-    /** Resolved destination targets — known only once the run starts. */
-    setDestinations(ids: readonly string[]): void;
-    setStagedBytes(bytes: number): void;
-    setArchiveSize(bytes: number): void;
-    setUploadedBytes(bytes: number): void;
-    destinationCompleted(id: string): void;
-    destinationFailed(id: string): void;
+	setPhase(phase: BackupRunPhase): void;
+	/** Resolved destination targets — known only once the run starts. */
+	setDestinations(ids: readonly string[]): void;
+	setStagedBytes(bytes: number): void;
+	setArchiveSize(bytes: number): void;
+	setUploadedBytes(bytes: number): void;
+	destinationCompleted(id: string): void;
+	destinationFailed(id: string): void;
 }
 export interface SubmitResult<T> {
-    readonly runId: string;
-    /** True when the run had to wait behind an in-flight run. */
-    readonly queued: boolean;
-    /** True when this submit was coalesced onto an identical queued run. */
-    readonly joined: boolean;
-    /** Settles when the run terminates. Rejects `BackupCancelledError` on cancel-before-any-result. */
-    readonly result: Promise<T>;
+	readonly runId: string;
+	/** True when the run had to wait behind an in-flight run. */
+	readonly queued: boolean;
+	/** True when this submit was coalesced onto an identical queued run. */
+	readonly joined: boolean;
+	/** Settles when the run terminates. Rejects `BackupCancelledError` on cancel-before-any-result. */
+	readonly result: Promise<T>;
 }
 export type BackupRunExecutor<T> = (request: BackupRunRequest, signal: AbortSignal, progress: BackupRunProgress) => Promise<T>;
 export interface BackupRunQueueOptions {
-    readonly maxFinished?: number;
-    readonly now?: () => number;
+	readonly maxFinished?: number;
+	readonly now?: () => number;
 }
 /**
- * FIFO queue with concurrency 1. `submit` never starts a second
- * executor while one is in flight; an identical request already
- * WAITING (same destinations/locations/label/retention) is joined
- * instead of queued twice — two schedule ticks due on the same minute
- * produce one run, not two.
- */
+* FIFO queue with concurrency 1. `submit` never starts a second
+* executor while one is in flight; an identical request already
+* WAITING (same destinations/locations/label/retention) is joined
+* instead of queued twice — two schedule ticks due on the same minute
+* produce one run, not two.
+*/
 export declare class BackupRunQueue<T> {
-    private readonly executor;
-    private readonly runs;
-    private readonly pending;
-    private readonly finished;
-    private activeId;
-    private readonly maxFinished;
-    private readonly now;
-    constructor(executor: BackupRunExecutor<T>, opts?: BackupRunQueueOptions);
-    submit(request: BackupRunRequest): SubmitResult<T>;
-    /**
-     * Cancel a run. Queued: removed before it ever starts (its result
-     * rejects `BackupCancelledError`). Running: the abort signal fires —
-     * the executor's tar/upload streams stop and its cleanup runs.
-     * Unknown or already terminal: `false`.
-     */
-    cancel(runId: string): boolean;
-    /**
-     * EXECUTION order, not timestamp order: the running run first, then
-     * every queued run in the exact order the pump will start them (each
-     * stamped with `queuePosition`, 1 = next), then the bounded finished
-     * history newest-first. The queued section is read straight off
-     * `this.pending` — a consumer sorting by `requestedAt` descending
-     * would put the run that starts NEXT at the BOTTOM, which is
-     * backwards exactly when the queue matters (more than one waiter).
-     */
-    listRuns(): readonly BackupRunSnapshot[];
-    getRun(runId: string): BackupRunSnapshot | undefined;
-    private createRecord;
-    private pump;
-    private execute;
-    private progressFor;
-    private patch;
-    private finish;
+	private readonly executor;
+	private readonly runs;
+	private readonly pending;
+	private readonly finished;
+	private activeId;
+	private readonly maxFinished;
+	private readonly now;
+	constructor(executor: BackupRunExecutor<T>, opts?: BackupRunQueueOptions);
+	submit(request: BackupRunRequest): SubmitResult<T>;
+	/**
+	* Cancel a run. Queued: removed before it ever starts (its result
+	* rejects `BackupCancelledError`). Running: the abort signal fires —
+	* the executor's tar/upload streams stop and its cleanup runs.
+	* Unknown or already terminal: `false`.
+	*/
+	cancel(runId: string): boolean;
+	/**
+	* EXECUTION order, not timestamp order: the running run first, then
+	* every queued run in the exact order the pump will start them (each
+	* stamped with `queuePosition`, 1 = next), then the bounded finished
+	* history newest-first. The queued section is read straight off
+	* `this.pending` — a consumer sorting by `requestedAt` descending
+	* would put the run that starts NEXT at the BOTTOM, which is
+	* backwards exactly when the queue matters (more than one waiter).
+	*/
+	listRuns(): readonly BackupRunSnapshot[];
+	getRun(runId: string): BackupRunSnapshot | undefined;
+	private createRecord;
+	private pump;
+	private execute;
+	private progressFor;
+	private patch;
+	private finish;
 }

package/dist/builtins/backup-orchestrator/schedule-store.d.ts

@@ -1,43 +1,59 @@
-import { CollectionColumn, ISettingsStoreProvider } from '@camstack/types';
 /**
- * A backup schedule row.
- *
- * `locationIds` is the fan-out set (destination `backups` locations).
- * `retentionCount` applies to every one of them for THIS schedule's
- * runs. `dataSources` optionally narrows which top-level state
- * locations get archived; empty = the orchestrator's full default set.
- */
+* Backup-schedule storage for the backup orchestrator.
+*
+* A schedule is the N:M "entry" that binds one cron cadence to a SET of
+* `backups`-typed destination locations. It supersedes the per-location
+* cron previously carried on `BackupDestinationPolicy`: the operator
+* creates one schedule, picks the locations it should write to, and the
+* orchestrator fans a single archive out to all of them when the cron
+* fires. Retention is per-schedule (D-decision 2026-07-28).
+*
+* Contract mirror of `BackupDestinationPolicyService`:
+*   - Lazy `declareCollection` so the constructor stays sync.
+*   - `locationIds` / `dataSources` are arrays, persisted in `JSON` columns —
+*     the surface serialises and parses them, so this file passes and
+*     receives real arrays.
+*/
+import type { CollectionColumn, ISettingsStoreProvider } from "@camstack/types";
+/**
+* A backup schedule row.
+*
+* `locationIds` is the fan-out set (destination `backups` locations).
+* `retentionCount` applies to every one of them for THIS schedule's
+* runs. `dataSources` optionally narrows which top-level state
+* locations get archived; empty = the orchestrator's full default set.
+*/
 export interface BackupSchedule {
-    readonly id: string;
-    readonly label: string;
-    readonly cron: string;
-    readonly enabled: boolean;
-    readonly locationIds: readonly string[];
-    readonly retentionCount: number;
-    readonly dataSources?: readonly string[];
-    /**
-     * ms-epoch of the last tick that FIRED this schedule. Stamped BEFORE the
-     * archive runs — it is the dedupe anchor and the cron's "after" cursor —
-     * so it means "attempted", never "succeeded". It was documented as the
-     * latter and rendered as "last run", which is how a schedule whose only
-     * destination refused every byte read as a healthy nightly backup (D384).
-     */
-    readonly lastAttemptAt?: number;
-    /** ms-epoch of the last fired run that landed at ≥1 destination. */
-    readonly lastSuccessAt?: number;
-    /** Why the last fired run failed, verbatim. Cleared by the next success. */
-    readonly lastError?: string;
+	readonly id: string;
+	readonly label: string;
+	readonly cron: string;
+	readonly enabled: boolean;
+	readonly locationIds: readonly string[];
+	readonly retentionCount: number;
+	readonly dataSources?: readonly string[];
+	/**
+	* ms-epoch of the last tick that FIRED this schedule. Stamped BEFORE the
+	* archive runs — it is the dedupe anchor and the cron's "after" cursor —
+	* so it means "attempted", never "succeeded". It was documented as the
+	* latter and rendered as "last run", which is how a schedule whose only
+	* destination refused every byte read as a healthy nightly backup (D384).
+	*/
+	readonly lastAttemptAt?: number;
+	/** ms-epoch of the last fired run that landed at ≥1 destination. */
+	readonly lastSuccessAt?: number;
+	/** Why the last fired run failed, verbatim. Cleared by the next success. */
+	readonly lastError?: string;
 }
 export declare const BACKUP_SCHEDULES_COLUMNS: readonly CollectionColumn[];
 export declare class BackupScheduleService {
-    private readonly store;
-    private declared;
-    constructor(store: ISettingsStoreProvider);
-    initialize(): Promise<void>;
-    private ensureDeclared;
-    list(): Promise<readonly BackupSchedule[]>;
-    get(id: string): Promise<BackupSchedule | null>;
-    /** Replace-or-insert (delete + insert — mirrors the policy store). */
-    upsert(s: BackupSchedule): Promise<void>;
-    delete(id: string): Promise<void>;
+	private readonly store;
+	private declared;
+	constructor(store: ISettingsStoreProvider);
+	initialize(): Promise<void>;
+	private ensureDeclared;
+	list(): Promise<readonly BackupSchedule[]>;
+	get(id: string): Promise<BackupSchedule | null>;
+	/** Replace-or-insert (delete + insert — mirrors the policy store). */
+	upsert(s: BackupSchedule): Promise<void>;
+	delete(id: string): Promise<void>;
 }

package/dist/builtins/backup-orchestrator/staging-paths.d.ts

@@ -1,36 +1,36 @@
-import { IScopedLogger } from '@camstack/types';
+import type { IScopedLogger } from "@camstack/types";
 /** Basename of the staging dir under the node data root. */
 export declare const STAGING_DIR_NAME = "backup-staging";
 /** Canonical staging dir for a node data root. */
 export declare function resolveStagingDir(nodeDataDir: string): string;
 export interface StagingSweepResult {
-    /** Top-level staging entries removed. */
-    readonly removedCount: number;
-    /** File bytes reclaimed (recursive for removed subdirectories). */
-    readonly freedBytes: number;
-    /** Entries spared because `keepPaths` named them. */
-    readonly keptCount: number;
+	/** Top-level staging entries removed. */
+	readonly removedCount: number;
+	/** File bytes reclaimed (recursive for removed subdirectories). */
+	readonly freedBytes: number;
+	/** Entries spared because `keepPaths` named them. */
+	readonly keptCount: number;
 }
 export interface DirectoryFootprint {
-    readonly present: boolean;
-    readonly totalBytes: number;
-    readonly fileCount: number;
+	readonly present: boolean;
+	readonly totalBytes: number;
+	readonly fileCount: number;
 }
 /**
- * Delete every top-level entry of `stagingDir` except those whose
- * resolved path appears in `keepPaths`. Per-entry failures are logged
- * and skipped — a locked file must not abort the sweep. A missing
- * staging dir is a clean no-op.
- */
+* Delete every top-level entry of `stagingDir` except those whose
+* resolved path appears in `keepPaths`. Per-entry failures are logged
+* and skipped — a locked file must not abort the sweep. A missing
+* staging dir is a clean no-op.
+*/
 export declare function sweepStagingDir(input: {
-    stagingDir: string;
-    keepPaths: readonly string[];
-    logger: IScopedLogger;
+	stagingDir: string;
+	keepPaths: readonly string[];
+	logger: IScopedLogger;
 }): Promise<StagingSweepResult>;
 /**
- * Recursive size + file count of a path (file or directory). Absent
- * path → `present: false` with zeros. Used by the sweep to report
- * reclaimed bytes and by the orchestrator to surface the legacy
- * staging dir's footprint without touching it.
- */
+* Recursive size + file count of a path (file or directory). Absent
+* path → `present: false` with zeros. Used by the sweep to report
+* reclaimed bytes and by the orchestrator to surface the legacy
+* staging dir's footprint without touching it.
+*/
 export declare function measureDirectoryFootprint(dir: string): Promise<DirectoryFootprint>;

package/dist/builtins/backup-orchestrator/write-targets.d.ts

@@ -1,63 +1,63 @@
 /**
- * Which `backups` locations tonight's archive may land on.
- *
- * ## Why this is its own module
- *
- * The orchestrator had **two** enabled switches for one function: the
- * operator-visible `StorageLocation.enabled` on the storage screen, and
- * `backup_destination_policies.enabled`, seeded `true` for every newly-seen
- * location. Only the second one was consulted, so a location the storage
- * screen showed as disabled still received the archive — the exact shape D62
- * exists to forbid ("a second switch that disagrees with the first is worse
- * than no switch").
- *
- * The location flag is now the OUTER gate for every path, and the policy flag
- * keeps its narrower meaning: *this destination takes part in the unattended
- * fan-out*. An explicit request (an operator pressing Back up now with a
- * destination selected, or a schedule naming `locationIds`) still overrides
- * the policy flag — it never overrides the location flag, because that one is
- * the operator saying "do not write here" about the disk itself.
- *
- * Kept pure and separate so the decision can be read in one screen and the
- * addon is left with fetch → decide → log → upload.
- */
+* Which `backups` locations tonight's archive may land on.
+*
+* ## Why this is its own module
+*
+* The orchestrator had **two** enabled switches for one function: the
+* operator-visible `StorageLocation.enabled` on the storage screen, and
+* `backup_destination_policies.enabled`, seeded `true` for every newly-seen
+* location. Only the second one was consulted, so a location the storage
+* screen showed as disabled still received the archive — the exact shape D62
+* exists to forbid ("a second switch that disagrees with the first is worse
+* than no switch").
+*
+* The location flag is now the OUTER gate for every path, and the policy flag
+* keeps its narrower meaning: *this destination takes part in the unattended
+* fan-out*. An explicit request (an operator pressing Back up now with a
+* destination selected, or a schedule naming `locationIds`) still overrides
+* the policy flag — it never overrides the location flag, because that one is
+* the operator saying "do not write here" about the disk itself.
+*
+* Kept pure and separate so the decision can be read in one screen and the
+* addon is left with fetch → decide → log → upload.
+*/
 /** One `backups` location, reduced to the two flags that decide a write. */
 export interface BackupTargetCandidate {
-    readonly id: string;
-    /**
-     * `StorageLocation.enabled`. ABSENT MEANS ACTIVE — the caller maps
-     * `enabled !== false`, so a legacy location persisted before the flag
-     * existed stays a destination.
-     */
-    readonly locationEnabled: boolean;
-    /** `backup_destination_policies.enabled` — the unattended-fan-out opt-in. */
-    readonly policyEnabled: boolean;
+	readonly id: string;
+	/**
+	* `StorageLocation.enabled`. ABSENT MEANS ACTIVE — the caller maps
+	* `enabled !== false`, so a legacy location persisted before the flag
+	* existed stays a destination.
+	*/
+	readonly locationEnabled: boolean;
+	/** `backup_destination_policies.enabled` — the unattended-fan-out opt-in. */
+	readonly policyEnabled: boolean;
 }
 export interface BackupTargetSelection {
-    /** Destinations the archive may be written to. */
-    readonly targets: readonly BackupTargetCandidate[];
-    /**
-     * Ids dropped because the OPERATOR disabled the storage location. Returned
-     * rather than silently filtered: a fan-out that drops a destination must say
-     * so, and the caller decides between "log and continue" and "refuse".
-     */
-    readonly skippedDisabled: readonly string[];
+	/** Destinations the archive may be written to. */
+	readonly targets: readonly BackupTargetCandidate[];
+	/**
+	* Ids dropped because the OPERATOR disabled the storage location. Returned
+	* rather than silently filtered: a fan-out that drops a destination must say
+	* so, and the caller decides between "log and continue" and "refuse".
+	*/
+	readonly skippedDisabled: readonly string[];
 }
 export interface BackupTargetSelectionInput {
-    readonly candidates: readonly BackupTargetCandidate[];
-    /** Explicitly named destinations (cap input, or a schedule's `locationIds`). */
-    readonly requested?: readonly string[];
+	readonly candidates: readonly BackupTargetCandidate[];
+	/** Explicitly named destinations (cap input, or a schedule's `locationIds`). */
+	readonly requested?: readonly string[];
 }
 /**
- * Pick the destinations an archive may be fanned out to.
- *
- * An explicit `requested` list selects from the candidates by id and bypasses
- * the policy flag (that is today's behaviour and it is right: naming a
- * destination IS the opt-in). A requested id that is not a `backups` location
- * at all is simply absent from the candidates and drops out here, exactly as
- * before.
- *
- * The location flag is applied LAST and to both paths, so there is one place
- * where "disabled" is honoured rather than one per caller.
- */
+* Pick the destinations an archive may be fanned out to.
+*
+* An explicit `requested` list selects from the candidates by id and bypasses
+* the policy flag (that is today's behaviour and it is right: naming a
+* destination IS the opt-in). A requested id that is not a `backups` location
+* at all is simply absent from the candidates and drops out here, exactly as
+* before.
+*
+* The location flag is applied LAST and to both paths, so there is one place
+* where "disabled" is honoured rather than one per caller.
+*/
 export declare function selectBackupTargets(input: BackupTargetSelectionInput): BackupTargetSelection;

package/dist/builtins/calendars/calendar-color.d.ts

@@ -1,4 +1,8 @@
-import { CalendarColor } from '@camstack/types';
+/**
+* Deterministic system colours for calendar ids — same id → same hue for
+* every operator until they override via per-user preferences.
+*/
+import type { CalendarColor } from "@camstack/types";
 /** Fixed palette — high-contrast hues that read on light and dark chrome. */
 export declare const CALENDAR_COLOR_PALETTE: readonly CalendarColor[];
 /** Stable FNV-1a-ish hash → palette index. */

package/dist/builtins/calendars/calendar-prefs-store.d.ts

@@ -1,20 +1,26 @@
-import { CalendarPreferences, SettingsStoreClient } from '@camstack/types';
 /**
- * @durable class=config owner=calendars
- *   write="`setCalendarPreference` upserts the caller's row"
- *   retention="none — a missing row reads as empty prefs (all visible,
- *     system colours). Losing the table silently resets every operator's
- *     colour/hide choices."
- */
+* Per-user calendar UI preferences (colour override + visibility).
+*
+* One row per `userId`. The calendars builtin owns declare + read/write;
+* the browser never talks to `settingsStore` directly.
+*/
+import { type CalendarPreferences, type SettingsStoreClient } from "@camstack/types";
+/**
+* @durable class=config owner=calendars
+*   write="`setCalendarPreference` upserts the caller's row"
+*   retention="none — a missing row reads as empty prefs (all visible,
+*     system colours). Losing the table silently resets every operator's
+*     colour/hide choices."
+*/
 export declare const CALENDARS_USER_PREFS_COLLECTION = "calendars:user-prefs";
 export declare function declareCalendarPrefsSchema(store: SettingsStoreClient): Promise<void>;
 export declare function loadCalendarPreferences(store: SettingsStoreClient, userId: string): Promise<CalendarPreferences>;
 export declare function saveCalendarPreferences(store: SettingsStoreClient, userId: string, prefs: CalendarPreferences, nowMs: number): Promise<void>;
 /**
- * Patch one calendar's preference entry. `color: null` clears the override;
- * omitting a field leaves it unchanged. An entry that becomes empty is dropped.
- */
+* Patch one calendar's preference entry. `color: null` clears the override;
+* omitting a field leaves it unchanged. An entry that becomes empty is dropped.
+*/
 export declare function patchCalendarPreference(current: CalendarPreferences, calendarId: string, patch: {
-    readonly visible?: boolean;
-    readonly color?: string | null;
+	readonly visible?: boolean;
+	readonly color?: string | null;
 }): CalendarPreferences;

package/dist/builtins/calendars/calendars.addon.d.ts

@@ -1,14 +1,19 @@
-import { BaseAddon, ProviderRegistration } from '@camstack/types';
+/**
+* Hub calendars aggregator — walks `calendar-source` providers and stamps
+* cluster-stable ids (`<providerAddonId>:<localId>`). Owns per-user UI
+* preferences (colour / visibility) via `calendars:user-prefs`.
+*/
+import { BaseAddon, type ProviderRegistration } from "@camstack/types";
 export declare class CalendarsAddon extends BaseAddon {
-    readonly id = "calendars";
-    private prefsDeclared;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    private ensurePrefsSchema;
-    private sources;
-    private listCalendars;
-    private listEvents;
-    private getPreferences;
-    private setCalendarPreference;
+	readonly id = "calendars";
+	private prefsDeclared;
+	constructor();
+	protected onInitialize(): Promise<ProviderRegistration[]>;
+	private ensurePrefsSchema;
+	private sources;
+	private listCalendars;
+	private listEvents;
+	private getPreferences;
+	private setCalendarPreference;
 }
 export default CalendarsAddon;

package/dist/builtins/calendars/index.d.ts

@@ -1 +1 @@
-export { CalendarsAddon, default } from './calendars.addon.js';
+export { CalendarsAddon, default } from "./calendars.addon.js";

package/dist/builtins/camera-grid/acquire-retry.d.ts

@@ -1,30 +1,30 @@
 /**
- * Asking again for a source that has not republished yet.
- *
- * A camera provider re-announces its streams a moment after the hub comes up,
- * and a grid opened inside that window used to fail outright:
- *
- * ```
- * camera grid: could not acquire every source — releasing the ones already taken
- *   {acquired=0 error="getStreamWithCodec: profile \"low\" source \"native:sub\"
- *    not published for device 592"}
- * ```
- *
- * Observed twice on the hub at 12:02 on 2026-09-18 and gone by the next attempt.
- * It is the same shape as a WebRTC broker being rebuilt: the answer changes with
- * TIME, and the consumer was deciding on the first ask.
- *
- * The retry is BOUNDED and it changes no verdict — a camera that really has no
- * such profile still fails, with the provider's own error, after a wait that is
- * reported. What it stops is a grid refusing to open for the first few seconds
- * of every hub's life.
- */
+* Asking again for a source that has not republished yet.
+*
+* A camera provider re-announces its streams a moment after the hub comes up,
+* and a grid opened inside that window used to fail outright:
+*
+* ```
+* camera grid: could not acquire every source — releasing the ones already taken
+*   {acquired=0 error="getStreamWithCodec: profile \"low\" source \"native:sub\"
+*    not published for device 592"}
+* ```
+*
+* Observed twice on the hub at 12:02 on 2026-09-18 and gone by the next attempt.
+* It is the same shape as a WebRTC broker being rebuilt: the answer changes with
+* TIME, and the consumer was deciding on the first ask.
+*
+* The retry is BOUNDED and it changes no verdict — a camera that really has no
+* such profile still fails, with the provider's own error, after a wait that is
+* reported. What it stops is a grid refusing to open for the first few seconds
+* of every hub's life.
+*/
 export interface AcquireRetryDeps {
-    /** Wall-clock ceiling for the whole acquire, across every attempt. */
-    readonly budgetMs: number;
-    readonly now: () => number;
-    readonly sleep: () => Promise<void>;
-    /** Called before each retry with the ms spent so far — for the log line. */
-    readonly onRetry?: (waitedMs: number) => void;
+	/** Wall-clock ceiling for the whole acquire, across every attempt. */
+	readonly budgetMs: number;
+	readonly now: () => number;
+	readonly sleep: () => Promise<void>;
+	/** Called before each retry with the ms spent so far — for the log line. */
+	readonly onRetry?: (waitedMs: number) => void;
 }
 export declare function acquireWithRetry<T>(attempt: () => Promise<T>, deps: AcquireRetryDeps): Promise<T>;