@camstack/system 1.2.390 → 1.2.391

package/dist/kernel/moleculer/trpc-links.d.ts

@@ -1,244 +1,244 @@
-import { TRPCLink } from '@trpc/client';
-import { AnyRouter } from '@trpc/server';
-import { ServiceBroker } from 'moleculer';
-import { CapCallInput } from '../transport/index.js';
+import { type TRPCLink } from "@trpc/client";
+import type { AnyRouter } from "@trpc/server";
+import type { ServiceBroker } from "moleculer";
+import type { CapCallInput } from "../transport/index.js";
 /**
- * Resolver for in-process capability providers.
- *
- * The localProviderLink calls this on every operation to check whether
- * a provider exists in the local process. Implementations differ:
- *   - Worker: reads from `localProviderRegistry` + `preferredProviderRegistry`
- *   - Hub: reads from `CapabilityRegistry`
- */
+* Resolver for in-process capability providers.
+*
+* The localProviderLink calls this on every operation to check whether
+* a provider exists in the local process. Implementations differ:
+*   - Worker: reads from `localProviderRegistry` + `preferredProviderRegistry`
+*   - Hub: reads from `CapabilityRegistry`
+*/
 /**
- * Shared interface — also re-exported by `broker-api-proxy.ts`.
- * Single method is sufficient: the link only needs to resolve the
- * first matching provider. Singleton vs collection distinction is
- * a registry concern, not a transport concern.
- */
+* Shared interface — also re-exported by `broker-api-proxy.ts`.
+* Single method is sufficient: the link only needs to resolve the
+* first matching provider. Singleton vs collection distinction is
+* a registry concern, not a transport concern.
+*/
 export interface LocalProviderResolver {
-    /** First matching provider (active singleton or first collection member). */
-    getByName(capabilityName: string): unknown | null;
-    /**
-     * The node this resolver's providers run on (e.g. `'hub'`, `'hub/model-studio'`,
-     * `'little-unraid/model-studio'`). When set, {@link localProviderLink} defers a
-     * call carrying an explicit `nodePin` to a DIFFERENT node instead of
-     * short-circuiting to a co-located provider — so the pin routes to the
-     * intended node (parent → `onUnownedCall` → CapRouteResolver). Symmetric to
-     * the LocalChildRegistry sibling-skip: an explicit pin must win over a
-     * same-named co-located provider. Omit for legacy/in-process callers that
-     * never pin a cap they themselves host.
-     */
-    localNodeId?: string;
+	/** First matching provider (active singleton or first collection member). */
+	getByName(capabilityName: string): unknown | null;
+	/**
+	* The node this resolver's providers run on (e.g. `'hub'`, `'hub/model-studio'`,
+	* `'little-unraid/model-studio'`). When set, {@link localProviderLink} defers a
+	* call carrying an explicit `nodePin` to a DIFFERENT node instead of
+	* short-circuiting to a co-located provider — so the pin routes to the
+	* intended node (parent → `onUnownedCall` → CapRouteResolver). Symmetric to
+	* the LocalChildRegistry sibling-skip: an explicit pin must win over a
+	* same-named co-located provider. Omit for legacy/in-process callers that
+	* never pin a cap they themselves host.
+	*/
+	localNodeId?: string;
 }
 /**
- * A single tRPC cap call observation. Recorded by `localProviderLink`
- * / `brokerTransportLink` on every op, regardless of in-process vs
- * cluster-bound routing, and fed to the hub's `CapUsageRegistry`.
- *
- * Observation is best-effort — observers MUST NOT throw. The link
- * wraps the recorder in a try/catch so a broken observer never fails
- * the caller's RPC.
- */
+* A single tRPC cap call observation. Recorded by `localProviderLink`
+* / `brokerTransportLink` on every op, regardless of in-process vs
+* cluster-bound routing, and fed to the hub's `CapUsageRegistry`.
+*
+* Observation is best-effort — observers MUST NOT throw. The link
+* wraps the recorder in a try/catch so a broken observer never fails
+* the caller's RPC.
+*/
 export interface CapUsageObservation {
-    readonly callerAddonId: string;
-    readonly providerAddonId: string;
-    readonly capName: string;
-    readonly methodName: string;
-    readonly atMs: number;
+	readonly callerAddonId: string;
+	readonly providerAddonId: string;
+	readonly capName: string;
+	readonly methodName: string;
+	readonly atMs: number;
 }
 export type CapUsageObserver = (obs: CapUsageObservation) => void;
 export interface CapUsageObserverOptions {
-    /** The addon whose `ctx.api` produced this link chain. */
-    readonly callerAddonId: string;
-    /**
-     * Resolve which addon hosts the provider for `capName`. `null` means "not in
-     * the LOCAL registry" — which is every cross-process provider, and no longer
-     * means "do not record": see {@link UNRESOLVED_PROVIDER_ADDON_ID}.
-     */
-    readonly providerAddonIdForCap: (capName: string) => string | null;
-    /** Sink for observations. MUST NOT throw — wrapper catches anyway. */
-    readonly observer: CapUsageObserver;
+	/** The addon whose `ctx.api` produced this link chain. */
+	readonly callerAddonId: string;
+	/**
+	* Resolve which addon hosts the provider for `capName`. `null` means "not in
+	* the LOCAL registry" — which is every cross-process provider, and no longer
+	* means "do not record": see {@link UNRESOLVED_PROVIDER_ADDON_ID}.
+	*/
+	readonly providerAddonIdForCap: (capName: string) => string | null;
+	/** Sink for observations. MUST NOT throw — wrapper catches anyway. */
+	readonly observer: CapUsageObserver;
 }
 /**
- * Stands in for a provider the LOCAL registry cannot name.
- *
- * `providerAddonIdForCap` only searches the local registry, so it returns
- * `null` for every cross-process provider — which is every forked runner,
- * `sqlite-settings` included. That `null` used to drop the whole observation,
- * caller and all. The result: `nodes.getCapUsageGraph`, an admin API whose
- * entire job is to show caller → provider → cap traffic, returned an EMPTY
- * ARRAY on the live hub while the engine logged 39 717 calls a minute to a
- * single collection. An empty graph reads as "nothing is calling anything".
- *
- * The caller is always known — it is whoever made the call — and "who is
- * hammering this cap" is the question the graph exists to answer. So the
- * observation is recorded and the unknown half stays VISIBLY unknown, which is
- * a fact an operator can act on, rather than absent, which is a fact nobody can
- * see. Naming the provider properly needs the cluster-wide cap list; until then
- * this placeholder is the honest value.
- */
+* Stands in for a provider the LOCAL registry cannot name.
+*
+* `providerAddonIdForCap` only searches the local registry, so it returns
+* `null` for every cross-process provider — which is every forked runner,
+* `sqlite-settings` included. That `null` used to drop the whole observation,
+* caller and all. The result: `nodes.getCapUsageGraph`, an admin API whose
+* entire job is to show caller → provider → cap traffic, returned an EMPTY
+* ARRAY on the live hub while the engine logged 39 717 calls a minute to a
+* single collection. An empty graph reads as "nothing is calling anything".
+*
+* The caller is always known — it is whoever made the call — and "who is
+* hammering this cap" is the question the graph exists to answer. So the
+* observation is recorded and the unknown half stays VISIBLY unknown, which is
+* a fact an operator can act on, rather than absent, which is a fact nobody can
+* see. Naming the provider properly needs the cluster-wide cap list; until then
+* this placeholder is the honest value.
+*/
 export declare const UNRESOLVED_PROVIDER_ADDON_ID = "(unresolved: cross-process)";
 /**
- * Record one cap call, if an observer is configured. Extracted so the rule —
- * an unresolved provider never erases the caller — has ONE place and a test.
- */
+* Record one cap call, if an observer is configured. Extracted so the rule —
+* an unresolved provider never erases the caller — has ONE place and a test.
+*/
 export declare function recordCapUsage(observerOpts: CapUsageObserverOptions, capName: string, methodName: string): void;
 /**
- * Non-terminating tRPC link that intercepts calls when the target
- * capability has a provider registered in the local process.
- *
- * When a local provider is found and implements the requested method,
- * the call is made directly (zero serialization). When no local
- * provider exists, the call passes through to `next(op)`.
- *
- * This is the mechanism that makes `ctx.api.streamBroker.getBrokerStats.query()`
- * resolve in-process on the hub without going through Moleculer, and
- * makes `ctx.api.pipelineExecutor.runPipeline.mutate()` resolve locally
- * on a forked worker that has a co-located pipeline-executor.
- */
+* Non-terminating tRPC link that intercepts calls when the target
+* capability has a provider registered in the local process.
+*
+* When a local provider is found and implements the requested method,
+* the call is made directly (zero serialization). When no local
+* provider exists, the call passes through to `next(op)`.
+*
+* This is the mechanism that makes `ctx.api.streamBroker.getBrokerStats.query()`
+* resolve in-process on the hub without going through Moleculer, and
+* makes `ctx.api.pipelineExecutor.runPipeline.mutate()` resolve locally
+* on a forked worker that has a co-located pipeline-executor.
+*/
 export declare function localProviderLink<TRouter extends AnyRouter>(resolver: LocalProviderResolver, observerOpts?: CapUsageObserverOptions): TRPCLink<TRouter>;
 /**
- * Hard deadline for service discovery on a load-balanced cap call.
- *
- * Before this constant existed, `awaitServiceCandidates` polled forever
- * if a service never (re-)appeared — every consumer of a wedged cap then
- * hung indefinitely (observed live as `[brokerTransportLink] still
- * awaiting … after 200s+` in dev logs, cascading through every chain
- * that touched the affected cap). With the deadline in place, a missing
- * provider surfaces as a Moleculer "service not found" rejection at the
- * caller site after at most ~30s — within the cold-boot / respawn
- * window for any well-behaved addon, while still bounding the failure
- * mode of a genuinely-stuck cap.
- *
- * Callers that legitimately need to wait longer (e.g. boot ordering)
- * use `ctx.acquireCapability(name, scope, { timeoutMs })` BEFORE issuing
- * the RPC — see CLAUDE.md's "Do not re-implement Moleculer discovery /
- * liveness / events" rule. Per-link override is exposed for tests +
- * tuning via `BrokerTransportLinkOptions.discoveryTimeoutMs`.
- */
-export declare const DEFAULT_DISCOVERY_TIMEOUT_MS = 30000;
+* Hard deadline for service discovery on a load-balanced cap call.
+*
+* Before this constant existed, `awaitServiceCandidates` polled forever
+* if a service never (re-)appeared — every consumer of a wedged cap then
+* hung indefinitely (observed live as `[brokerTransportLink] still
+* awaiting … after 200s+` in dev logs, cascading through every chain
+* that touched the affected cap). With the deadline in place, a missing
+* provider surfaces as a Moleculer "service not found" rejection at the
+* caller site after at most ~30s — within the cold-boot / respawn
+* window for any well-behaved addon, while still bounding the failure
+* mode of a genuinely-stuck cap.
+*
+* Callers that legitimately need to wait longer (e.g. boot ordering)
+* use `ctx.acquireCapability(name, scope, { timeoutMs })` BEFORE issuing
+* the RPC — see CLAUDE.md's "Do not re-implement Moleculer discovery /
+* liveness / events" rule. Per-link override is exposed for tests +
+* tuning via `BrokerTransportLinkOptions.discoveryTimeoutMs`.
+*/
+export declare const DEFAULT_DISCOVERY_TIMEOUT_MS = 3e4;
 /**
- * Options for {@link brokerCallForCap} — the reusable broker-dispatch core
- * shared by `brokerTransportLink` and the parent-side `onUnownedCall` fallback.
- */
+* Options for {@link brokerCallForCap} — the reusable broker-dispatch core
+* shared by `brokerTransportLink` and the parent-side `onUnownedCall` fallback.
+*/
 export interface BrokerCapCallOpts {
-    /**
-     * Pins the call to a specific Moleculer node. When set, the call uses the
-     * bounded pinned-discovery retry (2s) and surfaces "service not found" fast,
-     * mirroring `brokerTransportLink`'s pinned path. When absent, the call uses
-     * the unbounded load-balanced discovery wait.
-     */
-    readonly nodeId?: string;
-    /** Static service-name override for the cap (matches `brokerTransportLink`'s serviceMap entry). */
-    readonly forceServiceName?: string;
-    /**
-     * Abort flag — set `aborted = true` to tear down a pending discovery wait.
-     * Defaults to a never-aborted flag when omitted.
-     */
-    readonly abort?: {
-        aborted: boolean;
-    };
+	/**
+	* Pins the call to a specific Moleculer node. When set, the call uses the
+	* bounded pinned-discovery retry (2s) and surfaces "service not found" fast,
+	* mirroring `brokerTransportLink`'s pinned path. When absent, the call uses
+	* the unbounded load-balanced discovery wait.
+	*/
+	readonly nodeId?: string;
+	/** Static service-name override for the cap (matches `brokerTransportLink`'s serviceMap entry). */
+	readonly forceServiceName?: string;
+	/**
+	* Abort flag — set `aborted = true` to tear down a pending discovery wait.
+	* Defaults to a never-aborted flag when omitted.
+	*/
+	readonly abort?: {
+		aborted: boolean;
+	};
 }
 /**
- * Resolve and dispatch a cap method call over a Moleculer broker.
- *
- * Routing (service discovery + node resolution + `capActionName`) is delegated
- * to the shared {@link resolveBrokerCapCall} core — the SAME core
- * `brokerTransportLink` uses — so the two can never drift. This function is the
- * thin "resolve then `broker.call`" wrapper.
- *
- * What this function IS used for:
- *   The hub / agent parent-side `onUnownedCall` fallback (F0 — when a forked
- *   child calls a cap no local sibling owns and the resolver returns `no-provider`,
- *   e.g. the hub's `$core-caps` / `$stream-probe` core services, which are
- *   Moleculer services NOT registered as CapabilityRegistry providers).
- *
- * A genuinely-absent service surfaces the broker's "service not found" error
- * (bounded for pinned calls) rather than hanging.
- */
+* Resolve and dispatch a cap method call over a Moleculer broker.
+*
+* Routing (service discovery + node resolution + `capActionName`) is delegated
+* to the shared {@link resolveBrokerCapCall} core — the SAME core
+* `brokerTransportLink` uses — so the two can never drift. This function is the
+* thin "resolve then `broker.call`" wrapper.
+*
+* What this function IS used for:
+*   The hub / agent parent-side `onUnownedCall` fallback (F0 — when a forked
+*   child calls a cap no local sibling owns and the resolver returns `no-provider`,
+*   e.g. the hub's `$core-caps` / `$stream-probe` core services, which are
+*   Moleculer services NOT registered as CapabilityRegistry providers).
+*
+* A genuinely-absent service surfaces the broker's "service not found" error
+* (bounded for pinned calls) rather than hanging.
+*/
 export declare function brokerCallForCap(broker: ServiceBroker, capName: string, method: string, args: unknown, opts?: BrokerCapCallOpts): Promise<unknown>;
 /**
- * Tunables for {@link brokerTransportLink}.
- *
- * `discoveryTimeoutMs` bounds the load-balanced service-discovery wait
- * inside `awaitServiceCandidates`. Default {@link DEFAULT_DISCOVERY_TIMEOUT_MS}.
- * Overriding is for tests + tuning — production callers that need a
- * different deadline should use `ctx.acquireCapability` instead, since
- * that's the documented liveness mechanism (CLAUDE.md).
- */
+* Tunables for {@link brokerTransportLink}.
+*
+* `discoveryTimeoutMs` bounds the load-balanced service-discovery wait
+* inside `awaitServiceCandidates`. Default {@link DEFAULT_DISCOVERY_TIMEOUT_MS}.
+* Overriding is for tests + tuning — production callers that need a
+* different deadline should use `ctx.acquireCapability` instead, since
+* that's the documented liveness mechanism (CLAUDE.md).
+*/
 export interface BrokerTransportLinkOptions {
-    readonly discoveryTimeoutMs?: number;
+	readonly discoveryTimeoutMs?: number;
 }
 /**
- * Dispatch a call to a device-scoped capability. Supplied by the hub, where it
- * is `callCapabilityOnNode` — the entry the codegen cap routers already use,
- * which extracts the `deviceId` from the input and asks the `CapRouteResolver`.
- */
+* Dispatch a call to a device-scoped capability. Supplied by the hub, where it
+* is `callCapabilityOnNode` — the entry the codegen cap routers already use,
+* which extracts the `deviceId` from the input and asks the `CapRouteResolver`.
+*/
 export type DeviceCapDispatcher = (capName: string, method: string, input: unknown) => Promise<unknown>;
 /**
- * The link that lets an IN-PROCESS addon call a device-scoped cap.
- *
- * Without it the hub's own `ctx.api` chain is `localProviderLink →
- * brokerTransportLink`: a provider in this process, then the Moleculer
- * registry. Forked addon children are BROKER-LESS (UDS), so a device provider
- * such as hikvision's `ptz` advertises nothing on the bus, no service candidate
- * matches, and the call falls back to the `<cap>.<cap>.<method>` shape
- * documented above as the broken one. A forked addon never hits this because
- * its chain ends at `ipcParentLink` → the parent's `CapRouteResolver`; an
- * in-process one had no way to reach that authority at all.
- *
- * Deliberately narrow: it intercepts ONLY a cap whose definition says
- * `scope: 'device'`, and only when the call actually carries a numeric
- * `deviceId` to route on. A system cap that happens to take a `deviceId`
- * argument (`deviceManager.getBindings`, `deviceState.getCapSlice`) is left
- * exactly where it was. There is no fallback to the broker after a resolver
- * failure, on purpose: the resolver's error names the node and the reason,
- * and replacing it with "service not found" is how this class of bug hides.
- */
+* The link that lets an IN-PROCESS addon call a device-scoped cap.
+*
+* Without it the hub's own `ctx.api` chain is `localProviderLink →
+* brokerTransportLink`: a provider in this process, then the Moleculer
+* registry. Forked addon children are BROKER-LESS (UDS), so a device provider
+* such as hikvision's `ptz` advertises nothing on the bus, no service candidate
+* matches, and the call falls back to the `<cap>.<cap>.<method>` shape
+* documented above as the broken one. A forked addon never hits this because
+* its chain ends at `ipcParentLink` → the parent's `CapRouteResolver`; an
+* in-process one had no way to reach that authority at all.
+*
+* Deliberately narrow: it intercepts ONLY a cap whose definition says
+* `scope: 'device'`, and only when the call actually carries a numeric
+* `deviceId` to route on. A system cap that happens to take a `deviceId`
+* argument (`deviceManager.getBindings`, `deviceState.getCapSlice`) is left
+* exactly where it was. There is no fallback to the broker after a resolver
+* failure, on purpose: the resolver's error names the node and the reason,
+* and replacing it with "service not found" is how this class of bug hides.
+*/
 export declare function deviceCapResolverLink<TRouter extends AnyRouter>(dispatch: DeviceCapDispatcher, isDeviceScoped: (capName: string) => boolean): TRPCLink<TRouter>;
 export declare function brokerTransportLink<TRouter extends AnyRouter>(broker: ServiceBroker, serviceMap?: Readonly<Record<string, string>>, observerOpts?: CapUsageObserverOptions, linkOptions?: BrokerTransportLinkOptions): TRPCLink<TRouter>;
 /**
- * Middle link that routes a child addon's outbound `ctx.api` cap call to the
- * parent hub over UDS via `callOut` (obtained at call-time so the child can
- * reconnect without rebuilding its tRPC client).
- *
- * Delegation rules:
- *  - `getCallOut()` returns `null`  → not connected, delegate via `next(op)`.
- *  - `parsePath(op.path)` returns `null` → unparseable path, delegate via `next(op)`.
- *  - `callOut` rejects with a no-route error (message starts with `UDS_NO_ROUTE_PREFIX`)
- *    → the parent could not route the call (no local sibling, no cluster fallback);
- *    delegate via `next(op)` (broker fallback) — safe because no provider ran.
- *  - `callOut` rejects with any other error → real provider error; propagate to
- *    the caller via `observer.error` — NEVER retry via broker to avoid
- *    double-executing side effects.
- */
+* Middle link that routes a child addon's outbound `ctx.api` cap call to the
+* parent hub over UDS via `callOut` (obtained at call-time so the child can
+* reconnect without rebuilding its tRPC client).
+*
+* Delegation rules:
+*  - `getCallOut()` returns `null`  → not connected, delegate via `next(op)`.
+*  - `parsePath(op.path)` returns `null` → unparseable path, delegate via `next(op)`.
+*  - `callOut` rejects with a no-route error (message starts with `UDS_NO_ROUTE_PREFIX`)
+*    → the parent could not route the call (no local sibling, no cluster fallback);
+*    delegate via `next(op)` (broker fallback) — safe because no provider ran.
+*  - `callOut` rejects with any other error → real provider error; propagate to
+*    the caller via `observer.error` — NEVER retry via broker to avoid
+*    double-executing side effects.
+*/
 export declare function ipcParentLink<TRouter extends AnyRouter>(getCallOut: () => ((input: CapCallInput) => Promise<unknown>) | null): TRPCLink<TRouter>;
 export type LinkChainTarget = {
-    type: 'local-router';
-    terminatingLink: TRPCLink<AnyRouter>;
+	type: "local-router";
+	terminatingLink: TRPCLink<AnyRouter>;
 } | {
-    type: 'ws';
-    terminatingLink: TRPCLink<AnyRouter>;
+	type: "ws";
+	terminatingLink: TRPCLink<AnyRouter>;
 } | {
-    type: 'broker';
-    broker: ServiceBroker;
-    serviceMap?: Readonly<Record<string, string>>;
+	type: "broker";
+	broker: ServiceBroker;
+	serviceMap?: Readonly<Record<string, string>>;
 };
 /**
- * Optional observer hookup for `buildLinkChain` — threads the same
- * `CapUsageObserverOptions` through `localProviderLink` and
- * `brokerTransportLink` so every op is recorded once regardless of
- * whether it resolved locally or over the broker.
- */
+* Optional observer hookup for `buildLinkChain` — threads the same
+* `CapUsageObserverOptions` through `localProviderLink` and
+* `brokerTransportLink` so every op is recorded once regardless of
+* whether it resolved locally or over the broker.
+*/
 export interface LinkChainObserverHookup {
-    readonly observerOpts?: CapUsageObserverOptions;
+	readonly observerOpts?: CapUsageObserverOptions;
 }
 /**
- * Build the tRPC link chain for an addon context.
- *
- * Always starts with `localProviderLink` (if a resolver is provided),
- * then falls through to the appropriate terminating link based on the
- * deployment context.
- */
+* Build the tRPC link chain for an addon context.
+*
+* Always starts with `localProviderLink` (if a resolver is provided),
+* then falls through to the appropriate terminating link based on the
+* deployment context.
+*/
 export declare function buildLinkChain(target: LinkChainTarget, localResolver?: LocalProviderResolver, hookup?: LinkChainObserverHookup): TRPCLink<AnyRouter>[];

package/dist/kernel/moleculer/typed-array-serde.d.ts

@@ -1,24 +1,13 @@
 /**
- * Serialize/deserialize non-Buffer TypedArrays for Moleculer MsgPack transport.
- *
- * MsgPack handles Buffer natively but serializes Float32Array, Int16Array etc.
- * as plain objects with numeric keys. These helpers convert them to Buffer
- * with a type tag for transport and reconstruct them on arrival.
- *
- * Used by:
- * - capability-bridge.ts (hub → child proxy calls)
- * - addon-service-factory.ts (child → provider param reconstruction)
- */
-/**
- * Convert non-Buffer TypedArrays → `{ __typedArray, type, data: Buffer }` recursively.
- *
- * A WeakSet tracks objects already visited on the current descent path so a
- * cyclic input throws a precise error at the offending path instead of
- * blowing the stack with "Maximum call stack size exceeded". tRPC inputs
- * should never be cyclic in practice — this is a safety net for regressions
- * that accidentally introduce shared-reference loops (e.g. a config object
- * that holds a back-pointer into its own container).
- */
+* Convert non-Buffer TypedArrays → `{ __typedArray, type, data: Buffer }` recursively.
+*
+* A WeakSet tracks objects already visited on the current descent path so a
+* cyclic input throws a precise error at the offending path instead of
+* blowing the stack with "Maximum call stack size exceeded". tRPC inputs
+* should never be cyclic in practice — this is a safety net for regressions
+* that accidentally introduce shared-reference loops (e.g. a config object
+* that holds a back-pointer into its own container).
+*/
 declare function serializeTypedArrays(value: unknown, seen?: WeakSet<object>, path?: string): unknown;
 /** Reconstruct TypedArrays from tagged objects. */
 declare function deserializeTypedArrays(value: unknown): unknown;

package/dist/kernel/moleculer/worker-device-restore.d.ts

@@ -1,10 +1,10 @@
-import { ICamstackAddon, IEventBus, IScopedLogger } from '@camstack/types';
+import type { ICamstackAddon, IEventBus, IScopedLogger } from "@camstack/types";
 export declare function runWorkerDeviceRestoreWithRetry(addon: ICamstackAddon, context: {
-    api?: unknown;
-    eventBus?: IEventBus;
-    logger?: IScopedLogger | {
-        info?: (m: string) => void;
-        warn?: (m: string) => void;
-        debug?: (m: string) => void;
-    };
+	api?: unknown;
+	eventBus?: IEventBus;
+	logger?: IScopedLogger | {
+		info?: (m: string) => void;
+		warn?: (m: string) => void;
+		debug?: (m: string) => void;
+	};
 }, addonId: string, sourceNodeId: string): Promise<void>;