@camstack/system 1.2.389 → 1.2.391

package/dist/kernel/lifecycle/lifecycle-job-engine.d.ts

@@ -1,106 +1,106 @@
-import { JobJournal } from './job-journal.js';
-import { StagingArea } from './staging-area.js';
-import { LifecycleJob, TaskLogEntry } from '@camstack/types';
+import type { JobJournal } from "./job-journal.js";
+import type { StagingArea } from "./staging-area.js";
+import type { LifecycleJob, TaskLogEntry } from "@camstack/types";
 export type ApplyAddonUpdateFn = (input: {
-    name: string;
-    version: string;
-    stagedPath: string;
+	name: string;
+	version: string;
+	stagedPath: string;
 }) => Promise<void>;
-export type EmitFn = (kind: 'progress' | 'log', job: LifecycleJob, entry?: TaskLogEntry) => void;
+export type EmitFn = (kind: "progress" | "log", job: LifecycleJob, entry?: TaskLogEntry) => void;
 interface Deps {
-    readonly journal: JobJournal;
-    readonly staging: StagingArea;
-    readonly applyAddonUpdate: ApplyAddonUpdateFn;
-    readonly emit: EmitFn;
-    readonly now: () => number;
-    readonly fetchTimeoutMs?: number;
-    readonly fetchConcurrency?: number;
-    /**
-     * Predicate used by `reconcileJob` to decide whether a task's recorded
-     * `stagedPath` directory still exists on disk (so apply can reuse it instead
-     * of re-fetching). Defaults to `fs.existsSync`.
-     */
-    readonly stagedPathExists?: (p: string) => boolean;
+	readonly journal: JobJournal;
+	readonly staging: StagingArea;
+	readonly applyAddonUpdate: ApplyAddonUpdateFn;
+	readonly emit: EmitFn;
+	readonly now: () => number;
+	readonly fetchTimeoutMs?: number;
+	readonly fetchConcurrency?: number;
+	/**
+	* Predicate used by `reconcileJob` to decide whether a task's recorded
+	* `stagedPath` directory still exists on disk (so apply can reuse it instead
+	* of re-fetching). Defaults to `fs.existsSync`.
+	*/
+	readonly stagedPathExists?: (p: string) => boolean;
 }
 export declare class LifecycleJobEngine {
-    private readonly deps;
-    constructor(deps: Deps);
-    private advance;
-    /**
-     * Fetch + stage a single addon task (advancing it to `staged`), wrapped in a
-     * per-task abort timeout. On success the resolved `stagedPath` is returned; on
-     * failure the task is marked `failed` and `null` is returned (so the apply
-     * phase skips it). Other tasks are unaffected.
-     *
-     * **`toVersion` is REWRITTEN here, to the version that was actually
-     * fetched.** A task's `toVersion` starts as the REQUEST, and the request is
-     * routinely a dist-tag: `addons.updatePackage` with no version resolves to
-     * the literal `'latest'`. The staging area already resolves it — it reads
-     * the version out of the unpacked tarball and returns `resolvedVersion` —
-     * and dropping that answer sent the string `'latest'` onward as if it were a
-     * version. It became the manifest's recorded version, the version the Addons
-     * page displayed, and the `toVersion` on the `addon.updated` event, which an
-     * operator read on his phone as "@camstack/addon-terminal 0.0.0 → latest"
-     * (2026-08-30). Everything downstream of the apply reads a version; none of
-     * it can resolve a tag, and none of it could tell that it had been handed
-     * one.
-     */
-    private fetchAddonTask;
-    /**
-     * Apply a single already-staged addon task serially:
-     * `validating` → `applying` → applyAddonUpdate → `restarting` → `done`.
-     * Returns true on success, false if the apply throws (task marked `failed`).
-     */
-    private applyAddonTask;
-    /**
-     * Mark a framework task `skipped`.
-     *
-     * Framework packages (`@camstack/system` + its lockstep companions) are NO
-     * LONGER updated through this engine. The legacy `/data/framework` per-package
-     * swap was removed in the single-copy framework collapse (2026-07-18) — the
-     * running framework is loaded from the active server-root single copy, and
-     * framework/cap updates now ship EXCLUSIVELY via `applyServerUpdate` (the
-     * node-root ServerUpdateService). Any framework task that still reaches this
-     * engine (e.g. an "Update all" bulk job that swept `@camstack/system`) is
-     * skipped, never applied — applying it would swap a dead dir.
-     */
-    private skipFrameworkTask;
-    /**
-     * Run the addon fetch phase with a bounded-concurrency worker pool. At most
-     * `fetchConcurrency` fetches are in flight at once; completion order may vary
-     * but the returned outcomes preserve the input task order.
-     */
-    private fetchAddonsBounded;
-    /**
-     * §10 boot reconcile: re-drive every NON-TERMINAL addon task of a job that
-     * was interrupted mid-flight (e.g. a crash) from its on-disk checkpoint.
-     *
-     * Framework tasks are NOT applied by this engine (single-copy collapse —
-     * framework updates ship via `applyServerUpdate`). Any stray non-terminal
-     * framework task is marked `skipped` so the interrupted job can finalize
-     * instead of hanging `running` forever. Terminal addon tasks
-     * (`done`/`failed`/`skipped`) are left as-is.
-     *
-     * Apply is idempotent (`applyAddonUpdate` backs up the live dir + restores on
-     * failure), so every non-terminal addon phase collapses to:
-     *   ensure staged (reuse a still-valid `stagedPath` or re-fetch) → apply → done;
-     *   on failure → `failed`.
-     */
-    reconcileJob(job: LifecycleJob): Promise<LifecycleJob>;
-    private isTerminal;
-    /**
-     * Re-drive a single non-terminal addon task: reuse a still-valid `stagedPath`
-     * when present (idempotent re-apply), otherwise re-fetch + stage, then apply.
-     */
-    private reconcileAddonTask;
-    /**
-     * Finalize a reconciled job: `completed` if all addon tasks succeeded,
-     * `failed` if all failed, `partially-failed` if mixed. A skipped framework
-     * task counts as neither success nor failure. Defensive: if a task is still
-     * non-terminal (should not happen — reconcile drives every task terminal),
-     * leave the job `running` and do not clean staging.
-     */
-    private finalizeReconciledJob;
-    runJob(job: LifecycleJob): Promise<LifecycleJob>;
+	private readonly deps;
+	constructor(deps: Deps);
+	private advance;
+	/**
+	* Fetch + stage a single addon task (advancing it to `staged`), wrapped in a
+	* per-task abort timeout. On success the resolved `stagedPath` is returned; on
+	* failure the task is marked `failed` and `null` is returned (so the apply
+	* phase skips it). Other tasks are unaffected.
+	*
+	* **`toVersion` is REWRITTEN here, to the version that was actually
+	* fetched.** A task's `toVersion` starts as the REQUEST, and the request is
+	* routinely a dist-tag: `addons.updatePackage` with no version resolves to
+	* the literal `'latest'`. The staging area already resolves it — it reads
+	* the version out of the unpacked tarball and returns `resolvedVersion` —
+	* and dropping that answer sent the string `'latest'` onward as if it were a
+	* version. It became the manifest's recorded version, the version the Addons
+	* page displayed, and the `toVersion` on the `addon.updated` event, which an
+	* operator read on his phone as "@camstack/addon-terminal 0.0.0 → latest"
+	* (2026-08-30). Everything downstream of the apply reads a version; none of
+	* it can resolve a tag, and none of it could tell that it had been handed
+	* one.
+	*/
+	private fetchAddonTask;
+	/**
+	* Apply a single already-staged addon task serially:
+	* `validating` → `applying` → applyAddonUpdate → `restarting` → `done`.
+	* Returns true on success, false if the apply throws (task marked `failed`).
+	*/
+	private applyAddonTask;
+	/**
+	* Mark a framework task `skipped`.
+	*
+	* Framework packages (`@camstack/system` + its lockstep companions) are NO
+	* LONGER updated through this engine. The legacy `/data/framework` per-package
+	* swap was removed in the single-copy framework collapse (2026-07-18) — the
+	* running framework is loaded from the active server-root single copy, and
+	* framework/cap updates now ship EXCLUSIVELY via `applyServerUpdate` (the
+	* node-root ServerUpdateService). Any framework task that still reaches this
+	* engine (e.g. an "Update all" bulk job that swept `@camstack/system`) is
+	* skipped, never applied — applying it would swap a dead dir.
+	*/
+	private skipFrameworkTask;
+	/**
+	* Run the addon fetch phase with a bounded-concurrency worker pool. At most
+	* `fetchConcurrency` fetches are in flight at once; completion order may vary
+	* but the returned outcomes preserve the input task order.
+	*/
+	private fetchAddonsBounded;
+	/**
+	* §10 boot reconcile: re-drive every NON-TERMINAL addon task of a job that
+	* was interrupted mid-flight (e.g. a crash) from its on-disk checkpoint.
+	*
+	* Framework tasks are NOT applied by this engine (single-copy collapse —
+	* framework updates ship via `applyServerUpdate`). Any stray non-terminal
+	* framework task is marked `skipped` so the interrupted job can finalize
+	* instead of hanging `running` forever. Terminal addon tasks
+	* (`done`/`failed`/`skipped`) are left as-is.
+	*
+	* Apply is idempotent (`applyAddonUpdate` backs up the live dir + restores on
+	* failure), so every non-terminal addon phase collapses to:
+	*   ensure staged (reuse a still-valid `stagedPath` or re-fetch) → apply → done;
+	*   on failure → `failed`.
+	*/
+	reconcileJob(job: LifecycleJob): Promise<LifecycleJob>;
+	private isTerminal;
+	/**
+	* Re-drive a single non-terminal addon task: reuse a still-valid `stagedPath`
+	* when present (idempotent re-apply), otherwise re-fetch + stage, then apply.
+	*/
+	private reconcileAddonTask;
+	/**
+	* Finalize a reconciled job: `completed` if all addon tasks succeeded,
+	* `failed` if all failed, `partially-failed` if mixed. A skipped framework
+	* task counts as neither success nor failure. Defensive: if a task is still
+	* non-terminal (should not happen — reconcile drives every task terminal),
+	* leave the job `running` and do not clean staging.
+	*/
+	private finalizeReconciledJob;
+	runJob(job: LifecycleJob): Promise<LifecycleJob>;
 }
 export {};

package/dist/kernel/lifecycle/staging-area.d.ts

@@ -1,31 +1,31 @@
 export type TarballFetcher = (name: string, version: string, signal: AbortSignal) => Promise<Buffer>;
 export type ExtractFn = (tgz: Buffer, destDir: string) => Promise<void>;
 interface StagingAreaDeps {
-    readonly fetchTarball: TarballFetcher;
-    readonly extract: ExtractFn;
+	readonly fetchTarball: TarballFetcher;
+	readonly extract: ExtractFn;
 }
 interface FetchAndStageInput {
-    readonly jobId: string;
-    readonly name: string;
-    readonly version: string;
-    readonly signal: AbortSignal;
+	readonly jobId: string;
+	readonly name: string;
+	readonly version: string;
+	readonly signal: AbortSignal;
 }
 export declare class StagingArea {
-    private readonly stagingDir;
-    private readonly deps;
-    constructor(stagingDir: string, deps: StagingAreaDeps);
-    fetchAndStage(input: FetchAndStageInput): Promise<{
-        stagedPath: string;
-        resolvedVersion: string;
-    }>;
-    cleanup(jobId: string): void;
-    /**
-     * Remove every staged dir under `stagingDir`. Safe — and meant — to run once
-     * at boot: `cleanup(jobId)` only fires when a lifecycle job finishes, so a
-     * restart (or crash) that interrupts a job mid-flight leaves its
-     * `<stagingDir>/<jobId>/` behind forever. At boot no job is in flight, so any
-     * entry present is an orphan. Returns the number of orphan dirs removed.
-     */
-    sweepOrphans(): number;
+	private readonly stagingDir;
+	private readonly deps;
+	constructor(stagingDir: string, deps: StagingAreaDeps);
+	fetchAndStage(input: FetchAndStageInput): Promise<{
+		stagedPath: string;
+		resolvedVersion: string;
+	}>;
+	cleanup(jobId: string): void;
+	/**
+	* Remove every staged dir under `stagingDir`. Safe — and meant — to run once
+	* at boot: `cleanup(jobId)` only fires when a lifecycle job finishes, so a
+	* restart (or crash) that interrupts a job mid-flight leaves its
+	* `<stagingDir>/<jobId>/` behind forever. At boot no job is in flight, so any
+	* entry present is an orphan. Returns the number of orphan dirs removed.
+	*/
+	sweepOrphans(): number;
 }
 export {};

package/dist/kernel/moleculer/addon-context-factory.d.ts

@@ -1,103 +1,104 @@
-import { ServiceBroker } from 'moleculer';
-import { InternalAddonContext, AddonDeclaration, IStorageProvider, IScopedLogger, IClusterBroker, StorageLocationDeclaration } from '@camstack/types';
-import { DeviceRegistry } from '../device-registry.js';
-import { CapabilityRegistry } from '../capability-registry.js';
-import { CapCallInput } from '../transport/index.js';
-import { LocalChildClient } from '../transport/local-child-client.js';
-import { DataPlaneSink } from './addon-data-plane-facility.js';
-import { getBrokerEventBus, registerEventBusService, setNodeEventInterest, getMoleculerEventStats, subscribePassthrough, clusterEventTopic, EVENT_TOPIC_PREFIX, MoleculerEventStats } from './event-bus.js';
-import { createRunnerLogger, setHubConnected, ___resetHubConnectedForTests, ___createRemoteLoggerForTests } from './remote-logger.js';
-import { withAddonScope, setPreferredProvider, ___resetBindingSubscriptionForTests } from './provider-registry.js';
+import type { ServiceBroker } from "moleculer";
+import type { InternalAddonContext, AddonDeclaration, IStorageProvider, IScopedLogger, IClusterBroker, StorageLocationDeclaration } from "@camstack/types";
+import { DeviceRegistry } from "../device-registry.js";
+import type { CapabilityRegistry } from "../capability-registry.js";
+import type { CapCallInput } from "../transport/index.js";
+import type { LocalChildClient } from "../transport/local-child-client.js";
+import { type DataPlaneSink } from "./addon-data-plane-facility.js";
+import { getBrokerEventBus, registerEventBusService, setNodeEventInterest, getMoleculerEventStats, subscribePassthrough, clusterEventTopic, EVENT_TOPIC_PREFIX } from "./event-bus.js";
+import type { MoleculerEventStats } from "./event-bus.js";
+import { createRunnerLogger, setHubConnected, __resetHubConnectedForTests, __createRemoteLoggerForTests } from "./remote-logger.js";
+import { withAddonScope, setPreferredProvider, __resetBindingSubscriptionForTests } from "./provider-registry.js";
 /**
- * Adapt a Moleculer ServiceBroker to the camstack-types `IClusterBroker`
- * structural interface so addons can consume cluster-level RPC without
- * pulling a moleculer dependency. Method signatures differ slightly
- * (Moleculer's overloads are wider than the camstack contract), so we
- * forward through a thin object instead of casting at the boundary.
- */
+* Adapt a Moleculer ServiceBroker to the camstack-types `IClusterBroker`
+* structural interface so addons can consume cluster-level RPC without
+* pulling a moleculer dependency. Method signatures differ slightly
+* (Moleculer's overloads are wider than the camstack contract), so we
+* forward through a thin object instead of casting at the boundary.
+*/
 declare function adaptBrokerToCluster(broker: ServiceBroker): IClusterBroker;
 /**
- * Expose the per-process worker device registry so the process-runner can
- * mount the `device-ops-bridge` Moleculer service on top of the same live
- * IDevice instances that `createBrokerDeviceManagerApi` writes to.
- *
- * Hub-side contexts also share this module, but they pass their own
- * `opts.deviceRegistry` explicitly — nothing hub-side uses this accessor.
- */
+* Expose the per-process worker device registry so the process-runner can
+* mount the `device-ops-bridge` Moleculer service on top of the same live
+* IDevice instances that `createBrokerDeviceManagerApi` writes to.
+*
+* Hub-side contexts also share this module, but they pass their own
+* `opts.deviceRegistry` explicitly — nothing hub-side uses this accessor.
+*/
 export declare function getWorkerDeviceRegistry(): DeviceRegistry;
 /**
- * Options for enriching the addon context with infrastructure providers.
- * When the agent boots with core addons (storage, settings-store),
- * pass them here so deployed addons get full capabilities.
- */
+* Options for enriching the addon context with infrastructure providers.
+* When the agent boots with core addons (storage, settings-store),
+* pass them here so deployed addons get full capabilities.
+*/
 interface AddonContextOptions {
-    readonly storageProvider?: IStorageProvider;
-    readonly addonConfig?: Record<string, unknown>;
-    /** Custom logger factory — when set, overrides the default remote logger */
-    readonly createLogger?: (addonId: string) => IScopedLogger;
-    /**
-     * Hub `CapabilityRegistry`. When set, the `DeviceManagerApi` created
-     * for this context wires `DeviceContext.registerNativeCap` through it
-     * so device-driver addons can publish per-device native capability
-     * providers. Forked-worker processes don't carry a CapabilityRegistry,
-     * so this field is left undefined there — `registerNativeCap` becomes
-     * unavailable on workers, which throw at runtime if called.
-     */
-    readonly capabilityRegistry?: CapabilityRegistry;
-    /**
-     * UDS egress function for child→parent cap calls. When provided,
-     * `ipcParentLink` is inserted between `localProviderLink` and
-     * `brokerTransportLink` so addon-runner cap calls route over UDS
-     * instead of through Moleculer when the parent owns the target cap.
-     *
-     * Returns `null` when the UDS channel is not yet connected (before
-     * `LocalChildClient.start()` resolves), in which case `ipcParentLink`
-     * no-ops and the call falls through to `brokerTransportLink`.
-     *
-     * Hub-side contexts omit this option; their link chain is unchanged.
-     */
-    readonly getParentCallOut?: () => ((input: CapCallInput) => Promise<unknown>) | null;
-    /**
-     * Where this context's `ctx.dataPlane` publishes its live HTTP data-plane
-     * endpoints. The forked addon-runner passes a sink writing into a per-addonId
-     * map the hub pulls (`target: 'data-planes'`); the hub passes a sink writing
-     * straight into its `DataPlaneRegistry` for co-located addons. Omitted → the
-     * facility still serves locally but nothing advertises it (tests/isolation).
-     */
-    readonly dataPlaneSink?: DataPlaneSink;
-    /**
-     * Per-addon storage-location declarations (one inner array per addon's
-     * `camstack.addons[].storageLocations`). Surfaced on
-     * `ctx.kernel.listStorageLocationDeclarations` so the storage-orchestrator
-     * can seed the default locations (`addons-data:default`, …) on this node.
-     *
-     * The hub wires this from its AddonRegistry; agents/forked workers (which
-     * build their context through this factory) MUST pass it too, or the
-     * orchestrator seeds nothing and `sqlite-settings` aborts boot with
-     * "No default storage location configured for type addons-data".
-     */
-    readonly listStorageLocationDeclarations?: () => StorageLocationDeclaration[][];
+	readonly storageProvider?: IStorageProvider;
+	readonly addonConfig?: Record<string, unknown>;
+	/** Custom logger factory — when set, overrides the default remote logger */
+	readonly createLogger?: (addonId: string) => IScopedLogger;
+	/**
+	* Hub `CapabilityRegistry`. When set, the `DeviceManagerApi` created
+	* for this context wires `DeviceContext.registerNativeCap` through it
+	* so device-driver addons can publish per-device native capability
+	* providers. Forked-worker processes don't carry a CapabilityRegistry,
+	* so this field is left undefined there — `registerNativeCap` becomes
+	* unavailable on workers, which throw at runtime if called.
+	*/
+	readonly capabilityRegistry?: CapabilityRegistry;
+	/**
+	* UDS egress function for child→parent cap calls. When provided,
+	* `ipcParentLink` is inserted between `localProviderLink` and
+	* `brokerTransportLink` so addon-runner cap calls route over UDS
+	* instead of through Moleculer when the parent owns the target cap.
+	*
+	* Returns `null` when the UDS channel is not yet connected (before
+	* `LocalChildClient.start()` resolves), in which case `ipcParentLink`
+	* no-ops and the call falls through to `brokerTransportLink`.
+	*
+	* Hub-side contexts omit this option; their link chain is unchanged.
+	*/
+	readonly getParentCallOut?: () => ((input: CapCallInput) => Promise<unknown>) | null;
+	/**
+	* Where this context's `ctx.dataPlane` publishes its live HTTP data-plane
+	* endpoints. The forked addon-runner passes a sink writing into a per-addonId
+	* map the hub pulls (`target: 'data-planes'`); the hub passes a sink writing
+	* straight into its `DataPlaneRegistry` for co-located addons. Omitted → the
+	* facility still serves locally but nothing advertises it (tests/isolation).
+	*/
+	readonly dataPlaneSink?: DataPlaneSink;
+	/**
+	* Per-addon storage-location declarations (one inner array per addon's
+	* `camstack.addons[].storageLocations`). Surfaced on
+	* `ctx.kernel.listStorageLocationDeclarations` so the storage-orchestrator
+	* can seed the default locations (`addons-data:default`, …) on this node.
+	*
+	* The hub wires this from its AddonRegistry; agents/forked workers (which
+	* build their context through this factory) MUST pass it too, or the
+	* orchestrator seeds nothing and `sqlite-settings` aborts boot with
+	* "No default storage location configured for type addons-data".
+	*/
+	readonly listStorageLocationDeclarations?: () => StorageLocationDeclaration[][];
 }
 /**
- * Broker-mode entry point — UNCHANGED public signature. The hub
- * (`addon-registry.service.ts`), the agent (`agent-bootstrap.ts`), and
- * every broker-mode test call this with a positional `ServiceBroker`.
- */
+* Broker-mode entry point — UNCHANGED public signature. The hub
+* (`addon-registry.service.ts`), the agent (`agent-bootstrap.ts`), and
+* every broker-mode test call this with a positional `ServiceBroker`.
+*/
 declare function createAddonContext(broker: ServiceBroker, declaration: AddonDeclaration, dataDir: string, options?: AddonContextOptions): Promise<InternalAddonContext>;
 /**
- * UDS-mode entry point — for a broker-less forked `addon-runner` child
- * (Phase F1+F2). Logger/eventBus/readiness ride the UDS channel; the tRPC
- * link chain is `[localProviderLink, ipcParentLink]` (no broker, so no
- * `brokerTransportLink`). `getParentCallOut` is implied by the client and
- * wired automatically — callers MUST NOT pass it in `options`.
- */
+* UDS-mode entry point — for a broker-less forked `addon-runner` child
+* (Phase F1+F2). Logger/eventBus/readiness ride the UDS channel; the tRPC
+* link chain is `[localProviderLink, ipcParentLink]` (no broker, so no
+* `brokerTransportLink`). `getParentCallOut` is implied by the client and
+* wired automatically — callers MUST NOT pass it in `options`.
+*/
 declare function createUdsAddonContext(client: LocalChildClient, nodeId: string, declaration: AddonDeclaration, dataDir: string, options?: AddonContextOptions): Promise<InternalAddonContext>;
 /**
- * Drain (and forget) the disposer chain for a worker-side addon. Idempotent:
- * subsequent calls are no-ops. Called by process-runner / group-runner
- * before reload or graceful shutdown so resources clean up before the
- * next addon instance loads.
- */
+* Drain (and forget) the disposer chain for a worker-side addon. Idempotent:
+* subsequent calls are no-ops. Called by process-runner / group-runner
+* before reload or graceful shutdown so resources clean up before the
+* next addon instance loads.
+*/
 declare function drainWorkerDisposerChain(nodeId: string, addonId: string): Promise<void>;
-export { createAddonContext, createUdsAddonContext, setHubConnected, adaptBrokerToCluster, drainWorkerDisposerChain, registerEventBusService, setNodeEventInterest, getMoleculerEventStats, subscribePassthrough, clusterEventTopic, EVENT_TOPIC_PREFIX, getBrokerEventBus, withAddonScope, setPreferredProvider, createRunnerLogger, __resetHubConnectedForTests, __resetBindingSubscriptionForTests, __createRemoteLoggerForTests, };
+export { createAddonContext, createUdsAddonContext, setHubConnected, adaptBrokerToCluster, drainWorkerDisposerChain, registerEventBusService, setNodeEventInterest, getMoleculerEventStats, subscribePassthrough, clusterEventTopic, EVENT_TOPIC_PREFIX, getBrokerEventBus, withAddonScope, setPreferredProvider, createRunnerLogger, __resetHubConnectedForTests, __resetBindingSubscriptionForTests, __createRemoteLoggerForTests };
 export type { AddonContextOptions, MoleculerEventStats };

package/dist/kernel/moleculer/addon-data-plane-facility.d.ts

@@ -1,19 +1,19 @@
-import { AddonDataPlane, AddonDataPlaneEndpoint, IScopedLogger } from '@camstack/types';
+import type { AddonDataPlane, AddonDataPlaneEndpoint, IScopedLogger } from "@camstack/types";
 /** Where the facility publishes the addon's current data-plane endpoints so the
- *  runner can expose them to the hub's pull. */
+*  runner can expose them to the hub's pull. */
 export interface DataPlaneSink {
-    set(addonId: string, endpoints: readonly AddonDataPlaneEndpoint[]): void;
+	set(addonId: string, endpoints: readonly AddonDataPlaneEndpoint[]): void;
 }
 export interface AddonDataPlaneFacility {
-    readonly dataPlane: AddonDataPlane;
-    /** Close the listener + clear endpoints. Wired to the context disposer chain. */
-    dispose(): Promise<void>;
+	readonly dataPlane: AddonDataPlane;
+	/** Close the listener + clear endpoints. Wired to the context disposer chain. */
+	dispose(): Promise<void>;
 }
 export declare function createAddonDataPlaneFacility(args: {
-    readonly addonId: string;
-    readonly logger: IScopedLogger;
-    readonly sink?: DataPlaneSink;
-    /** Bind host — `127.0.0.1` for a hub-local addon (default). Remote agents bind
-     *  their reachable interface (deferred — single-hub first). */
-    readonly bindHost?: string;
+	readonly addonId: string;
+	readonly logger: IScopedLogger;
+	readonly sink?: DataPlaneSink;
+	/** Bind host — `127.0.0.1` for a hub-local addon (default). Remote agents bind
+	*  their reachable interface (deferred — single-hub first). */
+	readonly bindHost?: string;
 }): AddonDataPlaneFacility;

package/dist/kernel/moleculer/addon-deploy-source.d.ts

@@ -1,16 +1,16 @@
 /**
- * Where an agent should fetch an addon's bytes from for a `$agent.deploy`.
- * `npm`: the agent runs its own AddonInstaller pull. `hub-http`: the agent
- * streams the staged tgz from the hub's one-time-token bundle route.
- */
+* Where an agent should fetch an addon's bytes from for a `$agent.deploy`.
+* `npm`: the agent runs its own AddonInstaller pull. `hub-http`: the agent
+* streams the staged tgz from the hub's one-time-token bundle route.
+*/
 export type AddonDeploySource = {
-    readonly kind: 'npm';
-    readonly version: string;
+	readonly kind: "npm";
+	readonly version: string;
 } | {
-    readonly kind: 'hub-http';
-    readonly url: string;
-    readonly token: string;
-    readonly sha256: string;
-    readonly bytes: number;
+	readonly kind: "hub-http";
+	readonly url: string;
+	readonly token: string;
+	readonly sha256: string;
+	readonly bytes: number;
 };
 export declare function isAddonDeploySource(v: unknown): v is AddonDeploySource;

package/dist/kernel/moleculer/addon-peer-bytes-facility.d.ts

@@ -1,24 +1,24 @@
-import { AddonPeerBytes } from '@camstack/types/addon';
-import { IScopedLogger } from '@camstack/types';
+import { type AddonPeerBytes } from "@camstack/types/addon";
+import type { IScopedLogger } from "@camstack/types";
 export interface AddonPeerBytesFacility {
-    readonly peerBytes: AddonPeerBytes;
-    dispose(): Promise<void>;
+	readonly peerBytes: AddonPeerBytes;
+	dispose(): Promise<void>;
 }
 export interface AddonPeerBytesFacilityArgs {
-    readonly addonId: string;
-    readonly logger: IScopedLogger;
-    /**
-     * This process's node id. A runner's is `<hostNode>/<runnerId>`
-     * (`addon-runner.ts`), so the HOST — the only thing loopback reachability is
-     * a fact about — is the part before the first slash.
-     */
-    readonly nodeId: string;
-    /** Loopback, and only loopback, in production. */
-    readonly host?: string;
-    readonly now?: () => number;
-    readonly ttlMs?: number;
-    readonly maxOutstanding?: number;
-    readonly stallMs?: number;
+	readonly addonId: string;
+	readonly logger: IScopedLogger;
+	/**
+	* This process's node id. A runner's is `<hostNode>/<runnerId>`
+	* (`addon-runner.ts`), so the HOST — the only thing loopback reachability is
+	* a fact about — is the part before the first slash.
+	*/
+	readonly nodeId: string;
+	/** Loopback, and only loopback, in production. */
+	readonly host?: string;
+	readonly now?: () => number;
+	readonly ttlMs?: number;
+	readonly maxOutstanding?: number;
+	readonly stallMs?: number;
 }
 /** The HOST a node id belongs to. `hub` → `hub`; `hub/runner-3` → `hub`. */
 export declare function hostNodeIdOf(nodeId: string): string;