nvent 0.4.0

package/dist/runtime/server/utils/defineQueueConfig.d.ts

@@ -0,0 +1,154 @@
+export type FlowRole = 'entry' | 'step';
+export interface FlowConfig {
+    /**
+     * One or more flow names this step belongs to.
+     * A single worker step can participate in multiple flows.
+     */
+    name: string | string[];
+    /**
+     * Role of this step in the flow.
+     */
+    role: FlowRole;
+    /**
+     * Logical step name (used as job name and event kind on start).
+     */
+    step: string;
+    /**
+     * Event kinds this step emits (e.g., `${step}.completed`).
+     */
+    emits?: string[];
+    /**
+     * Event kinds this step subscribes to; can be a single string or an array.
+     * The compiler normalizes this to `string[]` under `subscribes`.
+     */
+    subscribes?: string | string[];
+}
+export interface QueueJobDefaults {
+    /**
+     * Number of retry attempts for failed jobs.
+     * BullMQ: attempts, PGBoss: retryLimit
+     */
+    attempts?: number;
+    /**
+     * Backoff strategy for retries.
+     * BullMQ: backoff, PGBoss: retryBackoff + exponentialBackoff
+     */
+    backoff?: number | {
+        type: 'fixed' | 'exponential';
+        delay: number;
+    };
+    /**
+     * Delay in milliseconds before the job is processed.
+     * BullMQ: delay, PGBoss: startAfter
+     */
+    delay?: number;
+    /**
+     * Job priority (higher number = higher priority).
+     * BullMQ: priority, PGBoss: priority
+     */
+    priority?: number;
+    /**
+     * Job timeout in milliseconds.
+     * BullMQ: timeout, PGBoss: expireInSeconds (converted)
+     */
+    timeout?: number;
+    /**
+     * Process jobs in LIFO (Last In First Out) order.
+     * BullMQ: lifo, PGBoss: not supported
+     */
+    lifo?: boolean;
+    /**
+     * Remove job from queue when completed.
+     * BullMQ: removeOnComplete, PGBoss: deleteAfterSeconds
+     */
+    removeOnComplete?: boolean | number;
+    /**
+     * Remove job from queue when failed.
+     * BullMQ: removeOnFail, PGBoss: deleteAfterSeconds
+     */
+    removeOnFail?: boolean | number;
+    /**
+     * Repeatable job configuration.
+     * BullMQ: repeat, PGBoss: schedule pattern
+     */
+    repeat?: {
+        cron?: string;
+        every?: number;
+        limit?: number;
+        tz?: string;
+    };
+}
+export interface QueueConfig {
+    /**
+     * Queue name. If not provided, the filename will be used.
+     */
+    name?: string;
+    /**
+     * Default options for jobs enqueued to this queue.
+     */
+    defaultJobOptions?: QueueJobDefaults;
+    /**
+     * Prefix for queue keys in Redis/storage.
+     * BullMQ: prefix, PGBoss: schema
+     */
+    prefix?: string;
+    /**
+     * Rate limiting configuration.
+     * BullMQ: limiter, PGBoss: teamSize + teamConcurrency (partial)
+     */
+    limiter?: {
+        /**
+         * Maximum number of jobs to process in the duration window.
+         */
+        max?: number;
+        /**
+         * Duration of the rate limit window in milliseconds.
+         */
+        duration?: number;
+        /**
+         * Group key for rate limiting (optional).
+         * BullMQ only: allows per-group rate limiting
+         */
+        groupKey?: string;
+    };
+}
+export interface WorkerConfig {
+    /**
+     * Number of jobs to process concurrently.
+     * BullMQ: concurrency, PGBoss: teamSize
+     */
+    concurrency?: number;
+    /**
+     * Lock duration in milliseconds.
+     * BullMQ: lockDuration, PGBoss: newJobCheckInterval (similar concept)
+     */
+    lockDurationMs?: number;
+    /**
+     * Maximum number of times a job can be stalled before being failed.
+     * BullMQ: maxStalledCount, PGBoss: not directly supported
+     */
+    maxStalledCount?: number;
+    /**
+     * Delay in milliseconds before processing jobs after queue is drained.
+     * BullMQ: drainDelay, PGBoss: not directly supported
+     */
+    drainDelayMs?: number;
+    /**
+     * Automatically run worker on startup.
+     * BullMQ: autorun, PGBoss: workers start automatically
+     */
+    autorun?: boolean;
+    /**
+     * Polling interval in milliseconds for checking new jobs.
+     * PGBoss: newJobCheckInterval, BullMQ: uses blocking wait
+     */
+    pollingIntervalMs?: number;
+}
+export interface QueueWorkerConfig {
+    queue?: QueueConfig;
+    flow?: FlowConfig;
+    worker?: WorkerConfig;
+}
+export type DefineQueueConfig = <T extends QueueWorkerConfig>(cfg: T) => T;
+export declare const defineQueueConfig: DefineQueueConfig;
+export default defineQueueConfig;

package/dist/runtime/server/utils/defineQueueConfig.js

@@ -0,0 +1,2 @@
+export const defineQueueConfig = (cfg) => cfg;
+export default defineQueueConfig;

package/dist/runtime/server/utils/defineQueueWorker.d.ts

@@ -0,0 +1,10 @@
+import { useFlowEngine, useQueue } from '#imports';
+import type { RunContext, NodeHandler } from '../worker/runner/node.js';
+export type ExtendedRunContext = RunContext & {
+    provider: ReturnType<typeof useQueue>;
+    flow: ReturnType<typeof useFlowEngine>;
+    registry: any;
+};
+export type DefineQueueWorker = (handler: (input: any, ctx: ExtendedRunContext) => Promise<any>) => NodeHandler;
+export declare const defineQueueWorker: DefineQueueWorker;
+export default defineQueueWorker;

package/dist/runtime/server/utils/defineQueueWorker.js

@@ -0,0 +1,17 @@
+import { $useQueueRegistry, useFlowEngine, useQueue } from "#imports";
+export const defineQueueWorker = (handler) => {
+  const wrapped = async (input, ctx) => {
+    const provider = useQueue();
+    const flow = ctx.flow || useFlowEngine();
+    const registry = $useQueueRegistry();
+    const extended = {
+      ...ctx,
+      provider,
+      flow,
+      registry
+    };
+    return handler(input, extended);
+  };
+  return wrapped;
+};
+export default defineQueueWorker;

package/dist/runtime/server/utils/useEventManager.d.ts

@@ -0,0 +1,15 @@
+import { getEventBus } from '../events/eventBus.js';
+import type { EventRecord } from '../../types.js';
+export interface EventManager {
+    /**
+     * Publish an event directly to the in-proc bus.
+     */
+    publishBus(evt: Partial<EventRecord>): Promise<void>;
+    onType: (type: string, handler: (e: EventRecord) => void) => () => void;
+    subscribeRunId: ReturnType<typeof getEventBus>['subscribeRunId'];
+}
+declare global {
+    var __nq_event_manager: EventManager | undefined;
+}
+export declare function useEventManager(): EventManager;
+export declare function setEventManager(mgr: EventManager): void;

package/dist/runtime/server/utils/useEventManager.js

@@ -0,0 +1,26 @@
+import { getEventBus } from "../events/eventBus.js";
+import { useServerLogger } from "#imports";
+const logger = useServerLogger("event-manager");
+export function useEventManager() {
+  if (globalThis.__nq_event_manager) return globalThis.__nq_event_manager;
+  const bus = getEventBus();
+  const publishBus = async (evt) => {
+    const rec = {
+      ...evt,
+      runId: evt.runId || ""
+    };
+    bus.publish(rec);
+    logger.debug("Published event to bus", { type: rec.type, runId: rec.runId });
+  };
+  const subscribeRunId = (runId, handler) => {
+    return bus.subscribeRunId(runId, handler);
+  };
+  const onType = (type, handler) => {
+    return bus.onType(type, handler);
+  };
+  globalThis.__nq_event_manager = { publishBus, onType, subscribeRunId };
+  return globalThis.__nq_event_manager;
+}
+export function setEventManager(mgr) {
+  globalThis.__nq_event_manager = mgr;
+}

package/dist/runtime/server/utils/useEventStore.d.ts

@@ -0,0 +1,20 @@
+import type { EventReadOptions } from '../events/types.js';
+import type { EventRecord } from '../../types.js';
+export declare function useEventStore(): {
+    names: () => import("../events/streamNames.js").StreamNames;
+    read: (stream: string, opts?: EventReadOptions) => Promise<EventRecord[]>;
+    indexAdd: (key: string, id: string, score: number, metadata?: Record<string, any>) => Promise<void>;
+    indexGet: (key: string, id: string) => Promise<import("../events/types.js").IndexEntry | null>;
+    indexUpdate: (key: string, id: string, metadata: Record<string, any>) => Promise<boolean>;
+    indexUpdateWithRetry: (key: string, id: string, metadata: Record<string, any>, maxRetries?: number) => Promise<void>;
+    indexIncrement: (key: string, id: string, field: string, increment?: number) => Promise<number>;
+    indexRead: (key: string, opts?: {
+        offset?: number;
+        limit?: number;
+    }) => Promise<import("../events/types.js").IndexEntry[]>;
+    deleteStream: (subject: string) => Promise<void>;
+    deleteByPattern: (pattern: string) => Promise<number>;
+    deleteIndex: (key: string) => Promise<void>;
+    subscribe: (stream: string, handler: (e: EventRecord) => void) => () => void;
+    adapter: import("../events/types.js").EventStoreAdapter;
+};

package/dist/runtime/server/utils/useEventStore.js

@@ -0,0 +1,119 @@
+import { getEventStoreFactory } from "../events/eventStoreFactory.js";
+import { useServerLogger } from "#imports";
+const logger = useServerLogger("event-store");
+export function useEventStore() {
+  const factory = getEventStoreFactory();
+  async function read(stream, opts) {
+    return await factory.adapter.read(stream, opts);
+  }
+  async function indexAdd(key, id, score, metadata) {
+    if (!factory.adapter.indexAdd) {
+      throw new Error("Current adapter does not support indexAdd");
+    }
+    return await factory.adapter.indexAdd(key, id, score, metadata);
+  }
+  async function indexGet(key, id) {
+    if (!factory.adapter.indexGet) {
+      throw new Error("Current adapter does not support indexGet");
+    }
+    return await factory.adapter.indexGet(key, id);
+  }
+  async function indexUpdate(key, id, metadata) {
+    if (!factory.adapter.indexUpdate) {
+      throw new Error("Current adapter does not support indexUpdate");
+    }
+    return await factory.adapter.indexUpdate(key, id, metadata);
+  }
+  async function indexUpdateWithRetry(key, id, metadata, maxRetries) {
+    if (!factory.adapter.indexUpdateWithRetry) {
+      throw new Error("Current adapter does not support indexUpdateWithRetry");
+    }
+    return await factory.adapter.indexUpdateWithRetry(key, id, metadata, maxRetries);
+  }
+  async function indexIncrement(key, id, field, increment) {
+    if (!factory.adapter.indexIncrement) {
+      throw new Error("Current adapter does not support indexIncrement");
+    }
+    return await factory.adapter.indexIncrement(key, id, field, increment);
+  }
+  async function indexRead(key, opts) {
+    if (!factory.adapter.indexRead) {
+      throw new Error("Current adapter does not support indexRead");
+    }
+    return await factory.adapter.indexRead(key, opts);
+  }
+  async function deleteStream(subject) {
+    if (!factory.adapter.deleteStream) {
+      throw new Error("Current adapter does not support deleteStream");
+    }
+    return await factory.adapter.deleteStream(subject);
+  }
+  async function deleteByPattern(pattern) {
+    if (!factory.adapter.deleteByPattern) {
+      throw new Error("Current adapter does not support deleteByPattern");
+    }
+    return await factory.adapter.deleteByPattern(pattern);
+  }
+  async function deleteIndex(key) {
+    if (!factory.adapter.deleteIndex) {
+      throw new Error("Current adapter does not support deleteIndex");
+    }
+    return await factory.adapter.deleteIndex(key);
+  }
+  function names() {
+    return factory.names;
+  }
+  function subscribe(stream, handler) {
+    logger.debug("Subscribing to stream", { stream });
+    let sub = null;
+    let active = true;
+    (async () => {
+      try {
+        sub = await factory.adapter.subscribe(stream, (e) => {
+          logger.debug("Event received", { stream, id: e?.id, type: e?.type });
+          handler(e);
+        });
+        logger.debug("Subscription active", { stream });
+      } catch (err) {
+        logger.error("Subscription error", { stream, error: err });
+      }
+      if (!active && sub) {
+        try {
+          sub.unsubscribe();
+        } catch {
+        }
+      }
+    })();
+    return () => {
+      active = false;
+      if (sub) {
+        try {
+          sub.unsubscribe();
+        } catch {
+        }
+        sub = null;
+      }
+    };
+  }
+  return {
+    // names
+    names,
+    // read from canonical streams
+    read,
+    // sorted set index operations
+    indexAdd,
+    indexGet,
+    indexUpdate,
+    indexUpdateWithRetry,
+    indexIncrement,
+    indexRead,
+    // deletion operations
+    deleteStream,
+    deleteByPattern,
+    deleteIndex,
+    // subscribe to canonical stream events via the adapter (Store Bus)
+    subscribe,
+    // expose adapter if advanced usage is needed
+    adapter: factory.adapter
+  };
+}

package/dist/runtime/server/utils/useFlowEngine.d.ts

@@ -0,0 +1,9 @@
+export declare const useFlowEngine: () => {
+    startFlow: (flowName: string, payload?: any) => Promise<{
+        id: any;
+        queue: any;
+        step: any;
+        flowId: `${string}-${string}-${string}-${string}-${string}`;
+    }>;
+    emit: (trigger: string, payload?: any) => Promise<never[]>;
+};

package/dist/runtime/server/utils/useFlowEngine.js

@@ -0,0 +1,44 @@
+import { $useQueueRegistry, useQueue, useEventManager, useServerLogger } from "#imports";
+import { randomUUID } from "node:crypto";
+const logger = useServerLogger("flow-engine");
+export const useFlowEngine = () => {
+  const registry = $useQueueRegistry();
+  const queueAdapter = useQueue();
+  const eventsManager = useEventManager();
+  const startFlow = async (flowName, payload = {}) => {
+    const flow = registry?.flows?.[flowName];
+    if (!flow || !flow.entry) throw new Error("Flow not found");
+    const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
+    const flowId = randomUUID();
+    const id = await queueAdapter.enqueue(queueName, { name: flow.entry.step, data: { ...payload, flowId, flowName } });
+    try {
+      await eventsManager.publishBus({ type: "flow.start", runId: flowId, flowName, data: { input: payload } });
+    } catch {
+    }
+    return { id, queue: queueName, step: flow.entry.step, flowId };
+  };
+  const emit = async (trigger, payload = {}) => {
+    const flowId = payload?.flowId;
+    const flowName = payload?.flowName || "unknown";
+    if (!flowId) {
+      logger.warn("emit called without flowId, trigger may not work", { trigger });
+    }
+    const { flowId: _, flowName: __, ...actualPayload } = payload;
+    try {
+      await eventsManager.publishBus({
+        type: "emit",
+        runId: flowId || "unknown",
+        flowName,
+        data: {
+          name: trigger,
+          payload: actualPayload
+          // Store actual payload separately
+        }
+      });
+    } catch (err) {
+      logger.error("Failed to emit trigger event", { trigger, error: err });
+    }
+    return [];
+  };
+  return { startFlow, emit };
+};

package/dist/runtime/server/utils/useLogs.d.ts

@@ -0,0 +1,41 @@
+export interface LogReadOptions {
+    fromId?: string;
+    limit?: number;
+}
+export declare function useLogs(): {
+    getJobLogs: (_jobId: string, _opts?: {
+        limit?: number;
+        fromId?: string;
+        direction?: "forward" | "backward";
+        paged?: boolean;
+    }) => Promise<any>;
+    getFlowRunLogs: (flowId: string, opts?: {
+        limit?: number;
+        fromId?: string;
+        direction?: "forward" | "backward";
+        paged?: boolean;
+    }) => Promise<any>;
+    publishLog: (level: "debug" | "info" | "warn" | "error", msg: string, meta?: any, ctx?: {
+        queue?: string;
+        jobId?: string;
+        flowId?: string;
+    }) => Promise<void>;
+    onLog: (handler: (e: {
+        level: "debug" | "info" | "warn" | "error";
+        msg: string;
+        meta?: any;
+        raw: any;
+    }) => void) => any;
+    onJobLog: (_jobId: string, _handler: (e: {
+        level: "debug" | "info" | "warn" | "error";
+        msg: string;
+        meta?: any;
+        raw: any;
+    }) => void) => () => void;
+    onFlowLog: (flowId: string, handler: (e: {
+        level: "debug" | "info" | "warn" | "error";
+        msg: string;
+        meta?: any;
+        raw: any;
+    }) => void) => any;
+};

package/dist/runtime/server/utils/useLogs.js

@@ -0,0 +1,74 @@
+import { useEventManager, useEventStore } from "#imports";
+export function useLogs() {
+  const eventManager = useEventManager();
+  const store = useEventStore();
+  const names = store.names();
+  async function getJobLogs(_jobId, _opts) {
+    return { items: [], nextFromId: void 0 };
+  }
+  async function getFlowRunLogs(flowId, opts) {
+    const s = names.flow(flowId);
+    const limit = opts?.limit ?? 200;
+    const direction = opts?.direction || "backward";
+    if (opts?.paged) {
+      const page2 = await store.read(s, { limit: limit * 5, fromId: opts?.fromId, direction });
+      const filtered = page2.filter((r) => r?.kind === "runner.log");
+      const items = filtered.slice(0, limit);
+      const nextFromId = page2.length >= limit * 5 ? page2[page2.length - 1]?.id : void 0;
+      return { items, nextFromId };
+    }
+    const page = await store.read(s, { limit, fromId: opts?.fromId, direction });
+    return page.filter((r) => r?.kind === "runner.log").slice(0, limit);
+  }
+  async function publishLog(level, msg, meta, ctx) {
+    const reserved = /* @__PURE__ */ new Set(["flowId", "flowName", "stepName", "stepRunId", "stepId", "attempt", "jobId", "queue", "tags"]);
+    const envMeta = {};
+    const dataMeta = {};
+    const src = meta || {};
+    for (const k of Object.keys(src)) {
+      if (reserved.has(k)) envMeta[k] = src[k];
+      else dataMeta[k] = src[k];
+    }
+    if (ctx?.flowId && envMeta.flowId == null) envMeta.flowId = ctx.flowId;
+    const runId = ctx?.flowId || "unknown";
+    const flowName = envMeta.flowName || "unknown";
+    const stepName = envMeta.stepName;
+    const stepId = envMeta.stepId || envMeta.stepRunId;
+    const attempt = envMeta.attempt;
+    await eventManager.publishBus({
+      type: "log",
+      runId,
+      flowName,
+      stepName,
+      stepId,
+      attempt,
+      data: { level, message: msg, ...dataMeta }
+    });
+  }
+  function onLog(handler) {
+    return eventManager.onType("log", (evt) => {
+      const d = evt?.data || {};
+      handler({ level: d.level, msg: d.message || d.msg, meta: d.meta, raw: evt });
+    });
+  }
+  function onJobLog(_jobId, _handler) {
+    return () => {
+    };
+  }
+  function onFlowLog(flowId, handler) {
+    const s = names.flow(flowId);
+    return store.subscribe(s, (evt) => {
+      if (evt?.kind !== "runner.log") return;
+      const d = evt?.data || {};
+      handler({ level: d.level, msg: d.msg, meta: d.meta, raw: evt });
+    });
+  }
+  return {
+    getJobLogs,
+    getFlowRunLogs,
+    publishLog,
+    onLog,
+    onJobLog,
+    onFlowLog
+  };
+}

package/dist/runtime/server/utils/useQueue.d.ts

@@ -0,0 +1,31 @@
+import type { QueueEvent, JobsQuery, ScheduleOptions, JobInput, JobCounts } from '../queue/types.js';
+export declare const useQueue: () => {
+    enqueue: (queue: string, job: JobInput) => Promise<string>;
+    schedule: (queue: string, job: JobInput, opts?: ScheduleOptions) => Promise<string>;
+    getJob: (queue: string, id: string) => Promise<import("../queue/types.js").Job | null>;
+    getJobs: (queue: string, q?: JobsQuery) => Promise<import("../queue/types.js").Job[]>;
+    on: (queue: string, event: QueueEvent, cb: (p: any) => void) => () => void;
+    pause: (queue: string) => Promise<void>;
+    resume: (queue: string) => Promise<void>;
+    getJobCounts: (queue: string) => Promise<Record<string, number>> | {
+        new (executor: (resolve: (value: JobCounts | PromiseLike<JobCounts>) => void, reject: (reason?: any) => void) => void): Promise<JobCounts>;
+        all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
+        all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
+        race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+        readonly prototype: Promise<any>;
+        reject<T = never>(reason?: any): Promise<T>;
+        resolve(): Promise<void>;
+        resolve<T>(value: T): Promise<Awaited<T>>;
+        resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
+        allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
+        allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
+        any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+        any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+        withResolvers<T>(): PromiseWithResolvers<T>;
+        try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): Promise<Awaited<T>>;
+        readonly [Symbol.species]: PromiseConstructor;
+    };
+    isPaused: (queue: string) => Promise<any>;
+    close: () => Promise<void>;
+};

package/dist/runtime/server/utils/useQueue.js

@@ -0,0 +1,24 @@
+import { getQueueProvider } from "../queue/queueFactory.js";
+export const useQueue = () => {
+  const provider = getQueueProvider();
+  return {
+    // Enqueue immediately
+    enqueue: (queue, job) => provider.enqueue(queue, job),
+    // Schedule with optional delay or cron
+    schedule: (queue, job, opts) => provider.schedule(queue, job, opts),
+    // Fetch single job
+    getJob: (queue, id) => provider.getJob(queue, id),
+    // List jobs (provider decides states/pagination)
+    getJobs: (queue, q) => provider.getJobs(queue, q),
+    // Subscribe to provider-agnostic events
+    on: (queue, event, cb) => provider.on(queue, event, cb),
+    // Operational controls
+    pause: (queue) => provider.pause(queue),
+    resume: (queue) => provider.resume(queue),
+    // Optional helpers if provider exposes them
+    getJobCounts: (queue) => provider.getJobCounts ? provider.getJobCounts(queue) : Promise,
+    isPaused: (queue) => provider.isPaused ? provider.isPaused(queue) : Promise.resolve(void 0),
+    // Provider lifecycle (normally handled by plugin/provider)
+    close: () => provider.close()
+  };
+};

package/dist/runtime/server/utils/useServerLogger.d.ts

@@ -0,0 +1,42 @@
+import { type ConsolaInstance } from 'consola';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface ServerLogger {
+    debug: (message: string, context?: any) => void;
+    info: (message: string, context?: any) => void;
+    warn: (message: string, context?: any) => void;
+    error: (message: string, context?: any) => void;
+    log: (level: LogLevel, message: string, context?: any) => void;
+    isEnabled: (level: LogLevel) => boolean;
+    consola: ConsolaInstance;
+}
+/**
+ * Creates a contextual server logger with configurable log levels
+ * Uses consola for beautiful, styled console output with colors and icons
+ *
+ * Configuration via runtime config or environment variables:
+ * - queue.debug.level: 'debug' | 'info' | 'warn' | 'error' | 'silent'
+ * - queue.debug.<scope>: boolean (enables debug logging for specific scope)
+ * - NQ_DEBUG_LEVEL: environment variable override
+ * - NQ_DEBUG_<SCOPE>: environment variable for scope (e.g., NQ_DEBUG_FLOW_WIRING=1)
+ *
+ * @param scope - Logger scope/namespace (e.g., 'flow-wiring', 'event-manager')
+ * @returns ServerLogger instance with scoped logging methods
+ *
+ * @example
+ * ```ts
+ * const logger = useServerLogger('flow-wiring')
+ * logger.debug('Step triggered', { stepName: 'process', runId: '123' })
+ * logger.info('Flow completed', { flowName: 'example' })
+ * logger.warn('Retry attempt', { attempt: 3 })
+ * logger.error('Processing failed', { error: err.message })
+ *
+ * // Access consola instance for advanced features
+ * logger.consola.success('All steps completed!')
+ * logger.consola.box('🚀 Flow Started')
+ * ```
+ */
+export declare function useServerLogger(scope: string): ServerLogger;
+/**
+ * Type guard to check if debug logging is enabled for any scope
+ */
+export declare function isDebugEnabled(): boolean;