@camstack/system 1.2.389 → 1.2.391

package/dist/builtins/composer/composer-grafts.d.ts

@@ -1,5 +1,24 @@
-import { CompositionFeaturePlan, CompositionSourceRef, IScopedLogger } from '@camstack/types';
-import { ComposerGraftPorts, DescribeTarget } from './existing-target.js';
+/**
+* The composer's side of grafts (D663, Task 10): WHEN a cap a customization
+* ADDS is grafted, removed or refused — `GraftHost` is only the how. Split from
+* `composer.ts`.
+*
+* - Decided at PLAN time only (rule 2): every added cap is grafted; a grafted
+*   cap the plan now finds native is ungrafted (its event was dropped, D8).
+* - NATIVE ALWAYS WINS (I-2). A foreign `native-registered` on a grafted cap
+*   ungrafts it (the claim stays). One that lands while a plan is in flight —
+*   after the target's description was read, before the graft — is remembered
+*   per described device, so that plan never grafts over it. A foreign
+*   `native-unregistered` never re-grafts (D659).
+* - A cap no graft serves is NAMED for the block verdict (I-1): refused by the
+*   host, or taken by a native. Every added cap unserved → the block fails.
+* - A binding a PREVIOUS composer process left (a respawn, D5) is retracted
+*   when a settled plan does not want it (I-3), or when the gate releases the
+*   add claim of a block that is gone — after reading that the binding IS the
+*   composer's; a read that fails retracts nothing (D49).
+*/
+import { type CompositionFeaturePlan, type CompositionSourceRef, type IScopedLogger } from "@camstack/types";
+import { type ComposerGraftPorts, type DescribeTarget } from "./existing-target.js";
 /** A foreign native now serves the grafted cap: the claim stays (Task 10 rule 2). */
 export declare const NATIVE_APPEARED_UNGRAFT_REASON = "a native provider appeared";
 /** The block's add claim was released by the D49 gate (deleted, disabled, feature removed): its graft goes with it. */
@@ -8,47 +27,47 @@ export declare const NO_LONGER_ADDED_UNGRAFT_REASON = "the block no longer adds
 export declare const STALE_GRAFT_RETRACT_REASON = "a graft left by a previous composer process that no plan wants";
 /** The `device.bindings-changed` facts the graft decisions read. */
 export interface BindingsChangeFacts {
-    readonly deviceId: number;
-    readonly capName: string;
-    readonly reason: string;
-    readonly addonId: string;
+	readonly deviceId: number;
+	readonly capName: string;
+	readonly reason: string;
+	readonly addonId: string;
 }
 export interface GraftPlanInput {
-    readonly deviceId: number;
-    readonly ref: CompositionSourceRef;
-    readonly features: readonly CompositionFeaturePlan[];
-    /** The description the plan used: cap → the addon serving it (`getBindings`). */
-    readonly nativeCaps: ReadonlyMap<string, string>;
-    readonly enabled: boolean;
-    /** Planned without problems; a block whose plan failed holds what it has (rule 4). */
-    readonly settled: boolean;
+	readonly deviceId: number;
+	readonly ref: CompositionSourceRef;
+	readonly features: readonly CompositionFeaturePlan[];
+	/** The description the plan used: cap → the addon serving it (`getBindings`). */
+	readonly nativeCaps: ReadonlyMap<string, string>;
+	readonly enabled: boolean;
+	/** Planned without problems; a block whose plan failed holds what it has (rule 4). */
+	readonly settled: boolean;
 }
 /** What a block's added caps say about its verdict: null when every one is served. */
 export interface GraftVerdict {
-    /** Nothing the block adds can be served. */
-    readonly allUnserved: boolean;
-    readonly reason: string;
+	/** Nothing the block adds can be served. */
+	readonly allUnserved: boolean;
+	readonly reason: string;
 }
 export declare class ComposerGrafts {
-    private readonly ports;
-    private readonly logger;
-    private readonly readBindings;
-    /** Per device: the added caps no graft serves, and why. Reset by each plan of that device. */
-    private unserved;
-    /** Per DESCRIBED device: foreign natives registered since its description was read (cap → addonId). */
-    private foreignSince;
-    constructor(ports: ComposerGraftPorts | undefined, logger: IScopedLogger, readBindings: DescribeTarget);
-    /** A description of `deviceId` is about to be read: it covers every registration before now. */
-    describing(deviceId: number): void;
-    onBindingsChanged(data: BindingsChangeFacts): void;
-    /** Rule 2, at plan time only: graft what the plan adds; ungraft what it finds native; retract what a previous process left. */
-    plan(input: GraftPlanInput): void;
-    /** The gate released a claim: a graft of that cap goes with it; a previous process's binding is retracted once read as the composer's. */
-    released(deviceId: number, capName: string): Promise<void>;
-    /** The target row is gone: nothing about it is reported any more. */
-    gone(deviceId: number): void;
-    verdict(deviceId: number, features: readonly CompositionFeaturePlan[]): GraftVerdict | null;
-    private retractUnwanted;
-    private remember;
-    private setUnserved;
+	private readonly ports;
+	private readonly logger;
+	private readonly readBindings;
+	/** Per device: the added caps no graft serves, and why. Reset by each plan of that device. */
+	private unserved;
+	/** Per DESCRIBED device: foreign natives registered since its description was read (cap → addonId). */
+	private foreignSince;
+	constructor(ports: ComposerGraftPorts | undefined, logger: IScopedLogger, readBindings: DescribeTarget);
+	/** A description of `deviceId` is about to be read: it covers every registration before now. */
+	describing(deviceId: number): void;
+	onBindingsChanged(data: BindingsChangeFacts): void;
+	/** Rule 2, at plan time only: graft what the plan adds; ungraft what it finds native; retract what a previous process left. */
+	plan(input: GraftPlanInput): void;
+	/** The gate released a claim: a graft of that cap goes with it; a previous process's binding is retracted once read as the composer's. */
+	released(deviceId: number, capName: string): Promise<void>;
+	/** The target row is gone: nothing about it is reported any more. */
+	gone(deviceId: number): void;
+	verdict(deviceId: number, features: readonly CompositionFeaturePlan[]): GraftVerdict | null;
+	private retractUnwanted;
+	private remember;
+	private setUnserved;
 }

package/dist/builtins/composer/composer-live-set.d.ts

@@ -1,22 +1,22 @@
-import { ClaimGate, ClaimKey } from './claim-gate.js';
-import { PlannedBlock } from './composer-plan.js';
-import { LiveComposition } from './composer-verdict.js';
-import { TrackedSourceRequest } from './source-tracker.js';
+import type { ClaimGate, ClaimKey } from "./claim-gate.js";
+import type { PlannedBlock } from "./composer-plan.js";
+import type { LiveComposition } from "./composer-verdict.js";
+import type { TrackedSourceRequest } from "./source-tracker.js";
 /** A release answered with one of these hands back nothing of ours: the gate forgets the claim. */
 export declare const RELEASE_SETTLED_CODES: ReadonlySet<string>;
 /**
- * The source keys an operator action on `p` re-opens: every source its fields
- * read, except its own target (re-resolved by `planExisting` already, never
- * twice).
- */
+* The source keys an operator action on `p` re-opens: every source its fields
+* read, except its own target (re-resolved by `planExisting` already, never
+* twice).
+*/
 export declare function operatorResetKeys(p: PlannedBlock): readonly string[];
 /** Every source the live set reads, with the view each own cap is read in. */
 export declare function trackedSourceRequests(live: Iterable<LiveComposition>): readonly TrackedSourceRequest[];
 /**
- * Rule 3: the claims every live customization WANTS this apply; everything
- * else the gate knows is a release candidate, handed back once two applies
- * agree. A block that cannot plan — waiting, unreadable, failed, or with its
- * target gone — HOLDS its claims (rule 4, rule 5): they are wanted as they
- * are. A disabled block wants none (rule 7).
- */
-export declare function wantedClaims(live: ReadonlyMap<string, LiveComposition>, claimGate: Pick<ClaimGate, 'claimsOf'>): readonly ClaimKey[];
+* Rule 3: the claims every live customization WANTS this apply; everything
+* else the gate knows is a release candidate, handed back once two applies
+* agree. A block that cannot plan — waiting, unreadable, failed, or with its
+* target gone — HOLDS its claims (rule 4, rule 5): they are wanted as they
+* are. A disabled block wants none (rule 7).
+*/
+export declare function wantedClaims(live: ReadonlyMap<string, LiveComposition>, claimGate: Pick<ClaimGate, "claimsOf">): readonly ClaimKey[];

package/dist/builtins/composer/composer-plan.d.ts

@@ -1,94 +1,110 @@
-import { CapabilityLookup, ComposerBlock, ComposerUnreadableBlock, CompositionExistingTarget, CompositionEventPlan, CompositionFeaturePlan, CompositionFieldPlan, CompositionNewTarget, CompositionSourceRef, DeviceDeclaration, DeviceType, IScopedLogger, LogTags } from '@camstack/types';
-import { TargetDescriptions } from './existing-target.js';
-import { SourceResolution } from './source-tracker.js';
+/**
+* What one apply PLANS for a block, before anything is declared, claimed or
+* run (D659, D663). Pure over its inputs: the composer hands in what it knows
+* (its rows, the previous plan, the tracker) and gets a `PlannedBlock` back.
+*
+* - A `new` target plans as in slice 1: a declaration, a shape, a placeholder
+*   when the composition stopped planning but its row exists.
+* - An `existing` target declares NOTHING (the row is not the composer's). It
+*   is resolved through the tracker's path, described with one bindings read
+*   per plan change, and planned against that description. A settled plan is
+*   kept until the OPERATOR acts (edit, restart): a bindings change alone never
+*   re-plans (Task 10 rule 2, D659). While the claims index is unseeded or the
+*   target is unresolved or undescribed, the block WAITS by name and claims
+*   nothing (D49). A target gone on two agreeing index reads is `gone`.
+* - An unreadable row names no target: whatever it holds is held (D49).
+*/
+import { type CapabilityLookup, type ComposerBlock, type ComposerUnreadableBlock, type CompositionExistingTarget, type CompositionEventPlan, type CompositionFeaturePlan, type CompositionFieldPlan, type CompositionNewTarget, type CompositionSourceRef, type DeviceDeclaration, type DeviceType, type IScopedLogger, type LogTags } from "@camstack/types";
+import type { TargetDescriptions } from "./existing-target.js";
+import type { SourceResolution } from "./source-tracker.js";
 /** What the apply knows of a block besides its plan. `name` is null for an unreadable row whose name is unreadable too. */
 export interface PlannedBlockMeta {
-    readonly id: string;
-    readonly name: string | null;
-    readonly enabled: boolean;
-    readonly updatedAt: number;
+	readonly id: string;
+	readonly name: string | null;
+	readonly enabled: boolean;
+	readonly updatedAt: number;
 }
 export interface ComposerDerivedSpec {
-    readonly type: DeviceType;
-    readonly role?: string;
+	readonly type: DeviceType;
+	readonly role?: string;
 }
 export interface PlannedNewTarget {
-    readonly kind: 'new';
+	readonly kind: "new";
 }
 /** A row that does not parse names no target: its claims, if any, are held (D49). */
 export interface PlannedUnreadableTarget {
-    readonly kind: 'unreadable';
+	readonly kind: "unreadable";
 }
 export interface PlannedExistingTarget {
-    readonly kind: 'existing';
-    readonly ref: CompositionSourceRef;
-    /** The target row's id once resolved; null until then. */
-    readonly deviceId: number | null;
-    /** Why the block is `starting` rather than planned: claims unseeded, target unresolved or undescribed. Nothing is claimed. */
-    readonly waiting: string | null;
-    /** The target row is gone — two index reads agreed (rule 5). Sticky until an operator edit or restart. */
-    readonly gone: string | null;
-    readonly features: readonly CompositionFeaturePlan[];
-    /** The description the plan used: cap → the addon serving it; empty until described. */
-    readonly nativeCaps: ReadonlyMap<string, string>;
+	readonly kind: "existing";
+	readonly ref: CompositionSourceRef;
+	/** The target row's id once resolved; null until then. */
+	readonly deviceId: number | null;
+	/** Why the block is `starting` rather than planned: claims unseeded, target unresolved or undescribed. Nothing is claimed. */
+	readonly waiting: string | null;
+	/** The target row is gone — two index reads agreed (rule 5). Sticky until an operator edit or restart. */
+	readonly gone: string | null;
+	readonly features: readonly CompositionFeaturePlan[];
+	/** The description the plan used: cap → the addon serving it; empty until described. */
+	readonly nativeCaps: ReadonlyMap<string, string>;
 }
 export type PlannedTarget = PlannedNewTarget | PlannedUnreadableTarget | PlannedExistingTarget;
 export interface PlannedBlock {
-    readonly block: PlannedBlockMeta;
-    readonly fields: readonly CompositionFieldPlan[];
-    readonly events: readonly CompositionEventPlan[];
-    readonly problems: readonly string[];
-    readonly declaration: DeviceDeclaration | null;
-    /** What forces a rebuild of the live device; null when nothing is declared. */
-    readonly shape: string | null;
-    readonly spec: ComposerDerivedSpec | null;
-    readonly target: PlannedTarget;
+	readonly block: PlannedBlockMeta;
+	readonly fields: readonly CompositionFieldPlan[];
+	readonly events: readonly CompositionEventPlan[];
+	readonly problems: readonly string[];
+	readonly declaration: DeviceDeclaration | null;
+	/** What forces a rebuild of the live device; null when nothing is declared. */
+	readonly shape: string | null;
+	readonly spec: ComposerDerivedSpec | null;
+	readonly target: PlannedTarget;
 }
 /**
- * A row that exists but does not parse is held exactly like a composition
- * that stopped planning: its device (if it has a row) stays as an offline
- * placeholder, its claims (if any) are kept, and the block fails naming the
- * parse error. Absent, it would be withdrawn on the second apply that omitted
- * it (D49).
- */
+* A row that exists but does not parse is held exactly like a composition
+* that stopped planning: its device (if it has a row) stays as an offline
+* placeholder, its claims (if any) are kept, and the block fails naming the
+* parse error. Absent, it would be withdrawn on the second apply that omitted
+* it (D49).
+*/
 export declare function planUnreadable(block: ComposerUnreadableBlock, rows: ReadonlySet<string>): PlannedBlock;
 /** `target` is the block's own `new` target, narrowed by the caller: this path never sees an existing one (M-5). */
 export declare function planNew(block: ComposerBlock, target: CompositionNewTarget, lookupCap: CapabilityLookup, rows: ReadonlySet<string>): PlannedBlock;
 /** The tracker's resolution path, as `planExisting` needs it (rule 1). */
 export interface TargetResolver {
-    resolve(ref: CompositionSourceRef, reset: boolean): Promise<SourceResolution>;
+	resolve(ref: CompositionSourceRef, reset: boolean): Promise<SourceResolution>;
 }
 export interface ExistingPlanInput {
-    readonly block: ComposerBlock;
-    readonly target: CompositionExistingTarget;
-    /** The block's previous plan, if it is live. */
-    readonly previous: PlannedBlock | undefined;
-    /** An edit, a restart, or the block's first appearance: the only things that re-plan a settled block. */
-    readonly operatorAction: boolean;
-    /** Why the claims index is not seeded yet, else null. */
-    readonly claimsWait: string | null;
-    readonly tracker: TargetResolver;
-    readonly targets: TargetDescriptions;
-    readonly lookupCap: CapabilityLookup;
+	readonly block: ComposerBlock;
+	readonly target: CompositionExistingTarget;
+	/** The block's previous plan, if it is live. */
+	readonly previous: PlannedBlock | undefined;
+	/** An edit, a restart, or the block's first appearance: the only things that re-plan a settled block. */
+	readonly operatorAction: boolean;
+	/** Why the claims index is not seeded yet, else null. */
+	readonly claimsWait: string | null;
+	readonly tracker: TargetResolver;
+	readonly targets: TargetDescriptions;
+	readonly lookupCap: CapabilityLookup;
 }
 export declare function planExisting(input: ExistingPlanInput): Promise<PlannedBlock>;
 /**
- * Runtime preparation can still fail after a complete existing-target plan.
- * Preserve its fields and description for retry, but mark it waiting so claim
- * reconciliation cannot treat the unprepared candidate as live.
- */
+* Runtime preparation can still fail after a complete existing-target plan.
+* Preserve its fields and description for retry, but mark it waiting so claim
+* reconciliation cannot treat the unprepared candidate as live.
+*/
 export declare function withExistingTargetWait(p: PlannedBlock, waiting: string): PlannedBlock;
 /** A target the previous plan held live on `deviceId`, that this plan finds gone. */
 export interface LostTarget {
-    readonly target: PlannedExistingTarget;
-    readonly deviceId: number;
+	readonly target: PlannedExistingTarget;
+	readonly deviceId: number;
 }
 /**
- * Rule 5 on the PLAN path: `device.unregistered` is telemetry and may be
- * dropped (D8), so a target is often found gone by the operator's next edit or
- * restart. The previous live target is what must be ungrafted — exactly as on
- * the event path. Null when nothing was lost by THIS plan.
- */
+* Rule 5 on the PLAN path: `device.unregistered` is telemetry and may be
+* dropped (D8), so a target is often found gone by the operator's next edit or
+* restart. The previous live target is what must be ungrafted — exactly as on
+* the event path. Null when nothing was lost by THIS plan.
+*/
 export declare function lostTarget(p: PlannedBlock, previous: PlannedBlock | undefined): LostTarget | null;
 /** Two plans write the same place: both new, or the very same existing-target plan (reused until the operator acts). */
 export declare function sameTarget(a: PlannedTarget, b: PlannedTarget): boolean;

package/dist/builtins/composer/composer-runtime-factory.d.ts

@@ -1,19 +1,26 @@
-import { CapabilityLookup, IScopedLogger } from '@camstack/types';
-import { ComposedDeviceHandle } from './composed-device.js';
-import { PlannedBlock } from './composer-plan.js';
-import { ComposedWriteTarget, CompositionEventEmitter, CompositionRuntime, DeadlineTimer } from './composition-runtime.js';
-import { ComposerClaimsApi, ExistingTargetSeedRead } from './existing-target.js';
-import { ClaimEvent } from './held-claims.js';
-import { SourceTracker } from './source-tracker.js';
+/**
+* What a planned block's runtime is built from: WHERE it writes (its composed
+* device, or a claim-backed target on an existing device) and HOW it reads
+* (rule 6: a self-read of a field the block did not ADD is the native, never
+* the merge; the block's own output is answered by the runtime, never through
+* the hub — D670 amendment).
+*/
+import { type CapabilityLookup, type IScopedLogger } from "@camstack/types";
+import type { ComposedDeviceHandle } from "./composed-device.js";
+import type { PlannedBlock } from "./composer-plan.js";
+import { type ComposedWriteTarget, type CompositionEventEmitter, CompositionRuntime, type DeadlineTimer } from "./composition-runtime.js";
+import { type ComposerClaimsApi, type ExistingTargetSeedRead } from "./existing-target.js";
+import type { ClaimEvent } from "./held-claims.js";
+import type { SourceTracker } from "./source-tracker.js";
 /** The composer dependencies a runtime and its write target are built from. */
 export interface RuntimeFactoryDeps {
-    readonly logger: IScopedLogger;
-    readonly claims: ComposerClaimsApi;
-    readonly tracker: SourceTracker;
-    readonly events: CompositionEventEmitter;
-    readonly lookupCap: CapabilityLookup;
-    readonly now: () => number;
-    readonly newTimer: () => DeadlineTimer;
+	readonly logger: IScopedLogger;
+	readonly claims: ComposerClaimsApi;
+	readonly tracker: SourceTracker;
+	readonly events: CompositionEventEmitter;
+	readonly lookupCap: CapabilityLookup;
+	readonly now: () => number;
+	readonly newTimer: () => DeadlineTimer;
 }
 /** Where a block's own claim transitions are followed (C-1/N-1). */
 export type ClaimEventSink = (deviceId: number, cap: string, owner: string, event: ClaimEvent) => void;

package/dist/builtins/composer/composer-seeds.d.ts

@@ -1,22 +1,28 @@
-import { FieldClaim, IScopedLogger } from '@camstack/types';
-import { PersistedComposedRow } from './composition-declarations.js';
-import { ConfirmedSeed } from './confirmed-seed.js';
-import { ComposerClaimsApi } from './existing-target.js';
+/**
+* The two reads the composer takes ONCE before its first decision (D49): the
+* composed rows it already owns (before any withdrawal) and the claims the hub
+* holds (before any release). Each is a `ConfirmedSeed`: an unread or a
+* first-empty answer waits, by name, for an agreeing read.
+*/
+import { type FieldClaim, type IScopedLogger } from "@camstack/types";
+import type { PersistedComposedRow } from "./composition-declarations.js";
+import { ConfirmedSeed } from "./confirmed-seed.js";
+import type { ComposerClaimsApi } from "./existing-target.js";
 export interface ComposedRowSeedDeps {
-    readonly logger: IScopedLogger;
-    /** The composed rows that already exist (`listOwnDevices`). */
-    readonly readPersisted: () => Promise<readonly PersistedComposedRow[]>;
-    readonly onSeeded: (rows: readonly PersistedComposedRow[]) => void;
+	readonly logger: IScopedLogger;
+	/** The composed rows that already exist (`listOwnDevices`). */
+	readonly readPersisted: () => Promise<readonly PersistedComposedRow[]>;
+	readonly onSeeded: (rows: readonly PersistedComposedRow[]) => void;
 }
 /** The rows the composer owns, read ONCE before its first withdrawal decision. */
 export declare function composedRowSeed(deps: ComposedRowSeedDeps): ConfirmedSeed<PersistedComposedRow>;
 export interface ClaimIndexSeedDeps {
-    readonly logger: IScopedLogger;
-    readonly claims: ComposerClaimsApi;
-    readonly onSeeded: (claims: readonly FieldClaim[]) => void;
+	readonly logger: IScopedLogger;
+	readonly claims: ComposerClaimsApi;
+	readonly onSeeded: (claims: readonly FieldClaim[]) => void;
 }
 /**
- * The claims the hub holds, read ONCE before the first release decision (rule
- * 3). `not-loaded` is UNKNOWN (D315), never empty.
- */
+* The claims the hub holds, read ONCE before the first release decision (rule
+* 3). `not-loaded` is UNKNOWN (D315), never empty.
+*/
 export declare function claimIndexSeed(deps: ClaimIndexSeedDeps): ConfirmedSeed<FieldClaim>;

package/dist/builtins/composer/composer-verdict.d.ts

@@ -1,19 +1,33 @@
-import { ComposerBlockVerdict, CompositionFieldState } from '@camstack/types';
-import { ComposedDeviceHandle } from './composed-device.js';
-import { PlannedBlock } from './composer-plan.js';
-import { CompositionRuntime } from './composition-runtime.js';
-import { GraftVerdict } from './composer-grafts.js';
+/**
+* What a block's report says (D659, D663): one verdict per live block, every
+* one naming its reason. Pure over the live entry — split from `composer.ts`.
+*
+* - A new-target block whose device exists and runs no runtime plans no field:
+*   nothing to run is running (the pre-split verdict, M-6).
+* - A runtime built by an apply and not yet started by its sync is `starting`.
+* - A released field is `degraded` (S1b), naming the field and its source.
+* - An added cap no graft serves (refused, or taken by a native) is `degraded`
+*   naming it; every added cap unserved is `failed` (Task 10, I-1).
+* - A HELD field — unavailable, but no source has answered so (a failed, first
+*   or empty read) — keeps its last value and its claim: `starting`, naming
+*   the field and why (D49, fix round 2). Released wins: it is the harder fact.
+*/
+import type { ComposerBlockVerdict, CompositionFieldState } from "@camstack/types";
+import type { ComposedDeviceHandle } from "./composed-device.js";
+import type { PlannedBlock } from "./composer-plan.js";
+import type { CompositionRuntime } from "./composition-runtime.js";
+import type { GraftVerdict } from "./composer-grafts.js";
 /** A runtime built by an apply, before the apply's sync decides whether it may start. */
 export declare const NOT_STARTED = "the runtime has not started yet";
 export interface LiveComposition {
-    readonly planned: PlannedBlock;
-    /** The composed device of a `new` target; null for an existing one. */
-    readonly device: ComposedDeviceHandle | null;
-    readonly runtime: CompositionRuntime | null;
-    readonly appliedName: string | null;
-    /** Why the device could not be rebuilt for a new shape; the previous one is kept. */
-    readonly rebuildError: string | null;
-    /** Rule 4: the last values of a customization that stopped planning, reported stale. */
-    readonly heldFields: readonly CompositionFieldState[];
+	readonly planned: PlannedBlock;
+	/** The composed device of a `new` target; null for an existing one. */
+	readonly device: ComposedDeviceHandle | null;
+	readonly runtime: CompositionRuntime | null;
+	readonly appliedName: string | null;
+	/** Why the device could not be rebuilt for a new shape; the previous one is kept. */
+	readonly rebuildError: string | null;
+	/** Rule 4: the last values of a customization that stopped planning, reported stale. */
+	readonly heldFields: readonly CompositionFieldState[];
 }
 export declare function verdictOf(blockId: string, entry: LiveComposition | undefined, unsynced: boolean, grafts?: GraftVerdict | null): ComposerBlockVerdict;

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

@@ -1,12 +1,26 @@
-import { BaseAddon, ProviderRegistration } from '@camstack/types';
+/**
+* The `composer` builtin (D659): runs every declarative composition in ONE
+* isolated runner (`execution.isolate` + `group: composer`). It is
+* frame-free and low-crash, and its group is a group of ONE — no device
+* provider or data plane shares it, so a crash respawns nothing else (D29,
+* enforced by `scripts/check-runner-group-isolation.ts`). `CrashSupervisor`
+* bounds it like every forked runner (D6). Hub-only: declarations are cluster
+* state.
+*
+* Slice 2 (D663): a composition on an EXISTING device claims its fields on the
+* hub (`deviceState.claimFields` …) and reads its own replaced fields from the
+* native shadow (`getNativeCapSlice`, `device.native-shadow-changed`) — the one
+* subscriber that category has (`scripts/check-owner-only-events.ts`).
+*/
+import { BaseAddon, type ProviderRegistration } from "@camstack/types";
 export declare class ComposerAddon extends BaseAddon<Record<string, never>> {
-    private composer;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    /** An event handler never rejects unhandled: in a forked runner that is a crash strike (D6). */
-    private logEventFailure;
-    private buildProvider;
-    private requireComposer;
+	private composer;
+	constructor();
+	protected onInitialize(): Promise<ProviderRegistration[]>;
+	protected onShutdown(): Promise<void>;
+	/** An event handler never rejects unhandled: in a forked runner that is a crash strike (D6). */
+	private logEventFailure;
+	private buildProvider;
+	private requireComposer;
 }
 export default ComposerAddon;