nvent 0.4.3 → 0.4.5

package/dist/runtime/server/api/_flows/ws.js

@@ -1,8 +1,10 @@
 import {
   defineWebSocketHandler,
-  useEventStore,
   usePeerManager,
-  useNventLogger
+  useNventLogger,
+  useStreamAdapter,
+  useStoreAdapter,
+  useStreamTopics
 } from "#imports";
 const peerContexts = /* @__PURE__ */ new WeakMap();
 function safeSend(peer, data) {
@@ -14,7 +16,7 @@ function safeSend(peer, data) {
   }
 }
 export default defineWebSocketHandler({
-  open(peer) {
+  async open(peer) {
     const logger = useNventLogger("api-flows-ws");
     logger.info("[ws] client connected:", { peerId: peer.id });
     const { registerWsPeer } = usePeerManager();
@@ -53,19 +55,37 @@ export default defineWebSocketHandler({
         });
         return;
       }
-      const store = useEventStore();
-      const names = store.names();
-      const flowStream = names.flow(runId);
+      let stream;
+      let store;
+      try {
+        stream = useStreamAdapter();
+        store = useStoreAdapter();
+      } catch (err) {
+        logger.error("[ws] Adapters not initialized yet:", { error: err });
+        safeSend(peer, {
+          type: "error",
+          message: "Server initializing, please retry"
+        });
+        return;
+      }
       const subscriptionKey = `${flowName}:${runId}`;
-      const existingUnsub = context.subscriptions.get(subscriptionKey);
-      if (existingUnsub) {
+      const existingHandle = context.subscriptions.get(subscriptionKey);
+      if (existingHandle) {
         try {
-          existingUnsub();
+          await existingHandle.unsubscribe();
         } catch (err) {
           logger.error("[ws] error unsubscribing:", { error: err });
         }
       }
-      const unsub = store.subscribe(flowStream, async (event) => {
+      const { SubjectPatterns, getClientFlowTopic } = useStreamTopics();
+      const subject = SubjectPatterns.flowRun(runId);
+      const topic = getClientFlowTopic(runId);
+      const handle = await stream.subscribe(topic, async (message2) => {
+        const event = message2.data?.event;
+        if (!event) {
+          logger.warn("[ws] Received message without event data:", message2);
+          return;
+        }
         safeSend(peer, {
           type: "event",
           flowName,
@@ -77,11 +97,12 @@ export default defineWebSocketHandler({
           }
         });
       });
-      context.subscriptions.set(subscriptionKey, unsub);
+      context.subscriptions.set(subscriptionKey, handle);
       try {
-        const historicalEvents = await store.read(flowStream, {
+        const historicalEvents = await store.read(subject, {
           limit: 100,
-          direction: "forward"
+          order: "asc"
+          // forward order
         });
         safeSend(peer, {
           type: "history",
@@ -114,10 +135,10 @@ export default defineWebSocketHandler({
         return;
       }
       const subscriptionKey = `${flowName}:${runId}`;
-      const unsub = context.subscriptions.get(subscriptionKey);
-      if (unsub) {
+      const handle = context.subscriptions.get(subscriptionKey);
+      if (handle) {
         try {
-          unsub();
+          await handle.unsubscribe();
           context.subscriptions.delete(subscriptionKey);
           safeSend(peer, {
             type: "unsubscribed",
@@ -144,7 +165,7 @@ export default defineWebSocketHandler({
       });
     }
   },
-  close(peer, event) {
+  async close(peer, event) {
     const logger = useNventLogger("api-flows-ws");
     const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
     if (!isNormalClosure) {
@@ -154,9 +175,9 @@ export default defineWebSocketHandler({
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {
-      for (const unsub of context.subscriptions.values()) {
+      for (const handle of Array.from(context.subscriptions.values())) {
         try {
-          unsub();
+          await handle.unsubscribe();
         } catch (err) {
           if (!isNormalClosure) {
             logger.error("[ws] error unsubscribing on close:", { error: err });
@@ -167,16 +188,16 @@ export default defineWebSocketHandler({
       peerContexts.delete(peer);
     }
   },
-  error(peer, error) {
+  async error(peer, error) {
     const logger = useNventLogger("api-flows-ws");
     logger.error("[ws] error for peer:", { peerId: peer.id, error });
     const { unregisterWsPeer } = usePeerManager();
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {
-      for (const unsub of context.subscriptions.values()) {
+      for (const handle of Array.from(context.subscriptions.values())) {
         try {
-          unsub();
+          await handle.unsubscribe();
         } catch (err) {
           logger.error("[ws] error unsubscribing on error:", { error: err });
         }

package/dist/runtime/server/api/_queues/[name]/job/[id].get.js

@@ -1,9 +1,14 @@
-import { defineEventHandler, getRouterParam, useQueue } from "#imports";
+import { defineEventHandler, getRouterParam, useQueueAdapter } from "#imports";
 export default defineEventHandler(async (event) => {
   const name = getRouterParam(event, "name") || "";
   const id = getRouterParam(event, "id") || "";
-  const { getJob } = useQueue();
-  const job = await getJob(name, id);
+  let queue;
+  try {
+    queue = useQueueAdapter();
+  } catch {
+    return null;
+  }
+  const job = await queue.getJob(name, id);
   if (!job) return null;
   return { ...job, queue: name };
 });

package/dist/runtime/server/api/_queues/[name]/job/index.get.js

@@ -1,4 +1,4 @@
-import { defineEventHandler, getRouterParam, getQuery, useQueue, createError } from "#imports";
+import { defineEventHandler, getRouterParam, getQuery, useQueueAdapter, createError } from "#imports";
 export default defineEventHandler(async (event) => {
   const name = getRouterParam(event, "name");
   if (!name) {
@@ -6,8 +6,17 @@ export default defineEventHandler(async (event) => {
   }
   const query = getQuery(event);
   const state = query.state;
-  const { getJobs } = useQueue();
-  const jobs = await getJobs(name, {
+  let queue;
+  try {
+    queue = useQueueAdapter();
+  } catch {
+    throw createError({
+      statusCode: 503,
+      statusMessage: "Server initializing",
+      data: "Queue adapter not ready yet, please retry"
+    });
+  }
+  const jobs = await queue.getJobs(name, {
     state: state ? [state] : void 0,
     limit: 1e3
     // Fetch all jobs, pagination happens client-side

package/dist/runtime/server/api/_queues/index.get.js

@@ -1,12 +1,23 @@
-import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
+import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueueAdapter, useNventLogger } from "#imports";
+const logger = useNventLogger("api-queues-index");
 export default defineEventHandler(async () => {
   const rc = useRuntimeConfig();
-  const logger = useNventLogger("api-queues-index");
-  const cfgQueues = rc?.queue?.queues || {};
   const registry = $useQueueRegistry();
-  const queue = useQueue();
+  let queue;
+  try {
+    queue = useQueueAdapter();
+  } catch (err) {
+    logger.error("[queues/index] Adapters not initialized yet:", { error: err });
+    return [];
+  }
+  const globalQueueConfig = rc?.nvent?.queue || {};
+  const globalWorkerDefaults = globalQueueConfig.worker || {};
+  const globalQueueDefaults = {
+    prefix: globalQueueConfig.prefix,
+    defaultJobOptions: globalQueueConfig.defaultJobOptions,
+    limiter: globalQueueConfig.limiter
+  };
   const names = /* @__PURE__ */ new Set();
-  for (const q in cfgQueues) names.add(q);
   if (registry?.workers?.length) {
     for (const w of registry.workers) names.add(w.queue.name);
   }
@@ -15,27 +26,59 @@ export default defineEventHandler(async () => {
       try {
         const counts = await queue.getJobCounts(name);
         const isPaused = await queue.isPaused(name);
-        const worker = registry?.workers?.find((w) => w.queue.name === name);
-        const queueConfig = worker?.queue || {};
-        const workerConfig = worker?.worker || {};
+        const workers = registry?.workers?.filter((w) => w.queue.name === name) || [];
+        const mergedQueueConfig = workers.reduce((acc, w) => {
+          if (!w.queue) return acc;
+          const result = {
+            ...acc,
+            name: w.queue.name
+          };
+          if (w.queue.prefix && w.queue.prefix !== acc.prefix) {
+            result.prefix = w.queue.prefix;
+          }
+          if (w.queue.limiter) {
+            result.limiter = w.queue.limiter;
+          }
+          if (w.queue.defaultJobOptions) {
+            result.defaultJobOptions = { ...acc.defaultJobOptions };
+            const wOpts = w.queue.defaultJobOptions;
+            const accOpts = acc.defaultJobOptions || {};
+            if (typeof wOpts.attempts === "number") {
+              result.defaultJobOptions.attempts = Math.max(wOpts.attempts, accOpts.attempts || 0);
+            }
+            if (wOpts.backoff) {
+              if (!accOpts.backoff || wOpts.backoff.delay && wOpts.backoff.delay !== globalQueueDefaults.defaultJobOptions?.backoff?.delay) {
+                result.defaultJobOptions.backoff = wOpts.backoff;
+              }
+            }
+            if (typeof wOpts.priority === "number") result.defaultJobOptions.priority = wOpts.priority;
+            if (typeof wOpts.timeout === "number") result.defaultJobOptions.timeout = wOpts.timeout;
+            if (typeof wOpts.delay === "number") result.defaultJobOptions.delay = wOpts.delay;
+            if (typeof wOpts.lifo === "boolean") result.defaultJobOptions.lifo = wOpts.lifo;
+            if (wOpts.removeOnComplete !== void 0) result.defaultJobOptions.removeOnComplete = wOpts.removeOnComplete;
+            if (wOpts.removeOnFail !== void 0) result.defaultJobOptions.removeOnFail = wOpts.removeOnFail;
+          }
+          return result;
+        }, { ...globalQueueDefaults, name });
+        const mergedWorkerConfig = workers.reduce((acc, w) => {
+          if (!w.worker) return acc;
+          return {
+            concurrency: Math.max(acc.concurrency || 0, w.worker.concurrency || 0),
+            // Use max concurrency
+            lockDurationMs: w.worker.lockDurationMs ?? acc.lockDurationMs,
+            maxStalledCount: w.worker.maxStalledCount ?? acc.maxStalledCount,
+            drainDelayMs: w.worker.drainDelayMs ?? acc.drainDelayMs,
+            autorun: w.worker.autorun ?? acc.autorun,
+            pollingIntervalMs: w.worker.pollingIntervalMs ?? acc.pollingIntervalMs
+          };
+        }, { ...globalWorkerDefaults });
         return {
           name,
           counts,
           isPaused,
           config: {
-            queue: {
-              prefix: queueConfig.prefix,
-              defaultJobOptions: queueConfig.defaultJobOptions,
-              limiter: queueConfig.limiter
-            },
-            worker: {
-              concurrency: workerConfig.concurrency,
-              lockDurationMs: workerConfig.lockDurationMs,
-              maxStalledCount: workerConfig.maxStalledCount,
-              drainDelayMs: workerConfig.drainDelayMs,
-              autorun: workerConfig.autorun,
-              pollingIntervalMs: workerConfig.pollingIntervalMs
-            }
+            queue: mergedQueueConfig,
+            worker: mergedWorkerConfig
           }
         };
       } catch (err) {
@@ -52,8 +95,8 @@ export default defineEventHandler(async () => {
           },
           isPaused: false,
           config: {
-            queue: {},
-            worker: {}
+            queue: globalQueueDefaults,
+            worker: globalWorkerDefaults
           }
         };
       }

package/dist/runtime/server/api/_queues/ws.js

@@ -1,6 +1,6 @@
 import {
   defineWebSocketHandler,
-  useQueue,
+  useQueueAdapter,
   usePeerManager,
   useNventLogger
 } from "#imports";
@@ -53,7 +53,17 @@ export default defineWebSocketHandler({
         });
         return;
       }
-      const queue = useQueue();
+      let queue;
+      try {
+        queue = useQueueAdapter();
+      } catch (err) {
+        logger.error("[ws:queues] Adapters not initialized yet:", err);
+        safeSend(peer, {
+          type: "error",
+          message: "Server initializing, please retry"
+        });
+        return;
+      }
       const existingUnsub = context.subscriptions.get(queueName);
       if (existingUnsub) {
         try {
@@ -168,7 +178,7 @@ export default defineWebSocketHandler({
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {
-      for (const unsub of context.subscriptions.values()) {
+      for (const unsub of Array.from(context.subscriptions.values())) {
         try {
           unsub();
         } catch (err) {
@@ -191,7 +201,7 @@ export default defineWebSocketHandler({
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {
-      for (const unsub of context.subscriptions.values()) {
+      for (const unsub of Array.from(context.subscriptions.values())) {
         try {
           unsub();
         } catch (err) {

package/dist/runtime/server/plugins/00.adapters.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapter Initialization Plugin (v0.4.1)
+ *
+ * Initializes the three-adapter architecture with new config format:
+ * - QueueAdapter: Job queue operations (from config.queue)
+ * - StreamAdapter: Cross-instance pub/sub messaging (from config.stream)
+ * - StoreAdapter: Storage - events, documents, KV, indices (from config.store)
+ *
+ * Uses normalized config with connection fallback from connections.*
+ *
+ * External adapters can register themselves via the nvent:registerAdapter Nitro hook
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/00.adapters.js

@@ -0,0 +1,69 @@
+import { defineNitroPlugin, useRuntimeConfig, useNventLogger, setAdapters } from "#imports";
+import { createAdapters, shutdownAdapters } from "../../adapters/factory.js";
+import { useAdapterRegistry } from "../../adapters/registry.js";
+import { createWiringRegistry } from "../../events/wiring/registry.js";
+export default defineNitroPlugin(async (nitroApp) => {
+  const logger = useNventLogger("adapters-plugin");
+  const runtimeConfig = useRuntimeConfig();
+  const config = runtimeConfig.nvent;
+  if (!config) {
+    logger.error("No nvent config found in runtime config");
+    throw new Error("Missing nvent configuration");
+  }
+  logger.info("Initializing adapters", {
+    queue: config.queue?.adapter || "file",
+    stream: config.stream?.adapter || "memory",
+    store: config.store?.adapter || "file"
+  });
+  try {
+    await nitroApp.hooks.callHook("nvent:register-adapters");
+    const registry = useAdapterRegistry();
+    logger.info("Checking registered adapters", {
+      queueAdapters: registry.listQueueAdapters(),
+      streamAdapters: registry.listStreamAdapters(),
+      storeAdapters: registry.listStoreAdapters()
+    });
+    const adapters = await createAdapters({
+      queue: config.queue,
+      stream: config.stream,
+      store: config.store
+    });
+    setAdapters(adapters);
+    logger.info("Adapters initialized successfully", {
+      queueAdapter: config.queue.adapter,
+      streamAdapter: config.stream.adapter,
+      storeAdapter: config.store.adapter
+    });
+    await nitroApp.hooks.callHook("nvent:adapters:ready");
+    const wiring = createWiringRegistry({
+      streamWiring: {
+        enabled: true
+        // Enable for WebSocket support
+      },
+      stateWiring: {
+        // Strategy is read from config by default (queue.store.state.cleanup.strategy)
+        // Can be overridden here if needed
+      }
+    });
+    wiring.start();
+    logger.info("Flow wiring started");
+    return {
+      hooks: {
+        close: async () => {
+          logger.info("Shutting down");
+          try {
+            wiring.stop();
+            logger.info("Flow wiring stopped");
+            await shutdownAdapters(adapters);
+            logger.info("Adapters shut down successfully");
+          } catch (error) {
+            logger.error("Error during shutdown", { error });
+          }
+        }
+      }
+    };
+  } catch (error) {
+    logger.error("Failed to initialize adapters", { error });
+    throw error;
+  }
+});

package/dist/runtime/server/plugins/02.workers.js

@@ -0,0 +1,45 @@
+import { defineNitroPlugin, $useWorkerHandlers, $useQueueRegistry, useQueueAdapter } from "#imports";
+import { createJobProcessor } from "../../worker/node/runner.js";
+export default defineNitroPlugin(async (nitroApp) => {
+  nitroApp.hooks.hook("close", async () => {
+    const queueAdapter = useQueueAdapter();
+    await queueAdapter.close();
+  });
+  nitroApp.hooks.hook("nvent:adapters:ready", async () => {
+    const queueAdapter = useQueueAdapter();
+    try {
+      const handlers = $useWorkerHandlers();
+      const registry = $useQueueRegistry() || { workers: [] };
+      const registeredQueues = /* @__PURE__ */ new Set();
+      for (const entry of handlers) {
+        const { queue, id, handler } = entry;
+        const w = registry.workers.find((rw) => rw?.id === id || rw?.queue?.name === queue && rw?.absPath === entry.absPath);
+        let jobName;
+        if (w?.flow?.step) {
+          jobName = Array.isArray(w.flow.step) ? w.flow.step[0] : w.flow.step;
+        } else {
+          jobName = id.includes("/") ? id.split("/").pop() : id;
+        }
+        if (typeof handler === "function") {
+          const workerCfg = w && w.worker || {};
+          const queueCfg = w && w.queue || {};
+          const opts = {};
+          if (typeof workerCfg.concurrency === "number") opts.concurrency = workerCfg.concurrency;
+          if (typeof workerCfg.autorun === "boolean") opts.autorun = workerCfg.autorun;
+          if (queueCfg.defaultJobOptions) opts.defaultJobOptions = queueCfg.defaultJobOptions;
+          if (queueCfg.prefix) opts.prefix = queueCfg.prefix;
+          if (queueCfg.limiter) opts.limiter = queueCfg.limiter;
+          const processor = createJobProcessor(handler, queue);
+          queueAdapter.registerWorker(queue, jobName, processor, opts);
+          registeredQueues.add(queue);
+        }
+      }
+      if (queueAdapter.startProcessingQueue) {
+        for (const queueName of Array.from(registeredQueues)) {
+          queueAdapter.startProcessingQueue(queueName);
+        }
+      }
+    } catch {
+    }
+  });
+});

package/dist/runtime/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "extends": "../../../../playground/.nuxt/tsconfig.server.json",
+	"include": [
+		"./**/*.ts"
+  	],
+	"exclude": [
+	]
+}

package/dist/runtime/utils/adapters.d.ts

@@ -0,0 +1,66 @@
+import type { QueueAdapter } from '../adapters/interfaces/queue.js';
+import type { StreamAdapter } from '../adapters/interfaces/stream.js';
+import type { StoreAdapter } from '../adapters/interfaces/store.js';
+import type { AdapterSet } from '../adapters/factory.js';
+declare global {
+    var __nq_adapters: AdapterSet | undefined;
+}
+/**
+ * Set the global adapter set (called by plugin during initialization)
+ */
+export declare function setAdapters(adapters: AdapterSet): void;
+/**
+ * Get all adapters (internal use)
+ */
+export declare function getAdapters(): AdapterSet;
+/**
+ * Access QueueAdapter for job queue operations
+ *
+ * @example
+ * const queue = useQueueAdapter()
+ * await queue.enqueue('my-queue', { name: 'job', data: {...} })
+ */
+export declare function useQueueAdapter(): QueueAdapter;
+/**
+ * Access StreamAdapter for cross-instance pub/sub
+ *
+ * @example
+ * const stream = useStreamAdapter()
+ * await stream.subscribe('store:append:*', (event) => {
+ *   console.log('Remote update:', event)
+ * })
+ */
+export declare function useStreamAdapter(): StreamAdapter;
+/**
+ * Access StoreAdapter for storage operations
+ *
+ * @example
+ * const store = useStoreAdapter()
+ * await store.append('nq:flow:abc-123', { type: 'step.completed', data: {...} })
+ * const events = await store.read('nq:flow:abc-123')
+ */
+export declare function useStoreAdapter(): StoreAdapter;
+/**
+ * State provider interface for flow state management
+ */
+export interface StateAdapter {
+    get<T = any>(key: string): Promise<T | null>;
+    set<T = any>(key: string, value: T, opts?: {
+        ttl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(pattern: string): Promise<number>;
+    increment?: (key: string, by?: number) => Promise<number>;
+}
+/**
+ * Access StateAdapter for scoped key-value state storage
+ *
+ * State is backed by StoreAdapter's KV store with automatic namespacing.
+ * Used by worker context (ctx.state) for flow-scoped state management.
+ *
+ * @example
+ * const state = useStateAdapter()
+ * await state.set('lastEmail', { to: 'user@example.com' })
+ * const value = await state.get('lastEmail')
+ */
+export declare function useStateAdapter(): StateAdapter;

package/dist/runtime/utils/adapters.js

@@ -0,0 +1,51 @@
+import { useRuntimeConfig } from "#imports";
+export function setAdapters(adapters) {
+  globalThis.__nq_adapters = adapters;
+}
+export function getAdapters() {
+  if (!globalThis.__nq_adapters) {
+    throw new Error("[nvent] Adapters not initialized. Make sure the nvent plugin is loaded.");
+  }
+  return globalThis.__nq_adapters;
+}
+export function useQueueAdapter() {
+  return getAdapters().queue;
+}
+export function useStreamAdapter() {
+  return getAdapters().stream;
+}
+export function useStoreAdapter() {
+  return getAdapters().store;
+}
+export function useStateAdapter() {
+  const store = useStoreAdapter();
+  let namespace = "nq";
+  try {
+    const rc = useRuntimeConfig();
+    namespace = rc?.nvent?.state?.namespace || "nq";
+  } catch {
+  }
+  return {
+    async get(key) {
+      return store.kv.get(`${namespace}:${key}`);
+    },
+    async set(key, value, opts) {
+      await store.kv.set(`${namespace}:${key}`, value, opts?.ttl);
+    },
+    async delete(key) {
+      await store.kv.delete(`${namespace}:${key}`);
+    },
+    async clear(pattern) {
+      if (!store.kv.clear) {
+        throw new Error("Store adapter does not support clear operation");
+      }
+      return store.kv.clear(`${namespace}:${pattern}`);
+    },
+    increment: store.kv.increment ? async (key, by = 1) => {
+      if (!store.kv.increment) {
+        throw new Error("Store adapter does not support increment operation");
+      }
+      return store.kv.increment(`${namespace}:${key}`, by);
+    } : void 0
+  };
+}

package/dist/runtime/utils/defineFunction.d.ts

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

package/dist/runtime/{server-utils/utils/defineQueueWorker.js → utils/defineFunction.js}

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

package/dist/runtime/{server-utils/utils/defineQueueConfig.d.ts → utils/defineFunctionConfig.d.ts}

@@ -149,6 +149,6 @@ export interface QueueWorkerConfig {
     flow?: FlowConfig;
     worker?: WorkerConfig;
 }
-export type DefineQueueConfig = <T extends QueueWorkerConfig>(cfg: T) => T;
-export declare const defineQueueConfig: DefineQueueConfig;
-export default defineQueueConfig;
+export type DefineFunctionConfig = <T extends QueueWorkerConfig>(cfg: T) => T;
+export declare const defineFunctionConfig: DefineFunctionConfig;
+export default defineFunctionConfig;

package/dist/runtime/utils/defineFunctionConfig.js

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