@camstack/system 1.2.389 → 1.2.391

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

@@ -1,31 +1,66 @@
-import { PixelOrigin, PixelSize } from './grid-canvas.js';
-import { NormalizedRect } from './grid-filter-graph.js';
+/**
+* The operator's layout, as one decoder child per CELL.
+*
+* ## Why per cell, when `grid-plan.ts` dedupes per source
+*
+* The single ffmpeg that this replaces made a camera used by two cells ONE
+* input, because decoding it twice doubles the expensive half of the job. A
+* compositor cannot do that with the same shape: this repo has exactly one
+* ffmpeg argv builder (`scripts/check-ffmpeg-primitive.ts`, Rule 1) and it
+* expresses one output per process, so a source feeding two differently cropped
+* and differently scaled tiles needs two children.
+*
+* The trade is small and worth stating: since D528 every source is read at its
+* CHEAPEST stream, so the duplicate is a second 640x360 sub-stream decode, not a
+* second 4 MP one. Teaching the builder several outputs would buy that back, and
+* is the right change to make if a grid ever shows one camera many times — it is
+* deliberately not made for a case that costs this little.
+*
+* ## Why the tile is scaled in the DECODER
+*
+* ffmpeg's scaler is SIMD and already there. Scaling in this process would be a
+* per-pixel loop in JavaScript, on the event loop that also answers the grid's
+* RPCs. Handing each child the exact pixel size its rectangle needs makes the
+* composition a strided memcpy (`grid-canvas.ts`) and keeps the only per-pixel
+* work where it belongs.
+*
+* ## Even, and snapped DOWN
+*
+* yuv420p subsamples chroma 2x2, so an odd origin lands a tile's chroma half a
+* sample off its luma — which TINTS the tile instead of breaking it, and
+* survives review. Sizes round DOWN so a tile never claims a row the decoder
+* was not asked to produce; a cell that rounds away to nothing is dropped
+* rather than emitted at zero size, because a zero-size output is an ffmpeg
+* start-up failure that would take the whole grid with it.
+*/
+import { type PixelOrigin, type PixelSize } from "./grid-canvas.js";
+import type { 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;
+	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[];
+	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;
+	/** 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[];
+	readonly canvas: PixelSize;
+	readonly tiles: readonly GridTile[];
 }
 export declare function buildGridTilePlan(input: GridTilePlanInput): GridTilePlan;

package/dist/builtins/camera-grid/grid-wire-format.d.ts

@@ -1,4 +1,20 @@
-import { CamStreamKind } from '@camstack/types';
+/**
+* The one place that says what a grid puts on the wire.
+*
+* Four things have to agree — the ffmpeg sink, the HTTP content type, the URL
+* the broker dials, and the `kind` the catalog declares — and on 2026-09-17
+* they stopped agreeing twice in one hour. The switch from MPEG-TS to FLV
+* moved three of them and left the snapshot sampler spawning `-f mpegts`
+* against an FLV pipe: every grab returned nothing, and the WARN said "the
+* frame grab produced no bytes" without naming a format, because from where it
+* stood there was nothing to name.
+*
+* A constant cannot drift the way four literals can. Why FLV at all is
+* explained where the sink is built (`grid-stream-invocation.ts`): the bundled
+* ffmpeg segfaults re-muxing MPEG-TS, which is exactly what the broker's source
+* reader does to whatever this serves.
+*/
+import type { CamStreamKind } from "@camstack/types";
 /** The ffmpeg muxer the composition writes to stdout. */
 export declare const GRID_WIRE_CONTAINER: "flv";
 /** What the relay answers with, and what the sampler must demux. */
@@ -6,9 +22,9 @@ export declare const GRID_WIRE_CONTENT_TYPE = "video/x-flv";
 /** `/grid/<instanceId>/<profile>.flv`. */
 export declare const GRID_WIRE_PATH_SUFFIX = ".flv";
 /**
- * How the broker must ingest it: `pull-flv` is documented as ALWAYS read
- * through the ffmpeg source reader with `-c copy`. `pull-http` would have been
- * the intuitive choice and means MJPEG in this broker — it answers with
- * `HTTP_MJPEG_H264_OUTPUT_ARGS` and re-encodes an already-encoded H.264.
- */
+* How the broker must ingest it: `pull-flv` is documented as ALWAYS read
+* through the ffmpeg source reader with `-c copy`. `pull-http` would have been
+* the intuitive choice and means MJPEG in this broker — it answers with
+* `HTTP_MJPEG_H264_OUTPUT_ARGS` and re-encodes an already-encoded H.264.
+*/
 export declare const GRID_WIRE_STREAM_KIND: CamStreamKind;

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

@@ -1,45 +1,45 @@
 /**
- * Camera Grids — composite cameras built from other cameras.
- *
- * The manifest `entry` points at THIS module's build (`./dist/index.js`), and
- * `vite.config.ts` must carry an `entries` key for every module a manifest
- * names — a manifest entry is just a string and nothing resolves it at build
- * time, so a missing key compiles and fails at runtime.
- * `scripts/check-addon-entries.ts` is what catches that.
- */
-export { CameraGridAddon } from './addon.js';
-export { CameraGridAddon as default } from './addon.js';
-export { buildGridFilterGraph } from './grid-filter-graph.js';
-export type { GridCell, GridFilterGraph, GridLayout, NormalizedRect, } from './grid-filter-graph.js';
-export { buildGridCameraDeclarations, gridCameraReconciliationIndex, newGridCameraStableId, } from './grid-camera-declarations.js';
-export type { ExistingGridCameraRow, GridCameraConfig, GridCameraDeclaration, } from './grid-camera-declarations.js';
-export { GridCameraDevice, installGridCameraRuntime } from './grid-camera-device.js';
-export type { GridCameraRuntime } from './grid-camera-device.js';
-export { readGridInstances } from './grid-instances.js';
-export type { GridCellConfig, GridInstance } from './grid-instances.js';
-export { gridPlanFor } from './grid-plan.js';
-export type { GridPlanEncodeContext } from './grid-plan.js';
-export { normalizeGridRows } from './grid-row-normalization.js';
-export type { NormalizedGridRows } from './grid-row-normalization.js';
-export { gridStreamDescriptor } from './grid-stream-descriptor.js';
-export { GRID_CAM_STREAM_ID, GRID_PROFILES, gridCamStreamId, gridProfilePlans, } from './grid-profiles.js';
-export type { GridProfilePlan, ServedProfile } from './grid-profiles.js';
-export { deriveGridCanvas } from './grid-canvas-derivation.js';
-export { gridSourceDial } from './grid-sentry-sources.js';
-export type { GridSourceAcquisition, GridSourceDial } from './grid-sentry-sources.js';
-export { GridSnapshotSource, gridSnapshotAnswerFor } from './grid-snapshot.js';
-export type { GridLastFrameStore, GridSnapshotAnswer, GridSnapshotDeps, GridSnapshotImage, GridSnapshotSession, } from './grid-snapshot.js';
-export { GridLastFrameFileStore } from './grid-last-frame-store.js';
-export { GridFrameSampler } from './grid-frame-sample.js';
-export type { GridFrameSource, GridSpawn } from './grid-frame-sample.js';
-export type { GridStreamDescriptorInput } from './grid-stream-descriptor.js';
-export { gridStreamInvocation } from './grid-stream-invocation.js';
-export type { GridStreamInvocationInput, GridStreamSource } from './grid-stream-invocation.js';
-export { GridStreamRelay, parseGridStreamPath } from './grid-stream-relay.js';
-export type { GridStreamRelayDeps, GridStreamRequest } from './grid-stream-relay.js';
-export { GridStreamSession } from './grid-stream-session.js';
-export type { GridSourceHandle, GridStreamChild, GridStreamConsumer, GridStreamHold, GridStreamLogger, GridStreamPlan, GridStreamSessionDeps, GridStreamSessionOptions, } from './grid-stream-session.js';
-export { startGridChild } from './grid-child.js';
-export type { GridChildContext } from './grid-child.js';
-export { GRID_SILENCED_CAP_NAMES, silenceAnalysisFor } from './silence-analysis.js';
-export type { SilenceAnalysisDeps } from './silence-analysis.js';
+* Camera Grids — composite cameras built from other cameras.
+*
+* The manifest `entry` points at THIS module's build (`./dist/index.js`), and
+* `vite.config.ts` must carry an `entries` key for every module a manifest
+* names — a manifest entry is just a string and nothing resolves it at build
+* time, so a missing key compiles and fails at runtime.
+* `scripts/check-addon-entries.ts` is what catches that.
+*/
+export { CameraGridAddon } from "./addon.js";
+export { CameraGridAddon as default } from "./addon.js";
+export { buildGridFilterGraph } from "./grid-filter-graph.js";
+export type { GridCell, GridFilterGraph, GridLayout, NormalizedRect } from "./grid-filter-graph.js";
+export { buildGridCameraDeclarations, gridCameraReconciliationIndex, newGridCameraStableId } from "./grid-camera-declarations.js";
+export type { ExistingGridCameraRow, GridCameraConfig, GridCameraDeclaration } from "./grid-camera-declarations.js";
+export { GridCameraDevice, installGridCameraRuntime } from "./grid-camera-device.js";
+export type { GridCameraRuntime } from "./grid-camera-device.js";
+export { readGridInstances } from "./grid-instances.js";
+export type { GridCellConfig, GridInstance } from "./grid-instances.js";
+export { gridPlanFor } from "./grid-plan.js";
+export type { GridPlanEncodeContext } from "./grid-plan.js";
+export { normalizeGridRows } from "./grid-row-normalization.js";
+export type { NormalizedGridRows } from "./grid-row-normalization.js";
+export { gridStreamDescriptor } from "./grid-stream-descriptor.js";
+export { GRID_CAM_STREAM_ID, GRID_PROFILES, gridCamStreamId, gridProfilePlans } from "./grid-profiles.js";
+export type { GridProfilePlan, ServedProfile } from "./grid-profiles.js";
+export { deriveGridCanvas } from "./grid-canvas-derivation.js";
+export { gridSourceDial } from "./grid-sentry-sources.js";
+export type { GridSourceAcquisition, GridSourceDial } from "./grid-sentry-sources.js";
+export { GridSnapshotSource, gridSnapshotAnswerFor } from "./grid-snapshot.js";
+export type { GridLastFrameStore, GridSnapshotAnswer, GridSnapshotDeps, GridSnapshotImage, GridSnapshotSession } from "./grid-snapshot.js";
+export { GridLastFrameFileStore } from "./grid-last-frame-store.js";
+export { GridFrameSampler } from "./grid-frame-sample.js";
+export type { GridFrameSource, GridSpawn } from "./grid-frame-sample.js";
+export type { GridStreamDescriptorInput } from "./grid-stream-descriptor.js";
+export { gridStreamInvocation } from "./grid-stream-invocation.js";
+export type { GridStreamInvocationInput, GridStreamSource } from "./grid-stream-invocation.js";
+export { GridStreamRelay, parseGridStreamPath } from "./grid-stream-relay.js";
+export type { GridStreamRelayDeps, GridStreamRequest } from "./grid-stream-relay.js";
+export { GridStreamSession } from "./grid-stream-session.js";
+export type { GridSourceHandle, GridStreamChild, GridStreamConsumer, GridStreamHold, GridStreamLogger, GridStreamPlan, GridStreamSessionDeps, GridStreamSessionOptions } from "./grid-stream-session.js";
+export { startGridChild } from "./grid-child.js";
+export type { GridChildContext } from "./grid-child.js";
+export { GRID_SILENCED_CAP_NAMES, silenceAnalysisFor } from "./silence-analysis.js";
+export type { SilenceAnalysisDeps } from "./silence-analysis.js";

package/dist/builtins/camera-grid/silence-analysis.d.ts

@@ -1,20 +1,37 @@
-import { AddonApi, IScopedLogger } from '@camstack/types';
 /**
- * The list lives in `@camstack/types` now, and this is an alias rather than a
- * second copy. There WERE two — this one and the Terminal addon's — and they
- * had drifted: neither named `pipeline-analytics`, the one cap with no gate of
- * its own, which is what a grid forwarding its sources' motion would have used
- * to write a duplicate motion episode per event.
- */
+* Every analyzer a composite camera is created with switched OFF.
+*
+* A grid is a picture we composed from cameras that are ALREADY analyzed. Running
+* detection on the composite would pay for the same subjects a second time, and
+* would attribute them to a camera that does not exist as a viewpoint — a person
+* detected in the bottom-right cell is a person on THAT camera, not on the grid.
+*
+* `motion-detection` sits first deliberately: it is the one that holds the decode
+* session open, so its absence is the difference between a grid costing a
+* composition and costing a full decode pipeline. Same ordering, and the same
+* reason, as the Terminal addon's list.
+*
+* Called ONLY on creation. An operator who deliberately turns detection back on
+* for a grid must win, and a reconcile that re-asserted every pass would silently
+* overrule them once a minute.
+*/
+import { type AddonApi, type IScopedLogger } from "@camstack/types";
+/**
+* The list lives in `@camstack/types` now, and this is an alias rather than a
+* second copy. There WERE two — this one and the Terminal addon's — and they
+* had drifted: neither named `pipeline-analytics`, the one cap with no gate of
+* its own, which is what a grid forwarding its sources' motion would have used
+* to write a duplicate motion episode per event.
+*/
 export declare const GRID_SILENCED_CAP_NAMES: readonly string[];
 export interface SilenceAnalysisDeps {
-    readonly api: AddonApi;
-    readonly logger: IScopedLogger;
+	readonly api: AddonApi;
+	readonly logger: IScopedLogger;
 }
 /**
- * @throws if a cap IS bound and the write to its authority failed. The composite
- * would then be running a full analyzer over a picture whose subjects are already
- * counted elsewhere — exactly the cost this removes — and a silent version of
- * that failure is unfindable.
- */
+* @throws if a cap IS bound and the write to its authority failed. The composite
+* would then be running a full analyzer over a picture whose subjects are already
+* counted elsewhere — exactly the cost this removes — and a silent version of
+* that failure is unfindable.
+*/
 export declare function silenceAnalysisFor(deps: SilenceAnalysisDeps, deviceId: number): Promise<void>;

package/dist/builtins/composer/claim-gate.d.ts

@@ -1,32 +1,59 @@
-import { FieldClaim, IScopedLogger } from '@camstack/types';
+/**
+* The D49 gate over RELEASING a claim (D663).
+*
+* A composition on an existing device owns fields of the device through claims
+* on the hub, keyed by the block id. When the block is deleted, disabled, or
+* loses a feature, its claims must be handed back — and a block missing from
+* ONE apply (a transient store read, a race) must not hand a native field back
+* for good. So a release needs two consecutive applies to agree, exactly like
+* `WithdrawalGate` guards a composed device (D659).
+*
+* The gate is seeded at boot from the hub's claims index, so a restart is never
+* the first miss: an orphaned claim of a block that no longer exists is
+* released on the SECOND apply after boot, not the first, and not never.
+*
+* A release the hub did not confirm (a throw, an unreadable row, a migration in
+* flight) is retried on EVERY later apply until it lands — never on a timer
+* (D3), and never given up: a forgotten orphan claim would pin a stale composed
+* value on a native field until the composer restarts. Logged once per
+* transition (D391): a WARN when the failures start, an INFO naming the failed
+* attempts when it finally lands. This is also what heals a runtime whose own
+* `releaseClaim` on `disable()` failed: a disabled runtime runs no further pass
+* to re-send it (Task 8), the gate does.
+*
+* NOT the gate's: a FIELD released because its source is unavailable (S1b).
+* That is the runtime's `withhold`, immediate and reversible on the next event —
+* a source that blinked is not a withdrawal of the block's authority.
+*/
+import type { FieldClaim, IScopedLogger } from "@camstack/types";
 export interface ClaimKey {
-    readonly deviceId: number;
-    readonly capName: string;
-    readonly owner: string;
+	readonly deviceId: number;
+	readonly capName: string;
+	readonly owner: string;
 }
 export declare function claimKey(k: ClaimKey): string;
 export declare class ClaimGate {
-    private readonly logger;
-    private known;
-    constructor(logger: IScopedLogger);
-    /**
-     * The claims the hub holds before this process applied anything. Called once
-     * at boot, before the first `filter`. A claim the gate already knows keeps its
-     * entry and its miss count.
-     */
-    seed(claims: readonly FieldClaim[]): void;
-    /** Every claim known under one owner — what a block whose plan is held keeps (D659 placeholder rule). */
-    claimsOf(owner: string): readonly ClaimKey[];
-    /**
-     * Learn `wanted` and answer the claims to release NOW: those absent from
-     * `wanted` on two consecutive calls, plus those whose earlier release the hub
-     * has not confirmed yet. A claim wanted again starts from zero misses.
-     */
-    filter(wanted: readonly ClaimKey[]): readonly ClaimKey[];
-    /** The hub confirmed the release (or held nothing of ours): forgotten. */
-    released(key: ClaimKey, how: string): void;
-    /** The release did not land: kept, and returned by every later `filter` until it does. Never given up. */
-    releaseFailed(key: ClaimKey, error: string): void;
-    private tagsOf;
-    private metaOf;
+	private readonly logger;
+	private known;
+	constructor(logger: IScopedLogger);
+	/**
+	* The claims the hub holds before this process applied anything. Called once
+	* at boot, before the first `filter`. A claim the gate already knows keeps its
+	* entry and its miss count.
+	*/
+	seed(claims: readonly FieldClaim[]): void;
+	/** Every claim known under one owner — what a block whose plan is held keeps (D659 placeholder rule). */
+	claimsOf(owner: string): readonly ClaimKey[];
+	/**
+	* Learn `wanted` and answer the claims to release NOW: those absent from
+	* `wanted` on two consecutive calls, plus those whose earlier release the hub
+	* has not confirmed yet. A claim wanted again starts from zero misses.
+	*/
+	filter(wanted: readonly ClaimKey[]): readonly ClaimKey[];
+	/** The hub confirmed the release (or held nothing of ours): forgotten. */
+	released(key: ClaimKey, how: string): void;
+	/** The release did not land: kept, and returned by every later `filter` until it does. Never given up. */
+	releaseFailed(key: ClaimKey, error: string): void;
+	private tagsOf;
+	private metaOf;
 }

package/dist/builtins/composer/composed-device-set.d.ts

@@ -1,38 +1,52 @@
-import { DeviceDeclaration, IScopedLogger } from '@camstack/types';
-import { ComposedDeviceHandle } from './composed-device.js';
-import { ComposerDerivedSpec, PlannedBlock } from './composer-plan.js';
-import { PersistedComposedRow } from './composition-declarations.js';
+/**
+* The composed devices the composer DECLARED (D659): one row per `new`-target
+* block, hung off the shared Blocks integration, adopted or built by
+* `DeclaredDevices.reconcile`. This is the only place a composed row is created,
+* kept or swept — a composition on an EXISTING device never enters it (D663).
+*
+* - `rows` is the set of stableIds whose row exists: seeded from the persisted
+*   rows at boot, then what every declare kept. Planning asks it to decide
+*   whether a block that stopped planning has a row to hold as a placeholder.
+* - A changed shape (type, role, cap set, placeholder or not) needs a NEW device
+*   object: decommission, and let the reconcile adopt it with the new class. A
+*   failure keeps the old device and is retried on the next apply.
+* - A failed reconcile changes nothing (D49): the devices already live stay.
+*/
+import { type DeviceDeclaration, type IScopedLogger } from "@camstack/types";
+import type { ComposedDeviceHandle } from "./composed-device.js";
+import type { ComposerDerivedSpec, PlannedBlock } from "./composer-plan.js";
+import type { PersistedComposedRow } from "./composition-declarations.js";
 export interface ComposerDevicePorts {
-    setName(deviceId: number, name: string): Promise<void>;
-    decommission(deviceId: number): Promise<void>;
-    applyDerivedSpec(deviceId: number, derived: ComposerDerivedSpec): Promise<void>;
+	setName(deviceId: number, name: string): Promise<void>;
+	decommission(deviceId: number): Promise<void>;
+	applyDerivedSpec(deviceId: number, derived: ComposerDerivedSpec): Promise<void>;
 }
 export interface ComposerDeclareResult {
-    /** Live composed devices by stableId. */
-    readonly devices: ReadonlyMap<string, ComposedDeviceHandle>;
+	/** Live composed devices by stableId. */
+	readonly devices: ReadonlyMap<string, ComposedDeviceHandle>;
 }
 export type ComposerDeclare = (integrationId: string, devices: readonly DeviceDeclaration[]) => Promise<ComposerDeclareResult>;
 export interface ComposedDeviceSetDeps {
-    readonly logger: IScopedLogger;
-    readonly declare: ComposerDeclare;
-    readonly devices: ComposerDevicePorts;
+	readonly logger: IScopedLogger;
+	readonly declare: ComposerDeclare;
+	readonly devices: ComposerDevicePorts;
 }
 /** What `rebuildShapes` needs of a block's previous apply: its live device and the shape it was built for. */
 export interface PreviousShape {
-    readonly device: ComposedDeviceHandle | null;
-    readonly shape: string | null;
+	readonly device: ComposedDeviceHandle | null;
+	readonly shape: string | null;
 }
 export declare class ComposedDeviceSet {
-    private readonly deps;
-    private devices;
-    private existingRows;
-    private declaredFingerprint;
-    constructor(deps: ComposedDeviceSetDeps);
-    /** StableIds whose row exists. */
-    get rows(): ReadonlySet<string>;
-    seedRows(rows: readonly PersistedComposedRow[]): void;
-    get(stableId: string): ComposedDeviceHandle | null;
-    idOf(stableId: string): number | null;
-    rebuildShapes(planned: readonly PlannedBlock[], previousOf: (blockId: string) => PreviousShape | undefined): Promise<ReadonlyMap<string, string>>;
-    reconcile(integrationId: string, declarations: readonly DeviceDeclaration[], planned: readonly PlannedBlock[]): Promise<void>;
+	private readonly deps;
+	private devices;
+	private existingRows;
+	private declaredFingerprint;
+	constructor(deps: ComposedDeviceSetDeps);
+	/** StableIds whose row exists. */
+	get rows(): ReadonlySet<string>;
+	seedRows(rows: readonly PersistedComposedRow[]): void;
+	get(stableId: string): ComposedDeviceHandle | null;
+	idOf(stableId: string): number | null;
+	rebuildShapes(planned: readonly PlannedBlock[], previousOf: (blockId: string) => PreviousShape | undefined): Promise<ReadonlyMap<string, string>>;
+	reconcile(integrationId: string, declarations: readonly DeviceDeclaration[], planned: readonly PlannedBlock[]): Promise<void>;
 }

package/dist/builtins/composer/composed-device.d.ts

@@ -1,27 +1,49 @@
-import { BaseDevice, CapabilityDefinition, DeviceConstructor, DeviceContext, DeviceFeature, DeviceType, IDevice } from '@camstack/types';
-import { z } from 'zod';
-import { ComposedWriteTarget, WriteOutcome } from './composition-runtime.js';
-import { SlicePatch } from './slice-assembler.js';
-declare const COMPOSED_DEVICE_CONFIG_SCHEMA: z.ZodObject<{}, z.core.$strip>;
+/**
+* A composed device: an ordinary `BaseDevice` whose caps are served by the
+* composer (D659). Every consumer (exporters, NC, UI, HomeKit) reads it
+* through its bindings, unchanged.
+*
+* It serves NO command method: slice 1 refuses any cap with one
+* (`has-commands`), and commands arrive with `forward` in slice 3. So each
+* composed cap is registered with an EMPTY native provider, and `getStatus`
+* (R4) is the kernel's: `registerNativeCap` installs a default that reads the
+* device's runtime slice for any cap declaring both `status` and
+* `runtimeState` (`device-cap-proxy.ts`, "Default `getStatus`"), on the
+* registry path and the forked-runner (UDS) path alike. Every composable cap
+* qualifies: the validator refuses a cap with no `runtimeState`
+* (`validate-composition.ts`, `not-composable`). The default is correct only
+* because, for every composable cap, `status.schema` and `runtimeState` have
+* one shape — `composed-device.spec.ts` enumerates the real cap registry and
+* fails the day one breaks it (slice 3 lifting `has-commands` makes
+* `recording-signal` such a cap). `room-device.e2e.spec.ts` proves R4 through
+* the real registry. Its type comes from the declaration, not from
+* `deviceMeta`: a failed meta read builds a device as `generic`, and the
+* declaration is the authority for what this device is.
+*/
+import { BaseDevice, type CapabilityDefinition, type DeviceConstructor, type DeviceContext, type DeviceFeature, type DeviceType, type IDevice } from "@camstack/types";
+import { z } from "zod";
+import type { ComposedWriteTarget, WriteOutcome } from "./composition-runtime.js";
+import type { SlicePatch } from "./slice-assembler.js";
+declare const COMPOSED_DEVICE_CONFIG_SCHEMA: z.ZodObject<Record<string, never>>;
 export interface ComposedDeviceHandle extends ComposedWriteTarget {
-    readonly name: string;
+	readonly name: string;
 }
 export declare class ComposedDevice extends BaseDevice<typeof COMPOSED_DEVICE_CONFIG_SCHEMA> implements ComposedDeviceHandle {
-    readonly features: readonly DeviceFeature[];
-    constructor(ctx: DeviceContext, type: DeviceType, caps: readonly CapabilityDefinition[]);
-    seed(capName: string, slice: SlicePatch): WriteOutcome;
-    patch(capName: string, patch: SlicePatch): WriteOutcome;
-    setAvailable(available: boolean): void;
+	readonly features: readonly DeviceFeature[];
+	constructor(ctx: DeviceContext, type: DeviceType, caps: readonly CapabilityDefinition[]);
+	seed(capName: string, slice: SlicePatch): WriteOutcome;
+	patch(capName: string, patch: SlicePatch): WriteOutcome;
+	setAvailable(available: boolean): void;
 }
 export declare function composedDeviceClass(type: DeviceType, caps: readonly CapabilityDefinition[]): DeviceConstructor<ComposedDevice>;
 /**
- * A composed device kept alive by the withdrawal gate for a persisted row whose
- * block this process has not planned (yet): no caps, offline. Its type is the
- * ROW's (`deviceMeta.type`) — only ever adopted from an existing row, where the
- * row is canonical — because there is no plan to take one from.
- */
+* A composed device kept alive by the withdrawal gate for a persisted row whose
+* block this process has not planned (yet): no caps, offline. Its type is the
+* ROW's (`deviceMeta.type`) — only ever adopted from an existing row, where the
+* row is canonical — because there is no plan to take one from.
+*/
 export declare class ComposedPlaceholderDevice extends ComposedDevice {
-    constructor(ctx: DeviceContext);
+	constructor(ctx: DeviceContext);
 }
 export declare function isComposedDevice(device: IDevice): device is ComposedDevice;
 export {};

package/dist/builtins/composer/composer-apply-waits.d.ts

@@ -1,21 +1,28 @@
-import { ComposerApplyInput, ComposerApplyResult, IScopedLogger } from '@camstack/types';
+/**
+* The two preconditions an apply waits on BEFORE it reads anything (D49, R2):
+* the `core_blocks` store has loaded, and the shared Blocks integration has
+* reconciled. Each wait is warned once per run — the supervisor re-applies
+* every converge while it waits — and its end is logged with the count of
+* applies it refused.
+*/
+import type { ComposerApplyInput, ComposerApplyResult, IScopedLogger } from "@camstack/types";
 /** An apply either waits, naming why, or goes on with the reconciled integration. */
 export type ApplyGate = {
-    readonly kind: 'wait';
-    readonly reason: string;
+	readonly kind: "wait";
+	readonly reason: string;
 } | {
-    readonly kind: 'go';
-    readonly integrationId: string;
+	readonly kind: "go";
+	readonly integrationId: string;
 };
 export declare class ApplyWaits {
-    private readonly logger;
-    /** Consecutive applies refused because `core_blocks` had not loaded: warned once per run. */
-    private storeWaitApplies;
-    /** Consecutive applies refused because the Blocks integration had not reconciled: warned once per run. */
-    private integrationWaitApplies;
-    constructor(logger: IScopedLogger);
-    /** Whether this apply must act on nothing (and why), or may go on. */
-    check(input: ComposerApplyInput, liveCount: number): ApplyGate;
+	private readonly logger;
+	/** Consecutive applies refused because `core_blocks` had not loaded: warned once per run. */
+	private storeWaitApplies;
+	/** Consecutive applies refused because the Blocks integration had not reconciled: warned once per run. */
+	private integrationWaitApplies;
+	constructor(logger: IScopedLogger);
+	/** Whether this apply must act on nothing (and why), or may go on. */
+	check(input: ComposerApplyInput, liveCount: number): ApplyGate;
 }
 /** Every block `starting`, naming the wait; nothing acted. */
 export declare function waitingResult(blockIds: readonly string[], reason: string): ComposerApplyResult;