@camstack/system 1.2.389 → 1.2.391

package/dist/builtins/composer/source-readings.d.ts

@@ -1,115 +1,121 @@
-import { CompositionSourceRef, DeviceType, EventCatalog, IScopedLogger } from '@camstack/types';
+/**
+* What the source tracker reads and holds (D659, D663): the hub ports it reads
+* through, the requests it tracks, and one reading per (cap, view) — plus the
+* pure helpers over them. Split from `source-tracker.ts` so that file holds the
+* behaviour; every public name is re-exported from there.
+*/
+import { type CompositionSourceRef, type DeviceType, type EventCatalog, type IScopedLogger } from "@camstack/types";
 /** One row of the slim device listing: what resolves a `(addonId, stableId)` ref and types an existing target. */
 export interface SourceRow {
-    readonly id: number;
-    readonly stableId: string;
-    readonly type: DeviceType;
+	readonly id: number;
+	readonly stableId: string;
+	readonly type: DeviceType;
 }
 export interface SourceRowsRead {
-    readonly kind: 'rows';
-    readonly rows: readonly SourceRow[];
+	readonly kind: "rows";
+	readonly rows: readonly SourceRow[];
 }
 export interface SourceUnreadable {
-    readonly kind: 'unreadable';
-    readonly error: string;
+	readonly kind: "unreadable";
+	readonly error: string;
 }
 export type SourceListRead = SourceRowsRead | SourceUnreadable;
 export interface SliceFound {
-    readonly kind: 'slice';
-    readonly slice: Readonly<Record<string, unknown>>;
+	readonly kind: "slice";
+	readonly slice: Readonly<Record<string, unknown>>;
 }
 export interface SliceNone {
-    readonly kind: 'none';
+	readonly kind: "none";
 }
 export type SliceRead = SliceFound | SliceNone | SourceUnreadable;
 /** The caps bound on a device, each with the addon serving it natively (`getBindings`, one read). */
 export interface BoundCaps {
-    readonly kind: 'caps';
-    readonly caps: ReadonlyMap<string, string>;
+	readonly kind: "caps";
+	readonly caps: ReadonlyMap<string, string>;
 }
 export type BoundCapsRead = BoundCaps | SourceUnreadable;
 /** Which slice of a cap is read: what every consumer sees, or what the provider wrote (the shadow under a claim, D663). */
-export type SliceView = 'effective' | 'native';
+export type SliceView = "effective" | "native";
 export interface SourceTrackerPorts {
-    readonly logger: IScopedLogger;
-    /** `deviceManager.listAll({ addonId, projection: 'slim' })`: one call per owning addon per pass. */
-    readonly listDevicesOf: (addonId: string) => Promise<SourceListRead>;
-    /** `deviceState.getCapSlice` for the effective view; `deviceState.getNativeCapSlice` for the native one. */
-    readonly readSlice: (deviceId: number, capName: string, view: SliceView) => Promise<SliceRead>;
-    readonly readBoundCaps: (deviceId: number) => Promise<BoundCapsRead>;
+	readonly logger: IScopedLogger;
+	/** `deviceManager.listAll({ addonId, projection: 'slim' })`: one call per owning addon per pass. */
+	readonly listDevicesOf: (addonId: string) => Promise<SourceListRead>;
+	/** `deviceState.getCapSlice` for the effective view; `deviceState.getNativeCapSlice` for the native one. */
+	readonly readSlice: (deviceId: number, capName: string, view: SliceView) => Promise<SliceRead>;
+	readonly readBoundCaps: (deviceId: number) => Promise<BoundCapsRead>;
 }
 /** Why a `device.bindings-changed` fired — the catalog's own closed union. */
-export type SourceBindingsChangeReason = EventCatalog['device.bindings-changed']['reason'];
+export type SourceBindingsChangeReason = EventCatalog["device.bindings-changed"]["reason"];
 export interface TrackedSourceRequest {
-    readonly ref: CompositionSourceRef;
-    /** Caps read in the effective view — what every consumer sees. */
-    readonly caps: readonly string[];
-    /** Caps of the REF read in the NATIVE view: the target's own replaced or uncomposed fields (rule 6). */
-    readonly nativeCaps?: readonly string[];
-    /** The block whose own claims decide whether `device.state-changed` of a native cap is the native (N-7). */
-    readonly nativeOwner?: string;
+	readonly ref: CompositionSourceRef;
+	/** Caps read in the effective view — what every consumer sees. */
+	readonly caps: readonly string[];
+	/** Caps of the REF read in the NATIVE view: the target's own replaced or uncomposed fields (rule 6). */
+	readonly nativeCaps?: readonly string[];
+	/** The block whose own claims decide whether `device.state-changed` of a native cap is the native (N-7). */
+	readonly nativeOwner?: string;
 }
 /** How a `(addonId, stableId)` ref resolves against the device index. */
 export interface SourceFound {
-    readonly kind: 'found';
-    readonly deviceId: number;
-    readonly type: DeviceType;
+	readonly kind: "found";
+	readonly deviceId: number;
+	readonly type: DeviceType;
 }
 export interface SourceMissing {
-    readonly kind: 'missing';
-    readonly reason: string;
+	readonly kind: "missing";
+	readonly reason: string;
 }
 export interface SourceUnknown {
-    readonly kind: 'unknown';
-    readonly error: string;
+	readonly kind: "unknown";
+	readonly error: string;
 }
 export type SourceResolution = SourceFound | SourceMissing | SourceUnknown;
 export interface CapSlice {
-    readonly kind: 'slice';
-    readonly slice: Readonly<Record<string, unknown>>;
-    readonly staleReason: string | null;
+	readonly kind: "slice";
+	readonly slice: Readonly<Record<string, unknown>>;
+	readonly staleReason: string | null;
 }
 export interface CapNoValue {
-    readonly kind: 'none';
-    readonly reason: string;
-    /** An ANSWER — the provider unregistered the cap and a bindings re-read agreed — not an empty or first read (D49). */
-    readonly confirmed: boolean;
+	readonly kind: "none";
+	readonly reason: string;
+	/** An ANSWER — the provider unregistered the cap and a bindings re-read agreed — not an empty or first read (D49). */
+	readonly confirmed: boolean;
 }
 /** Not bound on a device whose row exists: non-fatal, healed by `native-registered` (R7b). */
 export interface CapUnbound {
-    readonly kind: 'unbound';
-    readonly reason: string;
+	readonly kind: "unbound";
+	readonly reason: string;
 }
 /** Nothing is known: the read failed with no value held, or read empty under a held claim. Re-read by the next `sync` (D49). */
 export interface CapUnread {
-    readonly kind: 'unread';
-    readonly reason: string;
+	readonly kind: "unread";
+	readonly reason: string;
 }
 export type CapReading = CapSlice | CapNoValue | CapUnbound | CapUnread;
 /** One cap in one view — the unit a reading is held for. */
 export interface CapEntry {
-    readonly cap: string;
-    readonly view: SliceView;
+	readonly cap: string;
+	readonly view: SliceView;
 }
 export interface TrackedSource {
-    readonly ref: CompositionSourceRef;
-    readonly deviceId: number | null;
-    readonly type: DeviceType | null;
-    readonly missingReason: string | null;
-    /** The index could not be read the last time: retried on the next apply. */
-    readonly indexError: string | null;
-    readonly online: boolean | null;
-    /** Keyed by `entryKey`: an effective and a native reading of one cap are two entries. */
-    readonly caps: ReadonlyMap<string, CapReading>;
-    /** Whose claims decide what a `device.state-changed` is for the native-view caps; null: nobody claims here. */
-    readonly nativeOwner: string | null;
+	readonly ref: CompositionSourceRef;
+	readonly deviceId: number | null;
+	readonly type: DeviceType | null;
+	readonly missingReason: string | null;
+	/** The index could not be read the last time: retried on the next apply. */
+	readonly indexError: string | null;
+	readonly online: boolean | null;
+	/** Keyed by `entryKey`: an effective and a native reading of one cap are two entries. */
+	readonly caps: ReadonlyMap<string, CapReading>;
+	/** Whose claims decide what a `device.state-changed` is for the native-view caps; null: nobody claims here. */
+	readonly nativeOwner: string | null;
 }
 export interface Absent {
-    readonly kind: 'absent';
+	readonly kind: "absent";
 }
 export type RowVerdict = SourceFound | Absent | SourceUnknown;
 export type Resolution = SourceFound | SourceMissing | SourceUnknown;
-export type BindingVerdict = 'bound' | 'unbound' | 'unknown';
+export type BindingVerdict = "bound" | "unbound" | "unknown";
 export declare const DEVICE_STATUS_CAP = "device-status";
 export declare const NATIVE_SUFFIX = "@native";
 export declare const NO_CAPS: readonly string[];

package/dist/builtins/composer/source-tracker.d.ts

@@ -1,71 +1,135 @@
-import { CompositionFieldRead, CompositionSourceRef, FieldClaim, SourceReading } from '@camstack/types';
-import { ClaimEvent } from './held-claims.js';
-import { SliceView, SourceBindingsChangeReason, SourceResolution, SourceTrackerPorts, TrackedSourceRequest } from './source-readings.js';
-export type { BoundCaps, BoundCapsRead, SliceFound, SliceNone, SliceRead, SliceView, SourceBindingsChangeReason, SourceFound, SourceListRead, SourceMissing, SourceResolution, SourceRow, SourceRowsRead, SourceTrackerPorts, SourceUnknown, SourceUnreadable, TrackedSourceRequest, } from './source-readings.js';
+/**
+* What a composition's sources currently say, per source device and per cap
+* (D659).
+*
+* Fed by the events sources ALREADY emit (`device.state-changed`,
+* `device.unregistered`, `device.bindings-changed`). It never polls and arms no
+* timer. It reads the hub only to HYDRATE a source it has not resolved yet (on
+* `sync`, driven by the supervisor's existing converge), to CONFIRM a
+* destructive verdict, and to RECONCILE when the source device (re)registers.
+* A source once resolved is not re-read by `sync`: its values arrive by
+* `device.state-changed`. Events are telemetry and may be dropped (D8), so the
+* reconcile point is the one the source itself raises: a
+* `device.bindings-changed` for a cap it serves (`native-registered` on a
+* provider restart, a wrapper toggle) re-reads that cap — and `device-status`
+* re-reads `online` — and a source found under a NEW id after an unregister is
+* re-read at once. No timer, no poll (R7c).
+*
+*  - fresh: the last value, from a device that is online;
+*  - stale: the last value, while the device is offline or a re-read
+*    flickered. Nothing is destroyed (D49);
+*  - unavailable: no value — never a number that looks plausible (D393). A cap
+*    the provider unregistered is unavailable, NOT stale (spec §2), and so is a
+*    cap absent from the bindings of a device whose ROW exists: after a hub
+*    restart or a provider respawn the bindings are empty until the provider
+*    re-registers, and two back-to-back binding reads are one correlated read.
+*    `fatal` only when the source DEVICE is GONE and two index reads agreed.
+*    Fatal is sticky: only an operator reset ends it (no auto-repair, 2026-08-08).
+*
+* A re-read that answers "no report" never replaces a value already held: the
+* value is kept, marked stale with the reason (D49 — one empty read is not
+* proof). Only `native-unregistered` takes a value away (R7b).
+*
+* Every entry point runs on ONE promise chain (R3): `sync` builds its next map
+* across awaits, and an event that landed mid-way used to be overwritten when
+* that map was assigned. `read` is synchronous, from the last settled map.
+*
+* D224 (R7d): what is held here is the INPUT of a field the composition owns.
+* It is served to nobody else — no cap method, no getter for another addon
+* reads this map; the composed device's slice is the only output. A consumer
+* that wants a source's value asks the addon that owns that source.
+*
+* Slice 2 (D663): a cap is read in one of two VIEWS. The `effective` view is
+* what every consumer sees. The `native` view is what the provider wrote — the
+* shadow under a `replace` claim — and it is how a composition reads its OWN
+* target's fields without seeing its own output (rule 6, no self-cycle). The hub
+* emits the shadow (`device.native-shadow-changed`, owner-only) only for a cap
+* under a claim, and for an unclaimed cap `device.state-changed` IS the native;
+* so a native-view cap under the block's OWN claim ignores `device.state-changed`,
+* and one it does not takes it. What is held is what LANDED (`claimEvent`, the
+* boot seed), never what a plan wants (C-1); while the block's claim RPC is in
+* flight, `device.state-changed` is neither (N-1). Every claim or release reply
+* re-reads the native once — the read that closes the window between the RPC
+* and its answer (N-4). The target ROW is resolved through the same path as a
+* source (`resolve`): one list read, two agreeing absent reads to call it
+* missing, sticky until an operator reset.
+*
+* An unavailability is CONFIRMED only when it is an answer (D49, fix round 2):
+* a GONE row (two reads agreed), a cap the provider unregistered that a
+* bindings re-read agrees is unbound, a field the source reported without. A
+* failed read (`unread`, retried by the next `sync` — the converge is the
+* retry), a first read that finds the cap unbound, an empty read, a source not
+* tracked yet: unconfirmed. Only a confirmed one lets a `release`-mode field
+* hand its claim back; an unconfirmed one holds it on its last value.
+*/
+import { type CompositionFieldRead, type CompositionSourceRef, type FieldClaim, type SourceReading } from "@camstack/types";
+import { type ClaimEvent } from "./held-claims.js";
+import { type SliceView, type SourceBindingsChangeReason, type SourceResolution, type SourceTrackerPorts, type TrackedSourceRequest } from "./source-readings.js";
+export type { BoundCaps, BoundCapsRead, SliceFound, SliceNone, SliceRead, SliceView, SourceBindingsChangeReason, SourceFound, SourceListRead, SourceMissing, SourceResolution, SourceRow, SourceRowsRead, SourceTrackerPorts, SourceUnknown, SourceUnreadable, TrackedSourceRequest } from "./source-readings.js";
 export declare class SourceTracker {
-    private readonly ports;
-    private sources;
-    /** The claims the hub holds — what LANDED, never what a plan wants (C-1). */
-    private readonly held;
-    /** The one chain every entry point joins (R3); the pattern is `BlockSupervisor.inFlight`. */
-    private chain;
-    constructor(ports: SourceTrackerPorts);
-    /**
-     * Track exactly `requests`. Hydrate what is new or unresolved; keep what is
-     * known. `reset` names source keys an OPERATOR action re-opens (a block edit
-     * or restart): only those lose a sticky `missing`.
-     */
-    sync(requests: readonly TrackedSourceRequest[], reset: ReadonlySet<string>): Promise<ReadonlySet<string>>;
-    /**
-     * Resolve a ref against the device index through the same path as a source
-     * (D663 rule 1): one list read; two agreeing absent reads make it `missing`,
-     * sticky until `reset` (an operator edit or restart). A source already
-     * resolved is answered from memory; one whose index read FAILED is read
-     * again. The bare source stays tracked, so a later `sync` that names it keeps
-     * its resolution and reads only the caps it asks for.
-     */
-    resolve(ref: CompositionSourceRef, reset: boolean): Promise<SourceResolution>;
-    /** The claims the hub held at boot (the claims index seed). Nothing is read: no native self-read is tracked before it. */
-    seedClaims(claims: readonly FieldClaim[]): void;
-    /**
-     * A claim RPC of `owner` on `(deviceId, cap)`: dispatched (`claiming`), or
-     * answered — the hub holds it (`held`), holds none of it (`free`), or said
-     * nothing that changes it (`unsettled`). Every ANSWER re-reads the owner's
-     * native-view readings of that cap ONCE: while the RPC was in flight (or a
-     * release was being applied) the provider's writes arrived as a
-     * `device.state-changed` the tracker could not take as the native.
-     */
-    claimEvent(deviceId: number, cap: string, owner: string, event: ClaimEvent): Promise<ReadonlySet<string>>;
-    /** The last settled resolution of a ref; `unknown` when it was never resolved. Synchronous, from memory. */
-    resolution(ref: CompositionSourceRef): SourceResolution;
-    onStateChanged(deviceId: number, capName: string, slice: Readonly<Record<string, unknown>>): Promise<ReadonlySet<string>>;
-    /** `device.native-shadow-changed`: the provider's own slice of a cap under a claim (owner-only, D224). */
-    onNativeChanged(deviceId: number, capName: string, native: Readonly<Record<string, unknown>>): Promise<ReadonlySet<string>>;
-    onDeviceUnregistered(deviceId: number): Promise<ReadonlySet<string>>;
-    onBindingsChanged(deviceId: number, capName: string, reason: SourceBindingsChangeReason): Promise<ReadonlySet<string>>;
-    /** Run `work` after everything already queued, whether that settled or failed; never let one failure stall the chain. */
-    private serialized;
-    private syncNow;
-    read(read: CompositionFieldRead, view?: SliceView): SourceReading;
-    private applyStateChanged;
-    private applyNativeChanged;
-    private confirmUnregistered;
-    private applyBindingsChanged;
-    /** A source found under a NEW id is a re-registration: read it there now (R7c). */
-    private rereadUnderNewId;
-    private hydrate;
-    /** Read `toRead` (bindings first, then slices); every other requested entry keeps what `known` holds. */
-    private readCaps;
-    private resolveConfirmed;
-    /**
-     * One bindings read. A second one would not confirm anything: back to back
-     * they are one correlated read, and "unbound" no longer destroys work — it is
-     * a non-fatal `none` that `native-registered` heals.
-     */
-    private readBindings;
-    private readCap;
-    /** A claim or release of `owner` on `(deviceId, cap)` was answered: read the owner's native-view readings of it once, in place. */
-    private rereadNative;
-    private logHealed;
-    private readOnline;
+	private readonly ports;
+	private sources;
+	/** The claims the hub holds — what LANDED, never what a plan wants (C-1). */
+	private readonly held;
+	/** The one chain every entry point joins (R3); the pattern is `BlockSupervisor.inFlight`. */
+	private chain;
+	constructor(ports: SourceTrackerPorts);
+	/**
+	* Track exactly `requests`. Hydrate what is new or unresolved; keep what is
+	* known. `reset` names source keys an OPERATOR action re-opens (a block edit
+	* or restart): only those lose a sticky `missing`.
+	*/
+	sync(requests: readonly TrackedSourceRequest[], reset: ReadonlySet<string>): Promise<ReadonlySet<string>>;
+	/**
+	* Resolve a ref against the device index through the same path as a source
+	* (D663 rule 1): one list read; two agreeing absent reads make it `missing`,
+	* sticky until `reset` (an operator edit or restart). A source already
+	* resolved is answered from memory; one whose index read FAILED is read
+	* again. The bare source stays tracked, so a later `sync` that names it keeps
+	* its resolution and reads only the caps it asks for.
+	*/
+	resolve(ref: CompositionSourceRef, reset: boolean): Promise<SourceResolution>;
+	/** The claims the hub held at boot (the claims index seed). Nothing is read: no native self-read is tracked before it. */
+	seedClaims(claims: readonly FieldClaim[]): void;
+	/**
+	* A claim RPC of `owner` on `(deviceId, cap)`: dispatched (`claiming`), or
+	* answered — the hub holds it (`held`), holds none of it (`free`), or said
+	* nothing that changes it (`unsettled`). Every ANSWER re-reads the owner's
+	* native-view readings of that cap ONCE: while the RPC was in flight (or a
+	* release was being applied) the provider's writes arrived as a
+	* `device.state-changed` the tracker could not take as the native.
+	*/
+	claimEvent(deviceId: number, cap: string, owner: string, event: ClaimEvent): Promise<ReadonlySet<string>>;
+	/** The last settled resolution of a ref; `unknown` when it was never resolved. Synchronous, from memory. */
+	resolution(ref: CompositionSourceRef): SourceResolution;
+	onStateChanged(deviceId: number, capName: string, slice: Readonly<Record<string, unknown>>): Promise<ReadonlySet<string>>;
+	/** `device.native-shadow-changed`: the provider's own slice of a cap under a claim (owner-only, D224). */
+	onNativeChanged(deviceId: number, capName: string, native: Readonly<Record<string, unknown>>): Promise<ReadonlySet<string>>;
+	onDeviceUnregistered(deviceId: number): Promise<ReadonlySet<string>>;
+	onBindingsChanged(deviceId: number, capName: string, reason: SourceBindingsChangeReason): Promise<ReadonlySet<string>>;
+	/** Run `work` after everything already queued, whether that settled or failed; never let one failure stall the chain. */
+	private serialized;
+	private syncNow;
+	read(read: CompositionFieldRead, view?: SliceView): SourceReading;
+	private applyStateChanged;
+	private applyNativeChanged;
+	private confirmUnregistered;
+	private applyBindingsChanged;
+	/** A source found under a NEW id is a re-registration: read it there now (R7c). */
+	private rereadUnderNewId;
+	private hydrate;
+	/** Read `toRead` (bindings first, then slices); every other requested entry keeps what `known` holds. */
+	private readCaps;
+	private resolveConfirmed;
+	/**
+	* One bindings read. A second one would not confirm anything: back to back
+	* they are one correlated read, and "unbound" no longer destroys work — it is
+	* a non-fatal `none` that `native-registered` heals.
+	*/
+	private readBindings;
+	private readCap;
+	/** A claim or release of `owner` on `(deviceId, cap)` was answered: read the owner's native-view readings of it once, in place. */
+	private rereadNative;
+	private logHealed;
+	private readOnline;
 }

package/dist/builtins/console-logging/console-destination.d.ts

@@ -1,13 +1,20 @@
-import { ILogDestination, LogEntry, LogFilter } from '@camstack/types';
+/**
+* Zero-dependency log destination that writes every entry to stdout /
+* stderr via the shared `formatLogLine` formatter. Same surface as
+* `WinstonDestination` (full `ILogDestination` contract) but without
+* the rotating-file transport — ideal fallback when the Winston addon
+* is disabled or unavailable (e.g. bare-bones agents, tests).
+*/
+import type { ILogDestination, LogEntry, LogFilter } from "@camstack/types";
 interface ConsoleConfig {
-    /** Minimum log level to emit. Entries below this level are dropped. */
-    readonly level?: 'debug' | 'info' | 'warn' | 'error';
+	/** Minimum log level to emit. Entries below this level are dropped. */
+	readonly level?: "debug" | "info" | "warn" | "error";
 }
 export declare class ConsoleDestination implements ILogDestination {
-    private minLevel;
-    initialize(config?: ConsoleConfig): Promise<void>;
-    write(entry: LogEntry): void;
-    query(_filter: LogFilter): Promise<readonly LogEntry[]>;
-    shutdown(): Promise<void>;
+	private minLevel;
+	initialize(config?: ConsoleConfig): Promise<void>;
+	write(entry: LogEntry): void;
+	query(_filter: LogFilter): Promise<readonly LogEntry[]>;
+	shutdown(): Promise<void>;
 }
 export {};

package/dist/builtins/console-logging/console-logging.addon.d.ts

@@ -1,25 +1,26 @@
-import { ProviderRegistration, BaseAddon } from '@camstack/types';
-import { ConsoleDestination } from './console-destination.js';
+import type { ConfigUISchema, ProviderRegistration } from "@camstack/types";
+import { BaseAddon } from "@camstack/types";
+import { ConsoleDestination } from "./console-destination.js";
 interface ConsoleConfig {
-    readonly level: 'debug' | 'info' | 'warn' | 'error';
+	readonly level: "debug" | "info" | "warn" | "error";
 }
 /**
- * Console logging addon — zero-dependency stdout/stderr sink that
- * produces the same canonical line format as the Winston built-in.
- * Registers as a `log-destination` capability provider so the shared
- * LogManager fans every entry to both sinks when both are active.
- *
- * Settings live under Cluster → NodeDetail → Settings alongside the
- * Winston addon. Disable one without disabling the other — the
- * LogManager keeps working as long as at least one destination is
- * registered.
- */
+* Console logging addon — zero-dependency stdout/stderr sink that
+* produces the same canonical line format as the Winston built-in.
+* Registers as a `log-destination` capability provider so the shared
+* LogManager fans every entry to both sinks when both are active.
+*
+* Settings live under Cluster → NodeDetail → Settings alongside the
+* Winston addon. Disable one without disabling the other — the
+* LogManager keeps working as long as at least one destination is
+* registered.
+*/
 export declare class ConsoleLoggingAddon extends BaseAddon<ConsoleConfig> {
-    private destination;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    getDestination(): ConsoleDestination;
-    protected globalSettingsSchema(): import('@camstack/types').ConfigUISchema;
+	private destination;
+	constructor();
+	protected onInitialize(): Promise<ProviderRegistration[]>;
+	protected onShutdown(): Promise<void>;
+	getDestination(): ConsoleDestination;
+	protected globalSettingsSchema(): ConfigUISchema;
 }
 export {};

package/dist/builtins/console-logging/index.d.ts

@@ -1,3 +1,3 @@
-export { ConsoleLoggingAddon } from './console-logging.addon.js';
-export { ConsoleDestination } from './console-destination.js';
-export { ConsoleLoggingAddon as default } from './console-logging.addon.js';
+export { ConsoleLoggingAddon } from "./console-logging.addon.js";
+export { ConsoleDestination } from "./console-destination.js";
+export { ConsoleLoggingAddon as default } from "./console-logging.addon.js";

package/dist/builtins/core-blocks/block-package.d.ts

@@ -1,52 +1,52 @@
-import { coreBlockAddonId, coreBlockIdFromAddonId } from '@camstack/types';
+import { coreBlockAddonId, coreBlockIdFromAddonId } from "@camstack/types";
 /**
- * The runner id lives on the CAPABILITY, not here.
- *
- * It stopped being an implementation detail the day the operator surface
- * started reading a block's logs by asking `logs.query` for
- * `addonId = core-block-<id>` — with no cap of its own. A second copy of the
- * string would drift into a logs pane that is silently always empty, so these
- * are re-exports under the names this package already used.
- */
-export declare const BLOCK_ADDON_PREFIX = "core-block-";
+* The runner id lives on the CAPABILITY, not here.
+*
+* It stopped being an implementation detail the day the operator surface
+* started reading a block's logs by asking `logs.query` for
+* `addonId = core-block-<id>` — with no cap of its own. A second copy of the
+* string would drift into a logs pane that is silently always empty, so these
+* are re-exports under the names this package already used.
+*/
+export declare const BLOCK_ADDON_PREFIX: string;
 export declare const blockAddonId: typeof coreBlockAddonId;
 export declare const blockIdFromAddonId: typeof coreBlockIdFromAddonId;
 export interface MaterializeBlockInput {
-    /** Root under which every block package lives — one directory per block. */
-    readonly root: string;
-    readonly blockId: string;
-    readonly blockName: string;
-    /** The block's bundled / transpiled JavaScript (written to `dist/block.js`). */
-    readonly js: string;
-    /**
-     * Optional TypeScript sources (path → content). Written under `src/` so a
-     * multi-file project is inspectable on disk next to the bundle the runner
-     * loads. Absent for a legacy single-file materialize.
-     */
-    readonly files?: Readonly<Record<string, string>>;
+	/** Root under which every block package lives — one directory per block. */
+	readonly root: string;
+	readonly blockId: string;
+	readonly blockName: string;
+	/** The block's bundled / transpiled JavaScript (written to `dist/block.js`). */
+	readonly js: string;
+	/**
+	* Optional TypeScript sources (path → content). Written under `src/` so a
+	* multi-file project is inspectable on disk next to the bundle the runner
+	* loads. Absent for a legacy single-file materialize.
+	*/
+	readonly files?: Readonly<Record<string, string>>;
 }
 export interface MaterializedBlock {
-    /** What `$process.spawnRunner` gets as `addonDir` — the package root. */
-    readonly addonDir: string;
-    readonly addonId: string;
+	/** What `$process.spawnRunner` gets as `addonDir` — the package root. */
+	readonly addonDir: string;
+	readonly addonId: string;
 }
 /** Build the wrapper for one block. Exported for the test that asserts the
- *  generated source actually carries the block's identity. */
+*  generated source actually carries the block's identity. */
 export declare function renderBlockWrapper(blockId: string, blockName: string): string;
 /** The package manifest the addon runner reads to find the entry point. */
 export declare function renderBlockManifest(blockId: string, blockName: string): string;
 /**
- * Write (or rewrite) a block's package. Idempotent, and deliberately a full
- * rewrite: the author's code is the thing that changes, and a partial update
- * that left a stale `block.js` behind would run yesterday's code while the
- * editor showed today's.
- *
- * Layout:
- *   `src/<path>`     — author TypeScript when `files` is provided
- *   `dist/block.js`  — bundled / transpiled entry (what the wrapper imports)
- *   `dist/index.js`  — generated BaseAddon wrapper
- */
+* Write (or rewrite) a block's package. Idempotent, and deliberately a full
+* rewrite: the author's code is the thing that changes, and a partial update
+* that left a stale `block.js` behind would run yesterday's code while the
+* editor showed today's.
+*
+* Layout:
+*   `src/<path>`     — author TypeScript when `files` is provided
+*   `dist/block.js`  — bundled / transpiled entry (what the wrapper imports)
+*   `dist/index.js`  — generated BaseAddon wrapper
+*/
 export declare function materializeBlock(input: MaterializeBlockInput): Promise<MaterializedBlock>;
 /** Remove a block's package. Idempotent — a missing directory is the desired
- *  end state, not an error. */
+*  end state, not an error. */
 export declare function removeBlockPackage(root: string, blockId: string): Promise<void>;

package/dist/builtins/core-blocks/block-settings-store.d.ts

@@ -1,30 +1,43 @@
-import { SettingsStoreClient } from '@camstack/types';
 /**
- * @durable class=config owner=core-blocks
- *   write="`setValues` / `mergeValues` persist the operator's prefs for one block"
- *   retention="`delete` when the block is deleted. Nothing ages out."
- */
+* Preference values for core blocks.
+*
+* Schema lives on the block record (`settingsSchema`, extracted from the
+* compiled entry's named export or set by the editor). Values live HERE —
+* one JSON blob per blockId — so a settings patch never rewrites the
+* operator's source, and so a block that has not yet declared a schema still
+* keeps any values the UI already wrote.
+*
+* On every patch the same values are mirrored into the block addon's
+* `addon-settings` namespace so a running script reads them the same way any
+* addon does: `ctx.settings.readAddonStore()`.
+*/
+import type { SettingsStoreClient } from "@camstack/types";
+/**
+* @durable class=config owner=core-blocks
+*   write="`setValues` / `mergeValues` persist the operator's prefs for one block"
+*   retention="`delete` when the block is deleted. Nothing ages out."
+*/
 export declare const CORE_BLOCK_SETTINGS_COLLECTION = "core-blocks:settings";
 export declare const CORE_BLOCK_SETTINGS_COLUMNS: readonly [{
-    readonly name: "id";
-    readonly type: "TEXT";
-    readonly primaryKey: true;
-    readonly notNull: true;
+	readonly name: "id";
+	readonly type: "TEXT";
+	readonly primaryKey: true;
+	readonly notNull: true;
 }, {
-    readonly name: "values";
-    readonly type: "JSON";
-    readonly notNull: true;
-    readonly defaultValue: "{}";
+	readonly name: "values";
+	readonly type: "JSON";
+	readonly notNull: true;
+	readonly defaultValue: "{}";
 }];
 export interface BlockSettingsStoreDeps {
-    readonly store: SettingsStoreClient;
+	readonly store: SettingsStoreClient;
 }
 export declare class BlockSettingsStore {
-    private readonly store;
-    constructor(deps: BlockSettingsStoreDeps);
-    static declare(store: SettingsStoreClient): Promise<void>;
-    getValues(blockId: string): Promise<Record<string, unknown>>;
-    mergeValues(blockId: string, patch: Record<string, unknown>): Promise<Record<string, unknown>>;
-    delete(blockId: string): Promise<void>;
-    private mirrorToBlockAddon;
+	private readonly store;
+	constructor(deps: BlockSettingsStoreDeps);
+	static declare(store: SettingsStoreClient): Promise<void>;
+	getValues(blockId: string): Promise<Record<string, unknown>>;
+	mergeValues(blockId: string, patch: Record<string, unknown>): Promise<Record<string, unknown>>;
+	delete(blockId: string): Promise<void>;
+	private mirrorToBlockAddon;
 }