nuxt-processor 0.0.3 → 0.0.4

package/README.md

@@ -12,7 +12,7 @@ Background job processing for Nuxt using BullMQ with a dedicated workers process
 Note: This package is under very active development! Please consider creating issues if you run into anything!
 
 - [✨  Release Notes](/CHANGELOG.md)
-<!-- - [📖 &nbsp;Documentation](https://example.com) -->
+- [📖 &nbsp;Documentation](https://aidanhibbard.github.io/nuxt-processor/)
 
 ## Features
 
@@ -26,6 +26,7 @@ Note: This package is under very active development! Please consider creating is
 - [Define a queue and enqueue from your app](#define-a-queue-and-enqueue-from-your-app)
 - [Define a worker](#define-a-worker)
 - [Running](#running)
+- [CLI](#cli)
 - [Bull Board](#bull-board)
 - [Contribution](#contribution)
 
@@ -92,6 +93,33 @@ nuxi dev
 node .nuxt/dev/workers/index.mjs
 ```
 
+### CLI
+
+A simple CLI is provided to run workers in development.
+
+```bash
+# from your project root
+npx nuxt-processor dev
+```
+
+Notes:
+- If `.nuxt/dev/workers/index.mjs` does not exist yet, the CLI will ask you to start your Nuxt dev server first to generate the entry point for your workers.
+- If your `package.json` does not have a `processor:dev` script, the CLI will offer to add:
+
+```json
+{
+  "scripts": {
+    "processor:dev": "nuxt-processor dev"
+  }
+}
+```
+
+Then you can run:
+
+```bash
+npm run processor:dev
+```
+
 - After building for production, run workers from `.output/server/workers/index.mjs`:
 
 ```bash

package/bin/nuxt-processor.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+process._startTime = Date.now()
+import('../dist/cli.mjs').then(r => (r.default || r).main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+}))

package/dist/cli.cjs

@@ -0,0 +1,152 @@
+'use strict';
+
+const node_child_process = require('node:child_process');
+const node_fs = require('node:fs');
+const promises = require('node:readline/promises');
+const node_process = require('node:process');
+const pathe = require('pathe');
+const consola = require('consola');
+const citty = require('citty');
+const kit = require('@nuxt/kit');
+const _package = require('./shared/nuxt-processor.BqsFQtIQ.cjs');
+
+const ensureNuxtProject = async (args) => {
+  const dir = pathe.resolve(args.dir);
+  const nuxtConfig = await kit.loadNuxtConfig({ cwd: dir });
+  if (!nuxtConfig || !nuxtConfig._layers[0]?.configFile) {
+    consola.consola.error("You are not in a Nuxt project.");
+    process.exit();
+  }
+};
+
+const main = citty.createMain({
+  meta: {
+    name: _package.name,
+    description: _package.description,
+    version: _package.version
+  },
+  subCommands: {
+    dev: citty.defineCommand({
+      meta: {
+        name: "dev",
+        description: "Run workers with HMR from .nuxt/dev/workers/index.mjs"
+      },
+      args: {
+        dir: {
+          type: "positional",
+          default: "."
+        },
+        nodeArgs: {
+          type: "string",
+          description: "Extra Node args (e.g. --inspect)"
+        }
+      },
+      async run({ args }) {
+        const dirArg = typeof args.dir === "string" ? args.dir : ".";
+        await ensureNuxtProject({ dir: dirArg });
+        const projectRoot = pathe.resolve(dirArg);
+        const indexFile = pathe.resolve(projectRoot, ".nuxt/dev/workers/index.mjs");
+        const watchDir = pathe.resolve(projectRoot, ".nuxt/dev/workers");
+        if (node_fs.existsSync(indexFile)) {
+          const pkgPath = pathe.resolve(projectRoot, "package.json");
+          if (node_fs.existsSync(pkgPath)) {
+            try {
+              const pkgRaw = JSON.parse(node_fs.readFileSync(pkgPath, "utf8"));
+              const pkg = pkgRaw;
+              const hasProcessorDev = Boolean(pkg && pkg.scripts && pkg.scripts["processor:dev"]);
+              if (!hasProcessorDev) {
+                consola.consola.warn('No "processor:dev" script found in package.json.');
+                const rl = promises.createInterface({ input: node_process.stdin, output: node_process.stdout });
+                const answer = await rl.question("Add script to package.json? (y/N) ");
+                rl.close();
+                const isYes = typeof answer === "string" && /^y(?:es)?$/i.test(answer.trim());
+                if (isYes) {
+                  const updated = {
+                    ...pkg,
+                    scripts: {
+                      ...pkg.scripts || {},
+                      "processor:dev": "nuxt-processor dev"
+                    }
+                  };
+                  try {
+                    node_fs.writeFileSync(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+                    consola.consola.success('Added "processor:dev" script to package.json');
+                  } catch {
+                    consola.consola.error("Failed to write to package.json");
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        if (!node_fs.existsSync(indexFile)) {
+          const pkgPath = pathe.resolve(projectRoot, "package.json");
+          let hasProcessorDev = false;
+          if (node_fs.existsSync(pkgPath)) {
+            try {
+              const pkgRaw = JSON.parse(node_fs.readFileSync(pkgPath, "utf8"));
+              const pkg = pkgRaw;
+              hasProcessorDev = Boolean(pkg && pkg.scripts && pkg.scripts["processor:dev"]);
+              if (!hasProcessorDev) {
+                consola.consola.warn('No "processor:dev" script found in package.json.');
+                const rl = promises.createInterface({ input: node_process.stdin, output: node_process.stdout });
+                const answer = await rl.question("Add script to package.json? (y/N) ");
+                rl.close();
+                const isYes = typeof answer === "string" && /^y(?:es)?$/i.test(answer.trim());
+                if (isYes) {
+                  const updated = {
+                    ...pkg,
+                    scripts: {
+                      ...pkg.scripts || {},
+                      "processor:dev": "nuxt-processor dev"
+                    }
+                  };
+                  try {
+                    node_fs.writeFileSync(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+                    consola.consola.success('Added "processor:dev" script to package.json');
+                  } catch {
+                    consola.consola.error("Failed to write to package.json");
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+          consola.consola.error("No entry file found at .nuxt/dev/workers/index.mjs");
+          consola.consola.info("Please start your Nuxt dev server (e.g. `npm run dev`).");
+          consola.consola.info("After it starts, run `npx nuxt-processor dev` again to start the processor.");
+          process.exit(1);
+        }
+        const nodeBin = process.execPath;
+        const nodeArgsInput = Array.isArray(args.nodeArgs) ? args.nodeArgs : typeof args.nodeArgs === "string" ? args.nodeArgs.split(" ") : [];
+        const extraArgs = nodeArgsInput.filter(Boolean);
+        const nodeArgs = [
+          ...extraArgs,
+          "--watch",
+          "--watch-path",
+          watchDir,
+          indexFile
+        ];
+        consola.consola.info(`Running watcher for processor`);
+        const child = node_child_process.spawn(nodeBin, nodeArgs, {
+          stdio: "inherit",
+          cwd: projectRoot,
+          env: process.env
+        });
+        const onSignal = (signal) => {
+          if (!child.killed) {
+            child.kill(signal);
+          }
+        };
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+        child.on("exit", (code) => {
+          process.exit(code ?? 0);
+        });
+      }
+    })
+  }
+});
+
+exports.main = main;

package/dist/cli.d.cts

@@ -0,0 +1,5 @@
+import * as citty from 'citty';
+
+declare const main: (opts?: citty.RunMainOptions) => Promise<void>;
+
+export { main };

package/dist/cli.d.mts

@@ -0,0 +1,5 @@
+import * as citty from 'citty';
+
+declare const main: (opts?: citty.RunMainOptions) => Promise<void>;
+
+export { main };

package/dist/cli.mjs

@@ -0,0 +1,150 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import { stdout, stdin } from 'node:process';
+import { resolve } from 'pathe';
+import { consola } from 'consola';
+import { createMain, defineCommand } from 'citty';
+import { loadNuxtConfig } from '@nuxt/kit';
+import { v as version, d as description, n as name } from './shared/nuxt-processor.BDPWtq8T.mjs';
+
+const ensureNuxtProject = async (args) => {
+  const dir = resolve(args.dir);
+  const nuxtConfig = await loadNuxtConfig({ cwd: dir });
+  if (!nuxtConfig || !nuxtConfig._layers[0]?.configFile) {
+    consola.error("You are not in a Nuxt project.");
+    process.exit();
+  }
+};
+
+const main = createMain({
+  meta: {
+    name,
+    description,
+    version
+  },
+  subCommands: {
+    dev: defineCommand({
+      meta: {
+        name: "dev",
+        description: "Run workers with HMR from .nuxt/dev/workers/index.mjs"
+      },
+      args: {
+        dir: {
+          type: "positional",
+          default: "."
+        },
+        nodeArgs: {
+          type: "string",
+          description: "Extra Node args (e.g. --inspect)"
+        }
+      },
+      async run({ args }) {
+        const dirArg = typeof args.dir === "string" ? args.dir : ".";
+        await ensureNuxtProject({ dir: dirArg });
+        const projectRoot = resolve(dirArg);
+        const indexFile = resolve(projectRoot, ".nuxt/dev/workers/index.mjs");
+        const watchDir = resolve(projectRoot, ".nuxt/dev/workers");
+        if (existsSync(indexFile)) {
+          const pkgPath = resolve(projectRoot, "package.json");
+          if (existsSync(pkgPath)) {
+            try {
+              const pkgRaw = JSON.parse(readFileSync(pkgPath, "utf8"));
+              const pkg = pkgRaw;
+              const hasProcessorDev = Boolean(pkg && pkg.scripts && pkg.scripts["processor:dev"]);
+              if (!hasProcessorDev) {
+                consola.warn('No "processor:dev" script found in package.json.');
+                const rl = createInterface({ input: stdin, output: stdout });
+                const answer = await rl.question("Add script to package.json? (y/N) ");
+                rl.close();
+                const isYes = typeof answer === "string" && /^y(?:es)?$/i.test(answer.trim());
+                if (isYes) {
+                  const updated = {
+                    ...pkg,
+                    scripts: {
+                      ...pkg.scripts || {},
+                      "processor:dev": "nuxt-processor dev"
+                    }
+                  };
+                  try {
+                    writeFileSync(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+                    consola.success('Added "processor:dev" script to package.json');
+                  } catch {
+                    consola.error("Failed to write to package.json");
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        if (!existsSync(indexFile)) {
+          const pkgPath = resolve(projectRoot, "package.json");
+          let hasProcessorDev = false;
+          if (existsSync(pkgPath)) {
+            try {
+              const pkgRaw = JSON.parse(readFileSync(pkgPath, "utf8"));
+              const pkg = pkgRaw;
+              hasProcessorDev = Boolean(pkg && pkg.scripts && pkg.scripts["processor:dev"]);
+              if (!hasProcessorDev) {
+                consola.warn('No "processor:dev" script found in package.json.');
+                const rl = createInterface({ input: stdin, output: stdout });
+                const answer = await rl.question("Add script to package.json? (y/N) ");
+                rl.close();
+                const isYes = typeof answer === "string" && /^y(?:es)?$/i.test(answer.trim());
+                if (isYes) {
+                  const updated = {
+                    ...pkg,
+                    scripts: {
+                      ...pkg.scripts || {},
+                      "processor:dev": "nuxt-processor dev"
+                    }
+                  };
+                  try {
+                    writeFileSync(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+                    consola.success('Added "processor:dev" script to package.json');
+                  } catch {
+                    consola.error("Failed to write to package.json");
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+          consola.error("No entry file found at .nuxt/dev/workers/index.mjs");
+          consola.info("Please start your Nuxt dev server (e.g. `npm run dev`).");
+          consola.info("After it starts, run `npx nuxt-processor dev` again to start the processor.");
+          process.exit(1);
+        }
+        const nodeBin = process.execPath;
+        const nodeArgsInput = Array.isArray(args.nodeArgs) ? args.nodeArgs : typeof args.nodeArgs === "string" ? args.nodeArgs.split(" ") : [];
+        const extraArgs = nodeArgsInput.filter(Boolean);
+        const nodeArgs = [
+          ...extraArgs,
+          "--watch",
+          "--watch-path",
+          watchDir,
+          indexFile
+        ];
+        consola.info(`Running watcher for processor`);
+        const child = spawn(nodeBin, nodeArgs, {
+          stdio: "inherit",
+          cwd: projectRoot,
+          env: process.env
+        });
+        const onSignal = (signal) => {
+          if (!child.killed) {
+            child.kill(signal);
+          }
+        };
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+        child.on("exit", (code) => {
+          process.exit(code ?? 0);
+        });
+      }
+    })
+  }
+});
+
+export { main };

package/dist/module.cjs

@@ -0,0 +1,229 @@
+'use strict';
+
+const kit = require('@nuxt/kit');
+const _package = require('./shared/nuxt-processor.BqsFQtIQ.cjs');
+const node_path = require('node:path');
+const fg = require('fast-glob');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
+
+const scanFolder = async (path) => {
+  const nuxt = kit.useNuxt();
+  const { resolve } = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+  const resolvedPath = resolve(nuxt.options.rootDir, path);
+  const files = [];
+  const updatedFiles = await fg__default("**/*.{ts,js,mjs}", {
+    cwd: resolvedPath,
+    absolute: true,
+    onlyFiles: true
+  });
+  files.push(...new Set(updatedFiles));
+  return files;
+};
+
+const module$1 = kit.defineNuxtModule({
+  meta: {
+    name: _package.name,
+    version: _package.version,
+    compatibility: _package.compatibility,
+    configKey: _package.configKey
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    redis: {
+      host: process.env.NUXT_REDIS_HOST ?? "127.0.0.1",
+      port: Number(process.env.NUXT_REDIS_PORT ?? 6379),
+      password: process.env.NUXT_REDIS_PASSWORD ?? ""
+    },
+    workers: "server/workers"
+  },
+  async setup(_options, _nuxt) {
+    const { resolve } = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+    const buildDir = _nuxt.options.buildDir;
+    function generateWorkersEntryContent(workerFiles) {
+      const redisInline = JSON.stringify(_options.redis ?? {});
+      const toImportArray = workerFiles.map((id) => `() => import(${JSON.stringify(id)})`).join(",\n    ");
+      return `
+import { fileURLToPath } from 'node:url'
+import { resolve as resolvePath } from 'node:path'
+import { consola } from 'consola'
+import { $workers } from '#processor-utils'
+
+// Initialize connection as early as possible so any imports that register
+// workers/queues have a valid connection available.
+const api = $workers()
+api.setConnection(${redisInline})
+
+export async function createWorkersApp() {
+  // Avoid EPIPE when stdout/stderr are closed by terminal (e.g., Ctrl+C piping)
+  const handleStreamError = (err) => {
+    try {
+      const code = (typeof err === 'object' && err && 'code' in err) ? err.code : null
+      if (code === 'EPIPE') return
+    } catch (e) { console.warn?.('nuxt-processor: stream error inspection failed', e) }
+    throw err
+  }
+  try { process.stdout?.on?.('error', handleStreamError) } catch (err) { console.warn('nuxt-processor: failed to attach stdout error handler', err) }
+  try { process.stderr?.on?.('error', handleStreamError) } catch (err) { console.warn('nuxt-processor: failed to attach stderr error handler', err) }
+  const modules = [
+    ${toImportArray}
+  ]
+  for (const loader of modules) {
+    await loader()
+  }
+  const logger = consola.create({}).withTag('nuxt-processor')
+  try {
+    const workerNames = Array.isArray(api.workers) ? api.workers.map(w => w && w.name).filter(Boolean) : []
+    logger.info('starting workers:\\n' + workerNames.map(n => ' - ' + n).join('\\n'))
+    for (const w of api.workers) {
+      w.on('error', (err) => logger.error('worker error', err))
+    }
+    // Explicitly start workers since autorun is disabled
+    for (const w of api.workers) {
+      try {
+        // run() returns a promise that resolves when the worker stops; do not await to avoid blocking
+        // eslint-disable-next-line promise/catch-or-return
+        w.run().catch((err) => logger.error('worker run error', err))
+      }
+      catch (err) {
+        logger.error('failed to start worker', err)
+      }
+    }
+    logger.success('workers started')
+  } catch (err) {
+    logger.error('failed to initialize workers', err)
+  }
+  return { stop: api.stopAll, workers: api.workers }
+}
+
+const isMain = (() => {
+  try {
+    if (typeof process === 'undefined' || !process.argv || !process.argv[1]) return false
+    const argvPath = resolvePath(process.cwd?.() || '.', process.argv[1])
+    const filePath = fileURLToPath(import.meta.url)
+    return filePath === argvPath
+  } catch {
+    return false
+  }
+})()
+if (isMain) {
+  const logger = consola.create({}).withTag('nuxt-processor')
+  const appPromise = createWorkersApp().catch((err) => {
+    logger.error('failed to start workers', err)
+    process.exit(1)
+  })
+  const shutdown = async () => {
+    try { logger.info('closing workers...') } catch (err) { console.warn('nuxt-processor: failed to log shutdown start', err) }
+    try {
+      const app = await appPromise
+      try {
+        const names = (app?.workers || []).map(w => w && w.name).filter(Boolean)
+        logger.info('closing workers:\\n' + names.map(n => ' - ' + n).join('\\n'))
+      } catch (eL) { console.warn('nuxt-processor: failed to log workers list on shutdown', eL) }
+      await app.stop()
+      try { logger.success('workers closed') } catch (err2) { console.warn('nuxt-processor: failed to log shutdown complete', err2) }
+    }
+    finally { process.exit(0) }
+  }
+  ;['SIGINT','SIGTERM','SIGQUIT'].forEach(sig => process.on(sig, shutdown))
+  process.on('beforeExit', shutdown)
+}
+
+export default { createWorkersApp }
+`;
+    }
+    _nuxt.options.alias = _nuxt.options.alias ?? {};
+    _nuxt.options.alias["nuxt-processor"] = resolve("./runtime/server/handlers");
+    _nuxt.options.alias["#processor"] = resolve("./runtime/server/handlers");
+    _nuxt.options.alias["#processor-utils"] = resolve("./runtime/server/utils/workers");
+    if (!_nuxt.options.alias["#bullmq"]) {
+      _nuxt.options.alias["#bullmq"] = "bullmq";
+    }
+    const typesDtsPath = kit.addTemplate({
+      filename: "types/nuxt-processor.d.ts",
+      write: true,
+      getContents: () => `
+declare module 'nuxt-processor' {
+  export { defineQueue } from '${resolve("./runtime/server/handlers/defineQueue")}'
+  export { defineWorker } from '${resolve("./runtime/server/handlers/defineWorker")}'
+}
+
+declare module '#processor' {
+  export { defineQueue } from '${resolve("./runtime/server/handlers/defineQueue")}'
+  export { defineWorker } from '${resolve("./runtime/server/handlers/defineWorker")}'
+}
+
+declare module '#processor-utils' {
+  export { $workers } from '${resolve("./runtime/server/utils/workers")}'
+}
+
+declare module '#bullmq' {
+  export * from 'bullmq'
+}
+`
+    }).dst;
+    _nuxt.hooks.hook("prepare:types", (opts) => {
+      if (!opts.tsConfig.include) opts.tsConfig.include = [];
+      opts.tsConfig.include.push(resolve(buildDir, typesDtsPath));
+    });
+    function createWorkersRollupPlugin() {
+      const VIRTUAL_ID = "\0nuxt-processor-entry";
+      let virtualCode = "";
+      let entryRefId = null;
+      return {
+        name: "nuxt-processor-emit",
+        async buildStart() {
+          const workerFiles = await scanFolder(_options.workers);
+          if (workerFiles.length === 0) {
+            virtualCode = "";
+            return;
+          }
+          virtualCode = generateWorkersEntryContent(workerFiles);
+          for (const id of workerFiles) {
+            this.addWatchFile(id);
+          }
+          entryRefId = this.emitFile({ type: "chunk", id: VIRTUAL_ID, fileName: "workers/_entry.mjs" });
+        },
+        resolveId(id) {
+          if (id === VIRTUAL_ID) return VIRTUAL_ID;
+        },
+        load(id) {
+          if (id === VIRTUAL_ID) return virtualCode || "export {}\n";
+        },
+        generateBundle() {
+          if (!virtualCode || !entryRefId) return;
+          const entryFile = this.getFileName(entryRefId);
+          const fromDir = "workers";
+          const rel = "./" + node_path.relative(fromDir, entryFile).split("\\").join("/");
+          const wrapper = `import { createWorkersApp } from '${rel}'
+import { consola } from 'consola'
+const logger = consola.create({}).withTag('nuxt-processor')
+const appPromise = createWorkersApp().catch((err) => { logger.error('failed to start workers', err); process.exit(1) })
+let shuttingDown = false
+const shutdown = async (signal) => { if (shuttingDown) return; shuttingDown = true; try { logger.info('closing workers' + (signal ? ' ('+signal+')' : '') + '...') } catch (e) { console.warn('nuxt-processor: failed to log shutdown start', e) } ; try { const app = await appPromise; try { const names = (app?.workers || []).map(w => w && w.name).filter(Boolean); logger.info('closing workers:\\n' + names.map(n => ' - ' + n).join('\\n')) } catch (eL) { console.warn('nuxt-processor: failed to log workers list on shutdown', eL) } await app.stop(); try { logger.success('workers closed') } catch (e2) { console.warn('nuxt-processor: failed to log shutdown complete', e2) } } catch (err) { try { logger.error('shutdown error', err) } catch (e3) { console.warn('nuxt-processor: failed to log shutdown error', e3) } } finally { setTimeout(() => process.exit(0), 0) } }
+[ 'SIGINT','SIGTERM','SIGQUIT' ].forEach(sig => process.on(sig, () => shutdown(sig)))
+process.on('beforeExit', () => shutdown('beforeExit'))
+`;
+          this.emitFile({ type: "asset", fileName: "workers/index.mjs", source: wrapper });
+        }
+      };
+    }
+    _nuxt.hooks.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.rollupConfig = nitroConfig.rollupConfig ?? {};
+      const plugin = createWorkersRollupPlugin();
+      const current = nitroConfig.rollupConfig.plugins;
+      if (Array.isArray(current)) {
+        nitroConfig.rollupConfig.plugins = [...current, plugin];
+      } else if (current) {
+        nitroConfig.rollupConfig.plugins = [current, plugin];
+      } else {
+        nitroConfig.rollupConfig.plugins = [plugin];
+      }
+    });
+  }
+});
+
+module.exports = module$1;

package/dist/module.d.cts

@@ -0,0 +1,16 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { RedisOptions } from 'bullmq';
+
+interface ModuleOptions {
+    redis: RedisOptions;
+    /**
+     * The folder containing the worker files
+     * Scans for {ts,js,mjs}
+     * @default 'server/workers'
+     */
+    workers: string;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export = _default;
+export type { ModuleOptions };

package/dist/module.json

@@ -1,8 +1,8 @@
 {
   "name": "nuxt-processor",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "compatibility": {
-    "nuxt": "^4.0.0"
+    "nuxt": "^4.0.0 || ^3.0.0"
   },
   "configKey": "processor",
   "builder": {

package/dist/module.mjs

@@ -1,14 +1,8 @@
 import { useNuxt, createResolver, defineNuxtModule, addTemplate } from '@nuxt/kit';
+import { c as configKey, a as compatibility, v as version, n as name } from './shared/nuxt-processor.BDPWtq8T.mjs';
 import { relative } from 'node:path';
 import fg from 'fast-glob';
 
-const name = "nuxt-processor";
-const version = "0.0.3";
-const configKey = "processor";
-const compatibility = {
-	nuxt: "^4.0.0"
-};
-
 const scanFolder = async (path) => {
   const nuxt = useNuxt();
   const { resolve } = createResolver(import.meta.url);

package/dist/shared/nuxt-processor.BDPWtq8T.mjs

@@ -0,0 +1,9 @@
+const name = "nuxt-processor";
+const version = "0.0.4";
+const description = "Nuxt Processor";
+const configKey = "processor";
+const compatibility = {
+	nuxt: "^4.0.0 || ^3.0.0"
+};
+
+export { compatibility as a, configKey as c, description as d, name as n, version as v };

package/dist/shared/nuxt-processor.BqsFQtIQ.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const name = "nuxt-processor";
+const version = "0.0.4";
+const description = "Nuxt Processor";
+const configKey = "processor";
+const compatibility = {
+	nuxt: "^4.0.0 || ^3.0.0"
+};
+
+exports.compatibility = compatibility;
+exports.configKey = configKey;
+exports.description = description;
+exports.name = name;
+exports.version = version;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "nuxt-processor",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Nuxt Processor",
   "repository": "https://github.com/aidanhibbard/nuxt-processor",
   "license": "MIT",
   "type": "module",
   "configKey": "processor",
   "compatibility": {
-    "nuxt": "^4.0.0"
+    "nuxt": "^4.0.0 || ^3.0.0"
   },
   "exports": {
     ".": {
@@ -23,8 +23,12 @@
       ]
     }
   },
+  "bin": {
+    "nuxt-processor": "./bin/nuxt-processor.mjs"
+  },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "prepack": "nuxt-module-build build",
@@ -42,9 +46,12 @@
   },
   "dependencies": {
     "@nuxt/kit": "^4.0.3",
+    "citty": "^0.1.6",
+    "consola": "^3.2.3",
     "bullmq": "^5.58.2",
     "fast-glob": "^3.3.3",
-    "ioredis": "^5.7.0"
+    "ioredis": "^5.7.0",
+    "pathe": "^1.1.2"
   },
   "devDependencies": {
     "@nuxt/devtools": "^2.6.3",