@camstack/system 1.2.390 → 1.2.391

package/dist/kernel/array-buffer-census.d.ts

@@ -1,122 +1,118 @@
 /** One power-of-two bucket of the live set: every buffer with `byteLength <= upToBytes`
- *  and above the previous bucket. */
+*  and above the previous bucket. */
 export interface ArrayBufferSizeBucket {
-    readonly upToBytes: number;
-    readonly count: number;
-    readonly bytes: number;
+	readonly upToBytes: number;
+	readonly count: number;
+	readonly bytes: number;
 }
 /** One exact byteLength and how much of the live set it accounts for. */
 export interface ArrayBufferExactSize {
-    readonly byteLength: number;
-    readonly count: number;
-    readonly bytes: number;
+	readonly byteLength: number;
+	readonly count: number;
+	readonly bytes: number;
 }
 export interface ArrayBufferCensusReport {
-    /** Live `ArrayBuffer` objects reachable after the census's own GC. */
-    readonly count: number;
-    /** Their total `byteLength`. */
-    readonly bytes: number;
-    /** Buffers whose backing store is gone (`byteLength === 0`, detached). */
-    readonly detached: number;
-    /** Largest buckets first, by bytes. */
-    readonly buckets: readonly ArrayBufferSizeBucket[];
-    /** Largest exact sizes first, by bytes. */
-    readonly topSizes: readonly ArrayBufferExactSize[];
+	/** Live `ArrayBuffer` objects reachable after the census's own GC. */
+	readonly count: number;
+	/** Their total `byteLength`. */
+	readonly bytes: number;
+	/** Buffers whose backing store is gone (`byteLength === 0`, detached). */
+	readonly detached: number;
+	/** Largest buckets first, by bytes. */
+	readonly buckets: readonly ArrayBufferSizeBucket[];
+	/** Largest exact sizes first, by bytes. */
+	readonly topSizes: readonly ArrayBufferExactSize[];
 }
 /** Take a census. Injectable so the heartbeat's gating is testable without an inspector. */
 export type ArrayBufferCensus = () => Promise<ArrayBufferCensusReport>;
 /**
- * Take the census once `arrayBuffers` has been at or above this for
- * {@link ARRAY_BUFFER_CENSUS_SUSTAIN_MS}.
- *
- * 512 MB. The two 2026-09-10 episodes crossed it 25 and 8 minutes in; the
- * routine reading in six hours of 2-second samples around them was 18–100 MB
- * with single-sample spikes to 479 MB, and the process's floor after every
- * compaction is 12–18 MB. A dead-buffer sawtooth between major GCs (measured
- * up to 3.65 GB on 2026-08-08 when the heap had 4 GB of headroom) cannot reach
- * it while GC runs every few seconds — and if one did, the census would SAY
- * so: it reports the live total after its own GC next to the raw reading.
- */
+* Take the census once `arrayBuffers` has been at or above this for
+* {@link ARRAY_BUFFER_CENSUS_SUSTAIN_MS}.
+*
+* 512 MB. The two 2026-09-10 episodes crossed it 25 and 8 minutes in; the
+* routine reading in six hours of 2-second samples around them was 18–100 MB
+* with single-sample spikes to 479 MB, and the process's floor after every
+* compaction is 12–18 MB. A dead-buffer sawtooth between major GCs (measured
+* up to 3.65 GB on 2026-08-08 when the heap had 4 GB of headroom) cannot reach
+* it while GC runs every few seconds — and if one did, the census would SAY
+* so: it reports the live total after its own GC next to the raw reading.
+*/
 export declare const ARRAY_BUFFER_CENSUS_THRESHOLD_MB = 512;
 /**
- * How long the reading must stay above the threshold before a census is taken.
- *
- * 60 s = 30 probes at the 2 s cadence. A burst that a scavenge or the next
- * major GC returns never pays a forced GC; an episode climbing at the slowest
- * rate measured (20 MB/min) is still 20 MB higher by the time it is measured,
- * which is nothing against the threshold.
- */
-export declare const ARRAY_BUFFER_CENSUS_SUSTAIN_MS = 60000;
+* How long the reading must stay above the threshold before a census is taken.
+*
+* 60 s = 30 probes at the 2 s cadence. A burst that a scavenge or the next
+* major GC returns never pays a forced GC; an episode climbing at the slowest
+* rate measured (20 MB/min) is still 20 MB higher by the time it is measured,
+* which is nothing against the threshold.
+*/
+export declare const ARRAY_BUFFER_CENSUS_SUSTAIN_MS = 6e4;
 /**
- * Minimum spacing between two censuses.
- *
- * 30 minutes: the second episode ran 76 minutes, so it would have produced
- * three readings — enough to see the shape change (or not) as it grew — at a
- * cost the router already pays six times an hour for the reclaim pass.
- */
+* Minimum spacing between two censuses.
+*
+* 30 minutes: the second episode ran 76 minutes, so it would have produced
+* three readings — enough to see the shape change (or not) as it grew — at a
+* cost the router already pays six times an hour for the reclaim pass.
+*/
 export declare const ARRAY_BUFFER_CENSUS_COOLDOWN_MS: number;
 /**
- * A drop of at least this share of the threshold between two consecutive
- * probes, from a reading that had been SUSTAINED above the threshold, is a
- * RELEASE — the boundary both episodes crossed with no line, and the one line
- * that lets the release be correlated with whatever else the process logged
- * that second. Sustained, not merely above: a one-probe spike that the next
- * scavenge sweeps (a 1.3 GB burst in 11 s was measured on 2026-08-29) is not
- * an episode ending, and a WARN for every one of those would bury the line
- * this exists to produce.
- */
-export declare const ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO = 0.5;
+* A drop of at least this share of the threshold between two consecutive
+* probes, from a reading that had been SUSTAINED above the threshold, is a
+* RELEASE — the boundary both episodes crossed with no line, and the one line
+* that lets the release be correlated with whatever else the process logged
+* that second. Sustained, not merely above: a one-probe spike that the next
+* scavenge sweeps (a 1.3 GB burst in 11 s was measured on 2026-08-29) is not
+* an episode ending, and a WARN for every one of those would bury the line
+* this exists to produce.
+*/
+export declare const ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO = .5;
 export interface ArrayBufferCensusGateOptions {
-    readonly thresholdMb?: number;
-    readonly sustainMs?: number;
-    readonly cooldownMs?: number;
+	readonly thresholdMb?: number;
+	readonly sustainMs?: number;
+	readonly cooldownMs?: number;
 }
 /** What one probe reading means to the gate. */
 export type ArrayBufferCensusVerdict = {
-    readonly kind: 'hold';
-}
-/** Take a census now. `reason` is printed on the resulting line. */
- | {
-    readonly kind: 'take';
-    readonly reason: string;
-}
-/** The live set was released between this probe and the previous one. */
- | {
-    readonly kind: 'released';
-    readonly fromMb: number;
-    readonly toMb: number;
+	readonly kind: "hold";
+} | {
+	readonly kind: "take";
+	readonly reason: string;
+} | {
+	readonly kind: "released";
+	readonly fromMb: number;
+	readonly toMb: number;
 };
 export interface ArrayBufferCensusGate {
-    /** Judge one reading. A `take` verdict starts the cooldown. */
-    readonly observe: (arrayBuffersMb: number, at: number) => ArrayBufferCensusVerdict;
+	/** Judge one reading. A `take` verdict starts the cooldown. */
+	readonly observe: (arrayBuffersMb: number, at: number) => ArrayBufferCensusVerdict;
 }
 /**
- * The pure decision: threshold, sustain, cooldown, release — testable without
- * allocating a gigabyte or forcing a GC.
- */
+* The pure decision: threshold, sustain, cooldown, release — testable without
+* allocating a gigabyte or forcing a GC.
+*/
 export declare function createArrayBufferCensusGate(options?: ArrayBufferCensusGateOptions): ArrayBufferCensusGate;
 /** The inspector answers `unknown`; the report is trusted only once it has this shape. */
 export declare function isArrayBufferCensusReport(value: unknown): value is ArrayBufferCensusReport;
 /**
- * The real census: an in-process inspector session, opened for the call and
- * closed after it, so no session is left listening between censuses.
- *
- * Every remote object it creates is released before the session closes; a
- * failure anywhere still disconnects. The session is in-process — nothing
- * listens on a port, nothing outside this process can reach it.
- */
+* The real census: an in-process inspector session, opened for the call and
+* closed after it, so no session is left listening between censuses.
+*
+* Every remote object it creates is released before the session closes; a
+* failure anywhere still disconnects. The session is in-process — nothing
+* listens on a port, nothing outside this process can reach it.
+*/
 export declare function createInspectorArrayBufferCensus(): ArrayBufferCensus;
 /** What a census line needs beyond the report. */
 export interface ArrayBufferCensusContext {
-    /** `process.memoryUsage().arrayBuffers` at the probe that triggered it. */
-    readonly rawMb: number;
-    readonly tookMs: number;
-    /** The gate's `take` reason. */
-    readonly reason: string;
+	/** `process.memoryUsage().arrayBuffers` at the probe that triggered it. */
+	readonly rawMb: number;
+	readonly tookMs: number;
+	/** The gate's `take` reason. */
+	readonly reason: string;
 }
 /**
- * The census line. `live` is what survived the census's own GC; `raw` is the
- * reading that triggered it — when they disagree by a lot, the growth was dead
- * buffers awaiting a sweep, not a retention, and the line says which.
- */
+* The census line. `live` is what survived the census's own GC; `raw` is the
+* reading that triggered it — when they disagree by a lot, the growth was dead
+* buffers awaiting a sweep, not a retention, and the line says which.
+*/
 export declare function formatArrayBufferCensus(label: string, report: ArrayBufferCensusReport, context: ArrayBufferCensusContext): string;

package/dist/kernel/bootstrap-config.d.ts

@@ -1,8 +1,8 @@
-import { AppConfig, BootstrapConfig } from './config-schema.js';
+import { type AppConfig, type BootstrapConfig } from "./config-schema.js";
 /** config.yaml, env overrides applied, parsed. */
 export declare function loadBootstrapConfig(configPath: string): BootstrapConfig;
 export declare function writeBootstrapSection(configPath: string, section: string, data: Record<string, unknown>): BootstrapConfig;
 /**
- * Returns a merged view of bootstrap config + runtime defaults for backward compat.
- */
+* Returns a merged view of bootstrap config + runtime defaults for backward compat.
+*/
 export declare function buildRawAppConfig(bootstrapConfig: BootstrapConfig): AppConfig;

package/dist/kernel/cap-router-builder.d.ts

@@ -1,126 +1,170 @@
-import { CapabilityDefinition, CapabilityMountKind } from '@camstack/types';
 /**
- * A tRPC-procedure-like builder. Mirrors the chainable surface the
- * codegen emits (`procedure.input(...).output(...).query(...)`), kept
- * structural so the server can pass its real `protectedProcedure` /
- * `adminProcedure` / `publicProcedure` without this module importing
- * `@trpc/server` context types.
- */
+* Runtime cap-router builder (BIG PLAN 2).
+*
+* Builds the per-capability tRPC routers DYNAMICALLY at hub boot by
+* iterating `ALL_CAPABILITY_DEFINITIONS`, instead of importing the
+* statically codegen'd `createCapRouter_<Cap>` value functions baked into
+* `@camstack/server`. Moving the CONSTRUCTION here means a capability
+* update ships via the framework plugin (`@camstack/types` +
+* `@camstack/system`, live-updated together) WITHOUT a `@camstack/server`
+* image rebuild.
+*
+* Type vs value split:
+*   - The runtime VALUE is built here, generically.
+*   - The static AppRouter TYPE stays codegen'd into `@camstack/types`
+*     (`generated/addon-api.ts`) via the `generated-cap-routers.ts`
+*     per-cap router factory TYPES. The server delegation site assigns
+*     this builder's output to that static type at the single documented
+*     boundary, so the SDK keeps full procedure inference.
+*
+* The per-method procedure shape is mechanically derived from each
+* `cap.methods.*` (input zod schema + kind) + the auto-injected
+* `getStatus` / 3 settings-contribution methods (via `expandCapMethods`).
+* Provider resolution is derived from the declarative `mount` hint
+* (`resolveCapMount`) — the same decision the codegen
+* `generate-cap-mounts.ts` baked in.
+*
+* OUTPUT PASS-THROUGH (2026-07-11): unlike the historical codegen, the
+* builder deliberately does NOT apply `.output(schema)`. Re-validating an
+* output the hub does not own against the hub's OWN (framework-versioned,
+* therefore potentially stale) copy of the cap def silently STRIPS fields
+* a fresher addon added (a self-contained addon bundles its own newer
+* `@camstack/types`; the hub-closure copy lags). That is exactly how
+* `models[].group.resolution` vanished from `pipelineExecutor.getSchema`.
+* Cap dispatch is structural (CLAUDE.md invariant): the owning provider is
+* typed to return a complete `z.infer<output>` and is the SOLE authority
+* for the payload shape, so the hub forwards it verbatim. Input validation
+* is retained (`.input(...)`) — the hub still guards the client boundary.
+*
+* This module owns NO tRPC primitives of its own: `@camstack/system`
+* cannot import the server's `TrpcContext`-bound procedures. The server
+* passes them in via {@link CapRouterPrimitives} (the `t` half of the
+* `buildCapRouters(t, services)` contract), keeping the kernel free of any
+* backend coupling (self-sufficiency invariant).
+*/
+import { type CapabilityDefinition, type CapabilityMountKind } from "@camstack/types";
+/**
+* A tRPC-procedure-like builder. Mirrors the chainable surface the
+* codegen emits (`procedure.input(...).output(...).query(...)`), kept
+* structural so the server can pass its real `protectedProcedure` /
+* `adminProcedure` / `publicProcedure` without this module importing
+* `@trpc/server` context types.
+*/
 export interface ProcedureBuilder {
-    input(schema: unknown): ProcedureBuilder;
-    output(schema: unknown): ProcedureBuilder;
-    query(resolver: (opts: ProcedureResolverArgs) => unknown): unknown;
-    mutation(resolver: (opts: ProcedureResolverArgs) => unknown): unknown;
-    subscription(resolver: (opts: ProcedureResolverArgs) => unknown): unknown;
+	input(schema: unknown): ProcedureBuilder;
+	output(schema: unknown): ProcedureBuilder;
+	query(resolver: (opts: ProcedureResolverArgs) => unknown): unknown;
+	mutation(resolver: (opts: ProcedureResolverArgs) => unknown): unknown;
+	subscription(resolver: (opts: ProcedureResolverArgs) => unknown): unknown;
 }
 /** Args object tRPC hands a procedure resolver (input + ctx). */
 export interface ProcedureResolverArgs {
-    readonly input: unknown;
-    readonly ctx: unknown;
+	readonly input: unknown;
+	readonly ctx: unknown;
 }
 /** The `t`-half of `buildCapRouters(t, services)`: tRPC primitives the server owns. */
 export interface CapRouterPrimitives {
-    /** `t.router` — assembles a `Record<methodName, procedure>` into a router. */
-    readonly router: (procedures: Record<string, unknown>) => unknown;
-    /** Map of auth level → base procedure (`public`/`protected`/`admin`). */
-    readonly procedures: Readonly<Record<'public' | 'protected' | 'admin', ProcedureBuilder>>;
-    /**
-     * Wrap a push-based subscription into the async-generator tRPC v11
-     * expects. Identical to the server's `iterableSubscription`.
-     */
-    readonly iterableSubscription: <T>(subscribe: (push: (value: T) => void) => () => void) => AsyncGenerator<T>;
+	/** `t.router` — assembles a `Record<methodName, procedure>` into a router. */
+	readonly router: (procedures: Record<string, unknown>) => unknown;
+	/** Map of auth level → base procedure (`public`/`protected`/`admin`). */
+	readonly procedures: Readonly<Record<"public" | "protected" | "admin", ProcedureBuilder>>;
+	/**
+	* Wrap a push-based subscription into the async-generator tRPC v11
+	* expects. Identical to the server's `iterableSubscription`.
+	*/
+	readonly iterableSubscription: <T>(subscribe: (push: (value: T) => void) => () => void) => AsyncGenerator<T>;
 }
 /** A method the runtime can call on a resolved provider object. */
 type ProviderMethod = (input?: unknown, push?: (value: unknown) => void) => unknown;
 type ResolvedProvider = Readonly<Record<string, ProviderMethod>>;
 /**
- * Per-cap provider getter. `addonId` is only consulted for collection
- * caps (selects a specific provider within the local collection); the
- * server's `services`-backed resolution lives behind this closure so the
- * builder never touches the registry or backend services directly.
- */
+* Per-cap provider getter. `addonId` is only consulted for collection
+* caps (selects a specific provider within the local collection); the
+* server's `services`-backed resolution lives behind this closure so the
+* builder never touches the registry or backend services directly.
+*/
 export type CapProviderGetter = (ctx: unknown, addonId?: string) => ResolvedProvider | null;
 /** Cross-node proxy factory — Moleculer-bridged provider for a remote node. */
 export type RemoteProxyFactory = (capName: string, nodeId: string) => ResolvedProvider | null;
 /**
- * Everything the builder needs from the server to resolve a cap's
- * provider object. The server supplies these closures; the builder owns
- * the procedure shape + routing decision.
- */
+* Everything the builder needs from the server to resolve a cap's
+* provider object. The server supplies these closures; the builder owns
+* the procedure shape + routing decision.
+*/
 export interface CapRouterServices {
-    /**
-     * Resolve the LOCAL provider for a cap given the effective mount kind.
-     * Returns null on miss (the procedure surfaces PRECONDITION_FAILED).
-     * For `server-provided` caps this calls the server-supplied service
-     * provider factory; for `singleton` / `device-native` / `collection`
-     * it goes through the registry.
-     */
-    readonly getLocalProvider: (capName: string, mountKind: CapabilityMountKind, ctx: unknown, addonId?: string) => ResolvedProvider | null;
-    /** Cross-node Moleculer-bridged proxy. */
-    readonly remoteProxy: RemoteProxyFactory;
-    /** Raise the canonical "no provider" tRPC error (server owns TRPCError). */
-    readonly noProvider: (capName: string, nodeId?: string) => never;
-    /** Raise the canonical "node routing unavailable" tRPC error. */
-    readonly noNodeRouting: (capName: string) => never;
-    /** Raise the canonical "bad request: missing field" error. */
-    readonly badRequest: (message: string) => never;
-    /**
-     * Raise the canonical UNAUTHORIZED error — used by `caller: 'required'`
-     * methods when the context carries no authenticated user. OPTIONAL for
-     * framework-live-update version skew (an older server may hand a
-     * services object without it to a newer builder); the builder falls
-     * back to `badRequest` in that case so the call still fails closed.
-     */
-    readonly unauthorized?: (message: string) => never;
-    /**
-     * Called when an EXPLICIT top-level `{ addonId }` collection pin resolved to
-     * no local provider, BEFORE the hub-proxy fallthrough. Implementations throw
-     * (naming the id and enumerating the valid ones) when the cap has providers
-     * registered and none of them matches; they return normally when the cap has
-     * no local providers at all, which is the legitimate "the cap lives in a
-     * forked hub worker" case the fallthrough exists for.
-     *
-     * Why: without this the pin was simply DROPPED. `getLocalProvider` returned
-     * null for an unknown addonId, which reads identically to "not resident on
-     * the hub root", so the call fell through to `remoteProxy(cap, 'hub')` and
-     * the Moleculer prefix lookup answered from the FIRST hub-side provider.
-     * `deviceExport.getStatus { addonId: 'questo-non-esiste-affatto' }` returned
-     * Alexa's `linked / 3` — the caller could not tell it had been misrouted
-     * (2026-08-09). OPTIONAL for framework-live-update version skew: an older
-     * server hands a services object without it and the builder keeps the old
-     * fallthrough rather than crashing.
-     */
-    readonly rejectUnresolvedAddonPin?: (capName: string, addonId: string) => void;
-    /**
-     * Raise the canonical error for a resolved provider that does NOT
-     * implement `method` (Task 7.5d). Before this existed the router called
-     * `provider[method.name]?.(payload)` — an optional call that let a missing
-     * method answer `undefined`, which tRPC serializes as a 200. The UDS child
-     * dispatcher (`child-cap-dispatch.ts`) hits the SAME condition (a provider
-     * missing a method) and THROWS; two authorities disagreeing about the same
-     * defect is worse than either alone, and the hub's silence is the one a
-     * caller cannot detect. OPTIONAL for framework-live-update version skew: an
-     * older server hands a services object without it; the builder falls back
-     * to `badRequest` so the call still fails closed instead of answering 200.
-     */
-    readonly methodNotFound?: (capName: string, method: string) => never;
+	/**
+	* Resolve the LOCAL provider for a cap given the effective mount kind.
+	* Returns null on miss (the procedure surfaces PRECONDITION_FAILED).
+	* For `server-provided` caps this calls the server-supplied service
+	* provider factory; for `singleton` / `device-native` / `collection`
+	* it goes through the registry.
+	*/
+	readonly getLocalProvider: (capName: string, mountKind: CapabilityMountKind, ctx: unknown, addonId?: string) => ResolvedProvider | null;
+	/** Cross-node Moleculer-bridged proxy. */
+	readonly remoteProxy: RemoteProxyFactory;
+	/** Raise the canonical "no provider" tRPC error (server owns TRPCError). */
+	readonly noProvider: (capName: string, nodeId?: string) => never;
+	/** Raise the canonical "node routing unavailable" tRPC error. */
+	readonly noNodeRouting: (capName: string) => never;
+	/** Raise the canonical "bad request: missing field" error. */
+	readonly badRequest: (message: string) => never;
+	/**
+	* Raise the canonical UNAUTHORIZED error — used by `caller: 'required'`
+	* methods when the context carries no authenticated user. OPTIONAL for
+	* framework-live-update version skew (an older server may hand a
+	* services object without it to a newer builder); the builder falls
+	* back to `badRequest` in that case so the call still fails closed.
+	*/
+	readonly unauthorized?: (message: string) => never;
+	/**
+	* Called when an EXPLICIT top-level `{ addonId }` collection pin resolved to
+	* no local provider, BEFORE the hub-proxy fallthrough. Implementations throw
+	* (naming the id and enumerating the valid ones) when the cap has providers
+	* registered and none of them matches; they return normally when the cap has
+	* no local providers at all, which is the legitimate "the cap lives in a
+	* forked hub worker" case the fallthrough exists for.
+	*
+	* Why: without this the pin was simply DROPPED. `getLocalProvider` returned
+	* null for an unknown addonId, which reads identically to "not resident on
+	* the hub root", so the call fell through to `remoteProxy(cap, 'hub')` and
+	* the Moleculer prefix lookup answered from the FIRST hub-side provider.
+	* `deviceExport.getStatus { addonId: 'questo-non-esiste-affatto' }` returned
+	* Alexa's `linked / 3` — the caller could not tell it had been misrouted
+	* (2026-08-09). OPTIONAL for framework-live-update version skew: an older
+	* server hands a services object without it and the builder keeps the old
+	* fallthrough rather than crashing.
+	*/
+	readonly rejectUnresolvedAddonPin?: (capName: string, addonId: string) => void;
+	/**
+	* Raise the canonical error for a resolved provider that does NOT
+	* implement `method` (Task 7.5d). Before this existed the router called
+	* `provider[method.name]?.(payload)` — an optional call that let a missing
+	* method answer `undefined`, which tRPC serializes as a 200. The UDS child
+	* dispatcher (`child-cap-dispatch.ts`) hits the SAME condition (a provider
+	* missing a method) and THROWS; two authorities disagreeing about the same
+	* defect is worse than either alone, and the hub's silence is the one a
+	* caller cannot detect. OPTIONAL for framework-live-update version skew: an
+	* older server hands a services object without it; the builder falls back
+	* to `badRequest` so the call still fails closed instead of answering 200.
+	*/
+	readonly methodNotFound?: (capName: string, method: string) => never;
 }
 /**
- * Build a single capability's router (the runtime equivalent of one
- * codegen'd `createCapRouter_<Cap>`). Each method becomes a typed
- * procedure with the SAME routing branch the codegen emits.
- *
- * Exported for the caller-injection spec (which drives it with synthetic
- * cap defs) — production callers go through {@link buildCapRouters}.
- */
+* Build a single capability's router (the runtime equivalent of one
+* codegen'd `createCapRouter_<Cap>`). Each method becomes a typed
+* procedure with the SAME routing branch the codegen emits.
+*
+* Exported for the caller-injection spec (which drives it with synthetic
+* cap defs) — production callers go through {@link buildCapRouters}.
+*/
 export declare function buildOneCapRouter(def: CapabilityDefinition, primitives: CapRouterPrimitives, services: CapRouterServices): unknown;
 /**
- * Build the runtime cap-router map: `{ <camelCapName>: <router> }` for
- * every capability the builder owns. Caps with `mount.kind` `custom` /
- * `skip` are omitted (the server overrides / never mounts them). The
- * server spreads this BEFORE its hand-written overrides + core routers so
- * override-by-spread precedence is preserved.
- */
+* Build the runtime cap-router map: `{ <camelCapName>: <router> }` for
+* every capability the builder owns. Caps with `mount.kind` `custom` /
+* `skip` are omitted (the server overrides / never mounts them). The
+* server spreads this BEFORE its hand-written overrides + core routers so
+* override-by-spread precedence is preserved.
+*/
 export declare function buildCapRouters(primitives: CapRouterPrimitives, services: CapRouterServices): Record<string, unknown>;
 /** The set of cap camelNames the builder owns (for drift checks / tests). */
 export declare function builderMountedCapNames(): readonly string[];

package/dist/kernel/capability-handle.d.ts

@@ -1,46 +1,46 @@
-import { ReadinessRegistry, ReadinessScope, ICapabilityHandle } from '@camstack/types';
+import type { ReadinessRegistry, ReadinessScope, ICapabilityHandle } from "@camstack/types";
 export declare class CapabilityUnavailableError extends Error {
-    readonly capName: string;
-    readonly scope: ReadinessScope;
-    readonly timeoutMs: number;
-    constructor(capName: string, scope: ReadinessScope, timeoutMs: number);
+	readonly capName: string;
+	readonly scope: ReadinessScope;
+	readonly timeoutMs: number;
+	constructor(capName: string, scope: ReadinessScope, timeoutMs: number);
 }
 /**
- * A stable reference to a capability that tracks its readiness state and
- * gates calls on that state.
- *
- * Obtained via `ctx.useCapability()` (non-blocking) or `ctx.acquireCapability()`
- * (blocks until the cap is ready). The handle is cached per `(capName, scope)` in
- * AddonContextImpl so repeated calls return the same instance.
- *
- * The generic `T` is a phantom type documenting the expected provider interface;
- * the handle itself does not expose a typed proxy surface in v1.
- */
+* A stable reference to a capability that tracks its readiness state and
+* gates calls on that state.
+*
+* Obtained via `ctx.useCapability()` (non-blocking) or `ctx.acquireCapability()`
+* (blocks until the cap is ready). The handle is cached per `(capName, scope)` in
+* AddonContextImpl so repeated calls return the same instance.
+*
+* The generic `T` is a phantom type documenting the expected provider interface;
+* the handle itself does not expose a typed proxy surface in v1.
+*/
 export declare class CapabilityHandle<T = unknown> implements ICapabilityHandle<T> {
-    readonly capName: string;
-    readonly scope: ReadinessScope;
-    private readonly registry;
-    readonly defaultTimeoutMs: number;
-    private state;
-    private readonly unsubscribeReadiness;
-    constructor(capName: string, scope: ReadinessScope, registry: ReadinessRegistry, defaultTimeoutMs: number);
-    get isReady(): boolean;
-    /**
-     * Block until the capability is ready, or throw `CapabilityUnavailableError`
-     * if it does not become ready within `timeoutMs`.
-     */
-    awaitReady(timeoutMs?: number): Promise<void>;
-    /**
-     * Execute `fn` with readiness gating: if the cap is not ready, blocks
-     * until it becomes ready (or throws CapabilityUnavailableError on timeout),
-     * then calls `fn`.
-     *
-     * Preferred over calling awaitReady() + fn() separately because it
-     * re-gates after a down→ready transition that happens between the
-     * await and the call.
-     */
-    call<R>(fn: () => Promise<R>, timeoutMs?: number): Promise<R>;
-    /** Unsubscribe from ReadinessRegistry. Called by AddonContextImpl on shutdown. */
-    dispose(): void;
-    readonly _provider: T;
+	readonly capName: string;
+	readonly scope: ReadinessScope;
+	private readonly registry;
+	readonly defaultTimeoutMs: number;
+	private state;
+	private readonly unsubscribeReadiness;
+	constructor(capName: string, scope: ReadinessScope, registry: ReadinessRegistry, defaultTimeoutMs: number);
+	get isReady(): boolean;
+	/**
+	* Block until the capability is ready, or throw `CapabilityUnavailableError`
+	* if it does not become ready within `timeoutMs`.
+	*/
+	awaitReady(timeoutMs?: number): Promise<void>;
+	/**
+	* Execute `fn` with readiness gating: if the cap is not ready, blocks
+	* until it becomes ready (or throws CapabilityUnavailableError on timeout),
+	* then calls `fn`.
+	*
+	* Preferred over calling awaitReady() + fn() separately because it
+	* re-gates after a down→ready transition that happens between the
+	* await and the call.
+	*/
+	call<R>(fn: () => Promise<R>, timeoutMs?: number): Promise<R>;
+	/** Unsubscribe from ReadinessRegistry. Called by AddonContextImpl on shutdown. */
+	dispose(): void;
+	readonly _provider: T;
 }