nvent 0.5.15 → 1.0.0-alpha.2

package/dist/module.mjs

@@ -1,1169 +1,1140 @@
-import { dirname, join, extname, relative } from 'node:path';
-import { useLogger, defineNuxtModule, createResolver, addTemplate, addTypeTemplate, addServerPlugin, addServerHandler, addServerImports, updateTemplates } from '@nuxt/kit';
-import defu from 'defu';
-import { existsSync, realpathSync, readFileSync } from 'node:fs';
+import { join, dirname, relative, basename } from 'node:path';
+import { defineNuxtModule, createResolver, hasNuxtModule, addTemplate, addServerPlugin, addServerHandler, addServerImports, addImports, updateTemplates } from '@nuxt/kit';
+import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync, writeFileSync, readFileSync, copyFileSync } from 'node:fs';
+import { exec, execFileSync, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { pipeline } from 'node:stream/promises';
+import { stringifyYAML } from 'confbox';
 import { globby } from 'globby';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import { readFile } from 'node:fs/promises';
-import { parseModule } from 'magicast';
-import { spawn } from 'node:child_process';
+import { genString } from 'knitwork';
+import { PythonWorkersOrchestrator } from '../dist/runtime/nitro/utils/workers/python.js';
+import { createEngineManager } from '../dist/runtime/nitro/utils/engine.js';
+import { ConsoleManager } from '../dist/runtime/nitro/utils/console.js';
 import chokidar from 'chokidar';
-import { join as join$1 } from 'pathe';
 import { debounce } from 'perfect-debounce';
-import { normalizeModuleOptions, getRedisStorageConfig, toRuntimeConfig } from '../dist/runtime/config/index.js';
 
-async function loadJsConfig(absPath) {
-  const cacheBust = `?t=${Date.now()}`;
-  const mod = await import(pathToFileURL(absPath).href + cacheBust);
-  const cfg = mod?.config;
-  const queueName = cfg && typeof cfg.queue === "object" && cfg.queue ? cfg.queue?.name : void 0;
-  const isolate = cfg?.runner?.ts?.isolate || cfg?.runner?.isolate || cfg?.isolate;
-  const runtype = isolate === "task" ? "task" : isolate === "inprocess" ? "inprocess" : void 0;
-  const flowCfg = cfg?.flow;
-  let flow;
-  if (flowCfg) {
-    const subscribes = Array.isArray(flowCfg.subscribes) ? flowCfg.subscribes : typeof flowCfg.subscribes === "string" ? [flowCfg.subscribes] : void 0;
-    const names = Array.isArray(flowCfg.name) ? flowCfg.name.filter((s) => typeof s === "string" && s.length > 0) : typeof flowCfg.name === "string" && flowCfg.name.length > 0 ? [flowCfg.name] : [];
-    if (names.length) {
-      flow = {
-        names,
-        role: flowCfg.role,
-        step: flowCfg.step,
-        emits: flowCfg.emits,
-        subscribes,
-        triggers: flowCfg.triggers,
-        stepTimeout: flowCfg.stepTimeout,
-        awaitBefore: flowCfg.awaitBefore,
-        awaitAfter: flowCfg.awaitAfter
-      };
-    }
+const LogLevels = {
+  fatal: 0,
+  error: 0,
+  warn: 1,
+  log: 2,
+  info: 3,
+  success: 3,
+  fail: 3,
+  debug: 4,
+  trace: 5,
+  verbose: Number.POSITIVE_INFINITY
+};
+const LogTypes = {
+  // Silent
+  silent: {
+    level: -1
+  },
+  // Level 0
+  fatal: {
+    level: LogLevels.fatal
+  },
+  error: {
+    level: LogLevels.error
+  },
+  // Level 1
+  warn: {
+    level: LogLevels.warn
+  },
+  // Level 2
+  log: {
+    level: LogLevels.log
+  },
+  // Level 3
+  info: {
+    level: LogLevels.info
+  },
+  success: {
+    level: LogLevels.success
+  },
+  fail: {
+    level: LogLevels.fail
+  },
+  ready: {
+    level: LogLevels.info
+  },
+  start: {
+    level: LogLevels.info
+  },
+  box: {
+    level: LogLevels.info
+  },
+  // Level 4
+  debug: {
+    level: LogLevels.debug
+  },
+  // Level 5
+  trace: {
+    level: LogLevels.trace
+  },
+  // Verbose
+  verbose: {
+    level: LogLevels.verbose
+  }
+};
+
+function isPlainObject$1(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
   }
-  const queueCfg = cfg?.queue && typeof cfg.queue === "object" ? {
-    name: cfg.queue.name,
-    defaultJobOptions: cfg.queue.defaultJobOptions,
-    prefix: cfg.queue.prefix,
-    limiter: cfg.queue.limiter
-  } : void 0;
-  const workerCfg = cfg?.worker && typeof cfg.worker === "object" ? { ...cfg.worker } : void 0;
-  const hasDefaultExport = !!(mod && mod.default);
-  const hasHooks = !!(mod && typeof mod.onAwaitRegister === "function" || mod && typeof mod.onAwaitResolve === "function" || mod && typeof mod.onAwaitTimeout === "function");
-  return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport, hasHooks };
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
 }
 
-async function loadTsConfig(absPath) {
-  try {
-    const source = await readFile(absPath, "utf-8");
-    const mod = parseModule(source);
-    const hasDefaultExport = !!mod.exports.default;
-    const configExport = mod.exports.config;
-    if (!configExport) {
-      return { hasDefaultExport };
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject$1(defaults)) {
+    return _defu(baseObject, {}, namespace);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
     }
-    const cfg = extractConfigValue(configExport);
-    const queueName = cfg && typeof cfg.queue === "object" && cfg.queue ? cfg.queue?.name : void 0;
-    const isolate = cfg?.runner?.ts?.isolate || cfg?.runner?.isolate || cfg?.isolate;
-    const runtype = isolate === "task" ? "task" : isolate === "inprocess" ? "inprocess" : void 0;
-    const flowCfg = cfg?.flow;
-    let flow;
-    if (flowCfg) {
-      const subscribes = Array.isArray(flowCfg.subscribes) ? flowCfg.subscribes : typeof flowCfg.subscribes === "string" ? [flowCfg.subscribes] : void 0;
-      const names = Array.isArray(flowCfg.name) ? flowCfg.name.filter((s) => typeof s === "string" && s.length > 0) : typeof flowCfg.name === "string" && flowCfg.name.length > 0 ? [flowCfg.name] : [];
-      if (names.length) {
-        flow = {
-          names,
-          role: flowCfg.role,
-          step: flowCfg.step,
-          emits: flowCfg.emits,
-          subscribes,
-          triggers: flowCfg.triggers,
-          stepTimeout: flowCfg.stepTimeout,
-          awaitBefore: flowCfg.awaitBefore,
-          awaitAfter: flowCfg.awaitAfter
-        };
-      }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject$1(value) && isPlainObject$1(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString());
+    } else {
+      object[key] = value;
     }
-    const queueCfg = cfg?.queue && typeof cfg.queue === "object" ? {
-      name: cfg.queue.name,
-      defaultJobOptions: cfg.queue.defaultJobOptions,
-      prefix: cfg.queue.prefix,
-      limiter: cfg.queue.limiter
-    } : void 0;
-    const workerCfg = cfg?.worker && typeof cfg.worker === "object" ? { ...cfg.worker } : void 0;
-    const hasHooks = !!(mod.exports.onAwaitRegister || mod.exports.onAwaitResolve || mod.exports.onAwaitTimeout);
-    return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport, hasHooks };
-  } catch (error) {
-    throw new Error(`Failed to parse config from ${absPath}: ${error}`);
   }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, ""), {})
+  );
+}
+const defu = createDefu();
+
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
 }
-function extractConfigValue(value) {
-  if (value && typeof value === "object" && "$ast" in value) {
-    return astToValue(value.$ast);
+function isLogObj(arg) {
+  if (!isPlainObject(arg)) {
+    return false;
+  }
+  if (!arg.message && !arg.args) {
+    return false;
+  }
+  if (arg.stack) {
+    return false;
   }
-  return value;
+  return true;
 }
-function astToValue(node) {
-  if (!node) return void 0;
-  switch (node.type) {
-    case "CallExpression":
-      if (node.arguments?.length > 0) {
-        return astToValue(node.arguments[0]);
-      }
-      return void 0;
-    case "ObjectExpression":
-      return node.properties?.reduce((obj, prop) => {
-        if (prop.type === "ObjectProperty" || prop.type === "Property") {
-          const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.value;
-          obj[key] = astToValue(prop.value);
+
+let paused = false;
+const queue = [];
+class Consola {
+  options;
+  _lastLog;
+  _mockFn;
+  /**
+   * Creates an instance of Consola with specified options or defaults.
+   *
+   * @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
+   */
+  constructor(options = {}) {
+    const types = options.types || LogTypes;
+    this.options = defu(
+      {
+        ...options,
+        defaults: { ...options.defaults },
+        level: _normalizeLogLevel(options.level, types),
+        reporters: [...options.reporters || []]
+      },
+      {
+        types: LogTypes,
+        throttle: 1e3,
+        throttleMin: 5,
+        formatOptions: {
+          date: true,
+          colors: false,
+          compact: true
         }
-        return obj;
-      }, {}) || {};
-    case "ArrayExpression":
-      return node.elements?.map((el) => astToValue(el)) || [];
-    case "Literal":
-    case "StringLiteral":
-    case "NumericLiteral":
-    case "BooleanLiteral":
-      return node.value;
-    case "Identifier":
-      return void 0;
-    case "TemplateLiteral":
-      if (node.expressions?.length === 0 && node.quasis?.length === 1) {
-        return node.quasis[0].value.cooked;
       }
-      return void 0;
-    default:
-      return void 0;
+    );
+    for (const type in types) {
+      const defaults = {
+        type,
+        ...this.options.defaults,
+        ...types[type]
+      };
+      this[type] = this._wrapLogFn(defaults);
+      this[type].raw = this._wrapLogFn(
+        defaults,
+        true
+      );
+    }
+    if (this.options.mockFn) {
+      this.mockTypes();
+    }
+    this._lastLog = {};
   }
-}
-
-async function loadPyConfig(absPath, logger) {
-  const moduleDir = dirname(fileURLToPath(import.meta.url));
-  const helper = join(moduleDir, "..", "..", "runtime", "worker", "python", "get_config.py");
-  let pyConfig;
-  if (existsSync(helper)) {
-    pyConfig = await new Promise((resolve) => {
-      try {
-        const child = spawn("python3", [helper, absPath], {
-          stdio: ["ignore", "pipe", "pipe", "pipe"],
-          env: { ...process.env, NODE_CHANNEL_FD: "3" }
-        });
-        let dataBuf = "";
-        const fd = child.stdio[3];
-        const stream = fd || child.stdout;
-        stream.setEncoding("utf-8");
-        stream.on("data", (chunk) => {
-          dataBuf += chunk;
-        });
-        child.on("error", () => resolve(void 0));
-        child.on("close", () => {
-          const line = dataBuf.split("\n").find((l) => l.trim().length > 0);
-          if (!line) return resolve(void 0);
-          try {
-            resolve(JSON.parse(line));
-          } catch {
-            resolve(void 0);
-          }
-        });
-      } catch {
-        resolve(void 0);
+  /**
+   * Gets the current log level of the Consola instance.
+   *
+   * @returns {number} The current log level.
+   */
+  get level() {
+    return this.options.level;
+  }
+  /**
+   * Sets the minimum log level that will be output by the instance.
+   *
+   * @param {number} level - The new log level to set.
+   */
+  set level(level) {
+    this.options.level = _normalizeLogLevel(
+      level,
+      this.options.types,
+      this.options.level
+    );
+  }
+  /**
+   * Displays a prompt to the user and returns the response.
+   * Throw an error if `prompt` is not supported by the current configuration.
+   *
+   * @template T
+   * @param {string} message - The message to display in the prompt.
+   * @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
+   * @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
+   */
+  prompt(message, opts) {
+    if (!this.options.prompt) {
+      throw new Error("prompt is not supported!");
+    }
+    return this.options.prompt(message, opts);
+  }
+  /**
+   * Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
+   *
+   * @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  create(options) {
+    const instance = new Consola({
+      ...this.options,
+      ...options
+    });
+    if (this._mockFn) {
+      instance.mockTypes(this._mockFn);
+    }
+    return instance;
+  }
+  /**
+   * Creates a new Consola instance with the specified default log object properties.
+   *
+   * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withDefaults(defaults) {
+    return this.create({
+      ...this.options,
+      defaults: {
+        ...this.options.defaults,
+        ...defaults
       }
     });
-  } else {
-    logger?.warn?.("Python helper not found, skipping config extraction:", helper);
-  }
-  let queueName;
-  let flow;
-  if (pyConfig) {
-    queueName = pyConfig?.queue && typeof pyConfig.queue === "object" ? pyConfig.queue?.name : void 0;
-    const flowCfg = pyConfig?.flow;
-    if (flowCfg && typeof flowCfg === "object") {
-      const subscribes = Array.isArray(flowCfg.subscribes) ? flowCfg.subscribes : typeof flowCfg.subscribes === "string" ? [flowCfg.subscribes] : void 0;
-      const names = Array.isArray(flowCfg.name) ? flowCfg.name.filter((s) => typeof s === "string" && s.length > 0) : typeof flowCfg.name === "string" && flowCfg.name.length > 0 ? [flowCfg.name] : [];
-      if (names.length) {
-        flow = {
-          names,
-          role: flowCfg.role,
-          step: flowCfg.step,
-          emits: flowCfg.emits,
-          subscribes,
-          triggers: flowCfg.triggers,
-          stepTimeout: flowCfg.stepTimeout,
-          awaitBefore: flowCfg.awaitBefore,
-          awaitAfter: flowCfg.awaitAfter
-        };
+  }
+  /**
+   * Creates a new Consola instance with a specified tag, which will be included in every log.
+   *
+   * @param {string} tag - The tag to include in each log of the new instance.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withTag(tag) {
+    return this.withDefaults({
+      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag
+    });
+  }
+  /**
+   * Adds a custom reporter to the Consola instance.
+   * Reporters will be called for each log message, depending on their implementation and log level.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  addReporter(reporter) {
+    this.options.reporters.push(reporter);
+    return this;
+  }
+  /**
+   * Removes a custom reporter from the Consola instance.
+   * If no reporter is specified, all reporters will be removed.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  removeReporter(reporter) {
+    if (reporter) {
+      const i = this.options.reporters.indexOf(reporter);
+      if (i !== -1) {
+        return this.options.reporters.splice(i, 1);
       }
+    } else {
+      this.options.reporters.splice(0);
     }
+    return this;
   }
-  return { queueName, flow, hasDefaultExport: true };
-}
-
-async function scanWorkers(layers, functionsDir = "functions") {
-  const logger = useLogger();
-  const workerByVirtualPath = /* @__PURE__ */ new Map();
-  const seenFiles = /* @__PURE__ */ new Set();
-  const flowSources = [];
-  for (const layer of layers) {
-    const base = join(layer.serverDir, functionsDir);
-    if (!existsSync(base)) continue;
-    const files = await globby("**/*.{ts,js,mjs,cjs,mts,cts,py}", { cwd: base, dot: false });
-    for (const rel of files) {
-      const abs = join(base, rel);
-      try {
-        let key = abs;
-        try {
-          key = realpathSync(abs);
-        } catch {
-        }
-        key = key.replace(/\\/g, "/");
-        if (seenFiles.has(key)) continue;
-        seenFiles.add(key);
-        const ext = extname(abs).toLowerCase();
-        const id = rel.replace(/\.[^.]+$/, "");
-        let queueName;
-        let flow;
-        if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
-          const meta = await loadJsConfig(abs);
-          flow = meta.flow;
-          const hasDefaultExport = !!meta.hasDefaultExport;
-          if (hasDefaultExport) {
-            const kind = "ts";
-            const virtualPath = relative(layer.serverDir, abs).replace(/\\/g, "/");
-            queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
-            workerByVirtualPath.set(virtualPath, {
-              id,
-              name: queueName,
-              kind,
-              filePath: virtualPath,
-              absPath: abs,
-              exportName: "default",
-              queue: {
-                name: queueName,
-                defaultJobOptions: meta.queue?.defaultJobOptions,
-                prefix: meta.queue?.prefix,
-                limiter: meta.queue?.limiter
-              },
-              worker: meta.worker,
-              flow,
-              runtype: meta.runtype
-            });
-          }
-        } else if (ext === ".py") {
-          const meta = await loadPyConfig(abs, logger);
-          flow = meta.flow;
-          const kind = "py";
-          const virtualPath = relative(layer.serverDir, abs).replace(/\\/g, "/");
-          queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
-          workerByVirtualPath.set(virtualPath, {
-            id,
-            name: queueName,
-            kind,
-            filePath: virtualPath,
-            absPath: abs,
-            exportName: "default",
-            queue: {
-              name: queueName,
-              defaultJobOptions: meta.queue?.defaultJobOptions,
-              prefix: meta.queue?.prefix,
-              limiter: meta.queue?.limiter
-            },
-            flow
-          });
-        } else {
-          try {
-            const meta = await loadTsConfig(abs);
-            flow = meta.flow;
-            const hasDefaultExport = !!meta.hasDefaultExport;
-            if (hasDefaultExport) {
-              const kind = "ts";
-              const virtualPath = relative(layer.serverDir, abs).replace(/\\/g, "/");
-              queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
-              workerByVirtualPath.set(virtualPath, {
-                id,
-                name: queueName,
-                kind,
-                filePath: virtualPath,
-                absPath: abs,
-                exportName: "default",
-                queue: {
-                  name: queueName,
-                  defaultJobOptions: meta.queue?.defaultJobOptions,
-                  prefix: meta.queue?.prefix,
-                  limiter: meta.queue?.limiter
-                },
-                worker: meta.worker,
-                flow,
-                runtype: meta.runtype
-              });
-            }
-          } catch (err) {
-            logger.warn("Failed to load TS worker (jiti):", rel, err);
-          }
-        }
-        if (!queueName) {
-          queueName = id.split("/").pop() || id;
-        }
-        if (flow) {
-          flowSources.push({ flow, queue: String(queueName), id });
-        }
-      } catch (e) {
-        logger.warn("Failed to load worker file:", rel, e);
+  /**
+   * Replaces all reporters of the Consola instance with the specified array of reporters.
+   *
+   * @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  setReporters(reporters) {
+    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
+    return this;
+  }
+  wrapAll() {
+    this.wrapConsole();
+    this.wrapStd();
+  }
+  restoreAll() {
+    this.restoreConsole();
+    this.restoreStd();
+  }
+  /**
+   * Overrides console methods with Consola logging methods for consistent logging.
+   */
+  wrapConsole() {
+    for (const type in this.options.types) {
+      if (!console["__" + type]) {
+        console["__" + type] = console[type];
       }
+      console[type] = this[type].raw;
     }
   }
-  const workers = Array.from(workerByVirtualPath.values());
-  return { workers, flowSources };
-}
-
-function buildFlows(flowSources) {
-  const flows = {};
-  const eventIndex = {};
-  const seenFlowKeys = /* @__PURE__ */ new Set();
-  for (const src of flowSources) {
-    const { flow: f, queue, id } = src;
-    if (!f?.names?.length || !f.step) continue;
-    const rawSteps = Array.isArray(f.step) ? f.step : [f.step];
-    const steps = rawSteps.filter((s) => typeof s === "string" && s.length > 0);
-    if (steps.length === 0) continue;
-    for (const flowId of f.names) {
-      if (!flows[flowId]) flows[flowId] = { steps: {} };
-      const bucket = flows[flowId] = flows[flowId] || { steps: {} };
-      if (f.role === "entry") {
-        const mainStep = steps[0];
-        const key = `${flowId}:${f.role}:${mainStep}`;
-        if (!seenFlowKeys.has(key)) {
-          seenFlowKeys.add(key);
-          bucket.entry = {
-            step: mainStep,
-            queue,
-            workerId: id,
-            emits: f.emits,
-            stepTimeout: f.stepTimeout,
-            awaitBefore: f.awaitBefore,
-            awaitAfter: f.awaitAfter
-          };
-        }
-        for (const s of steps.slice(1)) {
-          const skey = `${flowId}:step:${s}`;
-          if (seenFlowKeys.has(skey)) continue;
-          seenFlowKeys.add(skey);
-          bucket.steps[s] = {
-            queue,
-            workerId: id,
-            subscribes: f.subscribes,
-            emits: f.emits,
-            stepTimeout: f.stepTimeout,
-            awaitBefore: f.awaitBefore,
-            awaitAfter: f.awaitAfter
-          };
-        }
-      } else {
-        for (const s of steps) {
-          const skey = `${flowId}:${f.role}:${s}`;
-          if (seenFlowKeys.has(skey)) continue;
-          seenFlowKeys.add(skey);
-          bucket.steps[s] = {
-            queue,
-            workerId: id,
-            subscribes: f.subscribes,
-            emits: f.emits,
-            stepTimeout: f.stepTimeout,
-            awaitBefore: f.awaitBefore,
-            awaitAfter: f.awaitAfter
-          };
+  /**
+   * Restores the original console methods, removing Consola overrides.
+   */
+  restoreConsole() {
+    for (const type in this.options.types) {
+      if (console["__" + type]) {
+        console[type] = console["__" + type];
+        delete console["__" + type];
+      }
+    }
+  }
+  /**
+   * Overrides standard output and error streams to redirect them through Consola.
+   */
+  wrapStd() {
+    this._wrapStream(this.options.stdout, "log");
+    this._wrapStream(this.options.stderr, "log");
+  }
+  _wrapStream(stream, type) {
+    if (!stream) {
+      return;
+    }
+    if (!stream.__write) {
+      stream.__write = stream.write;
+    }
+    stream.write = (data) => {
+      this[type].raw(String(data).trim());
+    };
+  }
+  /**
+   * Restores the original standard output and error streams, removing the Consola redirection.
+   */
+  restoreStd() {
+    this._restoreStream(this.options.stdout);
+    this._restoreStream(this.options.stderr);
+  }
+  _restoreStream(stream) {
+    if (!stream) {
+      return;
+    }
+    if (stream.__write) {
+      stream.write = stream.__write;
+      delete stream.__write;
+    }
+  }
+  /**
+   * Pauses logging, queues incoming logs until resumed.
+   */
+  pauseLogs() {
+    paused = true;
+  }
+  /**
+   * Resumes logging, processing any queued logs.
+   */
+  resumeLogs() {
+    paused = false;
+    const _queue = queue.splice(0);
+    for (const item of _queue) {
+      item[0]._logFn(item[1], item[2]);
+    }
+  }
+  /**
+   * Replaces logging methods with mocks if a mock function is provided.
+   *
+   * @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
+   */
+  mockTypes(mockFn) {
+    const _mockFn = mockFn || this.options.mockFn;
+    this._mockFn = _mockFn;
+    if (typeof _mockFn !== "function") {
+      return;
+    }
+    for (const type in this.options.types) {
+      this[type] = _mockFn(type, this.options.types[type]) || this[type];
+      this[type].raw = this[type];
+    }
+  }
+  _wrapLogFn(defaults, isRaw) {
+    return (...args) => {
+      if (paused) {
+        queue.push([this, defaults, args, isRaw]);
+        return;
+      }
+      return this._logFn(defaults, args, isRaw);
+    };
+  }
+  _logFn(defaults, args, isRaw) {
+    if ((defaults.level || 0) > this.level) {
+      return false;
+    }
+    const logObj = {
+      date: /* @__PURE__ */ new Date(),
+      args: [],
+      ...defaults,
+      level: _normalizeLogLevel(defaults.level, this.options.types)
+    };
+    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
+      Object.assign(logObj, args[0]);
+    } else {
+      logObj.args = [...args];
+    }
+    if (logObj.message) {
+      logObj.args.unshift(logObj.message);
+      delete logObj.message;
+    }
+    if (logObj.additional) {
+      if (!Array.isArray(logObj.additional)) {
+        logObj.additional = logObj.additional.split("\n");
+      }
+      logObj.args.push("\n" + logObj.additional.join("\n"));
+      delete logObj.additional;
+    }
+    logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
+    logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
+    const resolveLog = (newLog = false) => {
+      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
+      if (this._lastLog.object && repeated > 0) {
+        const args2 = [...this._lastLog.object.args];
+        if (repeated > 1) {
+          args2.push(`(repeated ${repeated} times)`);
         }
+        this._log({ ...this._lastLog.object, args: args2 });
+        this._lastLog.count = 1;
+      }
+      if (newLog) {
+        this._lastLog.object = logObj;
+        this._log(logObj);
       }
-      if (f.subscribes) {
-        for (const kind of f.subscribes) {
-          if (!eventIndex[kind]) eventIndex[kind] = [];
-          for (const s of steps) {
-            eventIndex[kind].push({ flowId, step: s, queue, workerId: id });
+    };
+    clearTimeout(this._lastLog.timeout);
+    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
+    this._lastLog.time = logObj.date;
+    if (diffTime < this.options.throttle) {
+      try {
+        const serializedLog = JSON.stringify([
+          logObj.type,
+          logObj.tag,
+          logObj.args
+        ]);
+        const isSameLog = this._lastLog.serialized === serializedLog;
+        this._lastLog.serialized = serializedLog;
+        if (isSameLog) {
+          this._lastLog.count = (this._lastLog.count || 0) + 1;
+          if (this._lastLog.count > this.options.throttleMin) {
+            this._lastLog.timeout = setTimeout(
+              resolveLog,
+              this.options.throttle
+            );
+            return;
           }
         }
+      } catch {
       }
     }
+    resolveLog(true);
+  }
+  _log(logObj) {
+    for (const reporter of this.options.reporters) {
+      reporter.log(logObj, {
+        options: this.options
+      });
+    }
   }
-  return { flows, eventIndex };
 }
-
-function mergeWorkerConfig(worker, defaults) {
-  const merged = { ...worker };
-  if (defaults.queue || worker.queue) {
-    merged.queue = defu(
-      worker.queue || {},
-      defaults.queue || {}
-    );
+function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
+  if (input === void 0) {
+    return defaultLevel;
   }
-  if (defaults.worker || worker.worker) {
-    merged.worker = defu(
-      worker.worker || {},
-      defaults.worker || {}
-    );
+  if (typeof input === "number") {
+    return input;
+  }
+  if (types[input] && types[input].level !== void 0) {
+    return types[input].level;
   }
-  return merged;
+  return defaultLevel;
 }
-function mergeAllWorkerConfigs(workers, defaults) {
-  return workers.map((worker) => mergeWorkerConfig(worker, defaults));
+Consola.prototype.add = Consola.prototype.addReporter;
+Consola.prototype.remove = Consola.prototype.removeReporter;
+Consola.prototype.clear = Consola.prototype.removeReporter;
+Consola.prototype.withScope = Consola.prototype.withTag;
+Consola.prototype.mock = Consola.prototype.mockTypes;
+Consola.prototype.pause = Consola.prototype.pauseLogs;
+Consola.prototype.resume = Consola.prototype.resumeLogs;
+function createConsola$1(options = {}) {
+  return new Consola(options);
 }
 
-function parseSubscription(token) {
-  const [prefix, ...rest] = token.split(":");
-  if (rest.length > 0) {
-    const type = prefix;
-    return { type, value: rest.join(":") };
+class BrowserReporter {
+  options;
+  defaultColor;
+  levelColorMap;
+  typeColorMap;
+  constructor(options) {
+    this.options = { ...options };
+    this.defaultColor = "#7f8c8d";
+    this.levelColorMap = {
+      0: "#c0392b",
+      // Red
+      1: "#f39c12",
+      // Yellow
+      3: "#00BCD4"
+      // Cyan
+    };
+    this.typeColorMap = {
+      success: "#2ecc71"
+      // Green
+    };
   }
-  return { type: "implicit", value: token };
-}
-function findEmitter(token, entryStep, steps, entry) {
-  const { type, value } = parseSubscription(token);
-  if (entryStep && entry) {
-    const entryEmits = entry.emits || [];
-    if (entryEmits.includes(token) || entryEmits.includes(value)) {
-      return entryStep;
+  _getLogFn(level) {
+    if (level < 1) {
+      return console.__error || console.error;
     }
-  }
-  for (const [stepName, step] of Object.entries(steps)) {
-    const emits = step.emits || [];
-    if (emits.includes(token)) {
-      return stepName;
+    if (level === 1) {
+      return console.__warn || console.warn;
     }
-    switch (type) {
-      case "step":
-        if (stepName === value) return stepName;
-        break;
-      case "queue":
-        if (step.queue === value) return stepName;
-        break;
-      case "worker":
-        if (step.workerId === value) return stepName;
-        break;
-      case "implicit":
-        if (stepName === value || step.queue === value || emits.includes(value)) {
-          return stepName;
-        }
-        break;
+    return console.__log || console.log;
+  }
+  log(logObj) {
+    const consoleLogFn = this._getLogFn(logObj.level);
+    const type = logObj.type === "log" ? "" : logObj.type;
+    const tag = logObj.tag || "";
+    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;
+    const style = `
+      background: ${color};
+      border-radius: 0.5em;
+      color: white;
+      font-weight: bold;
+      padding: 2px 0.5em;
+    `;
+    const badge = `%c${[tag, type].filter(Boolean).join(":")}`;
+    if (typeof logObj.args[0] === "string") {
+      consoleLogFn(
+        `${badge}%c ${logObj.args[0]}`,
+        style,
+        // Empty string as style resets to default console style
+        "",
+        ...logObj.args.slice(1)
+      );
+    } else {
+      consoleLogFn(badge, style, ...logObj.args);
     }
   }
-  return null;
 }
-function buildDependencyGraph(entryStep, steps, entry) {
-  const dependencies = {};
-  for (const [stepName, step] of Object.entries(steps)) {
-    const deps = /* @__PURE__ */ new Set();
-    const subscribes = step.subscribes || [];
-    for (const token of subscribes) {
-      const emitter = findEmitter(token, entryStep, steps, entry);
-      if (emitter && emitter !== stepName) {
-        deps.add(emitter);
+
+function createConsola(options = {}) {
+  const consola2 = createConsola$1({
+    reporters: options.reporters || [new BrowserReporter({})],
+    prompt(message, options2 = {}) {
+      if (options2.type === "confirm") {
+        return Promise.resolve(confirm(message));
       }
-    }
-    dependencies[stepName] = Array.from(deps);
+      return Promise.resolve(prompt(message));
+    },
+    ...options
+  });
+  return consola2;
+}
+const consola = createConsola();
+
+const execAsync$1 = promisify(exec);
+const logger$1 = consola.withTag("nvent:iii-install");
+const GITHUB_RELEASE_BASE$1 = "https://github.com/iii-hq/iii/releases/download";
+function getPlatformAsset(version) {
+  const platform = process.platform;
+  const arch = process.arch;
+  const tag = toReleaseTag$1(version);
+  if (platform === "linux" && arch === "x64") {
+    return { url: `${GITHUB_RELEASE_BASE$1}/${tag}/iii-x86_64-unknown-linux-gnu.tar.gz`, ext: "tar.gz" };
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return { url: `${GITHUB_RELEASE_BASE$1}/${tag}/iii-aarch64-unknown-linux-gnu.tar.gz`, ext: "tar.gz" };
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return { url: `${GITHUB_RELEASE_BASE$1}/${tag}/iii-x86_64-apple-darwin.tar.gz`, ext: "tar.gz" };
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return { url: `${GITHUB_RELEASE_BASE$1}/${tag}/iii-aarch64-apple-darwin.tar.gz`, ext: "tar.gz" };
+  }
+  if (platform === "win32" && arch === "x64") {
+    return { url: `${GITHUB_RELEASE_BASE$1}/${tag}/iii-x86_64-pc-windows-msvc.zip`, ext: "zip" };
   }
-  return dependencies;
+  if (platform === "win32" && arch === "arm64") {
+    return { url: `${GITHUB_RELEASE_BASE$1}/${tag}/iii-aarch64-pc-windows-msvc.zip`, ext: "zip" };
+  }
+  throw new Error(`Unsupported platform: ${platform}/${arch}`);
 }
-function calculateLevels(entryStep, dependencies) {
-  const levels = {};
-  const visited = /* @__PURE__ */ new Set();
-  const visiting = /* @__PURE__ */ new Set();
-  function visit(stepName) {
-    if (visited.has(stepName)) {
-      return levels[stepName] ?? 0;
-    }
-    if (visiting.has(stepName)) {
-      console.warn(`Circular dependency detected involving step: ${stepName}`);
-      return 0;
-    }
-    visiting.add(stepName);
-    const deps = dependencies[stepName] || [];
-    let maxDepLevel = -1;
-    if (stepName === entryStep) {
-      maxDepLevel = -1;
-    } else if (deps.length === 0 && entryStep) {
-      maxDepLevel = 0;
-    } else {
-      for (const dep of deps) {
-        const depLevel = visit(dep);
-        maxDepLevel = Math.max(maxDepLevel, depLevel);
-      }
-    }
-    levels[stepName] = maxDepLevel + 1;
-    visiting.delete(stepName);
-    visited.add(stepName);
-    return levels[stepName];
+function semverFromTag$1(tag) {
+  return tag.replace(/^.*\/v?/, "").replace(/^v/, "");
+}
+function toReleaseTag$1(version) {
+  if (version.includes("/")) return version;
+  return `v${version.replace(/^v/, "")}`;
+}
+async function fetchLatestVersion() {
+  const res = await fetch("https://api.github.com/repos/iii-hq/iii/releases/latest", {
+    headers: { "Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28" }
+  });
+  if (res.status === 403 || res.status === 429) {
+    const retryAfter = res.headers.get("retry-after") ?? res.headers.get("x-ratelimit-reset");
+    throw new RateLimitError$1(`GitHub API rate limit exceeded${retryAfter ? ` (retry after ${retryAfter})` : ""}`);
+  }
+  if (!res.ok) throw new Error(`Failed to fetch latest iii version: ${res.statusText}`);
+  const data = await res.json();
+  return data.tag_name;
+}
+let RateLimitError$1 = class RateLimitError extends Error {
+};
+async function getCurrentVersion(binaryPath) {
+  try {
+    const { stdout } = await execAsync$1(`"${binaryPath}" --version`);
+    const match = stdout.trim().match(/(\d+\.\d+\.\d+)/);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function downloadAndExtract(assetUrl, ext, binDir, logLevel = "warn") {
+  const archivePath = join(binDir, ext === "zip" ? "iii.zip" : "iii.tar.gz");
+  if (logLevel === "info") logger$1.info(`Downloading iii engine from ${assetUrl}`);
+  const res = await fetch(assetUrl);
+  if (!res.ok) throw new Error(`Failed to download iii engine: ${res.status} ${res.statusText}`);
+  if (!res.body) throw new Error("Response body is empty");
+  const fileStream = createWriteStream(archivePath);
+  await pipeline(res.body, fileStream);
+  if (logLevel === "info") logger$1.info("Extracting archive...");
+  if (ext === "tar.gz") {
+    await execAsync$1(`tar -xzf "${archivePath}" -C "${binDir}"`);
+  } else {
+    await execAsync$1(`unzip -o "${archivePath}" -d "${binDir}"`);
   }
-  const allSteps = Object.keys(dependencies);
-  for (const step of allSteps) {
-    visit(step);
+  try {
+    unlinkSync(archivePath);
+  } catch {
   }
-  return levels;
 }
-function findTriggeredSteps(stepName, step, allSteps) {
-  const emits = step.emits || [];
-  const triggered = /* @__PURE__ */ new Set();
-  for (const [targetName, targetStep] of Object.entries(allSteps)) {
-    if (targetName === stepName) continue;
-    const subscribes = targetStep.subscribes || [];
-    for (const token of subscribes) {
-      const { type, value } = parseSubscription(token);
-      let matches = false;
-      switch (type) {
-        case "step":
-          matches = stepName === value;
-          break;
-        case "queue":
-          matches = step.queue === value;
-          break;
-        case "worker":
-          matches = step.workerId === value;
-          break;
-        case "implicit":
-          matches = stepName === value || step.queue === value || emits.includes(value);
-          break;
-      }
-      if (matches || emits.includes(token)) {
-        triggered.add(targetName);
+async function ensureIiiEngine(options) {
+  const { binDir } = options;
+  const logLevel = options.logLevel ?? "warn";
+  const binaryName = process.platform === "win32" ? "iii.exe" : "iii";
+  const binaryPath = join(binDir, binaryName);
+  let version = options.version;
+  if (!version || version === "latest") {
+    if (logLevel === "info") logger$1.info("Resolving latest iii engine version...");
+    try {
+      version = await fetchLatestVersion();
+      if (logLevel === "info") logger$1.info(`Latest iii engine version: ${version}`);
+    } catch (err) {
+      if (err instanceof RateLimitError$1) {
+        if (existsSync(binaryPath)) {
+          logger$1.warn(`[nvent] ${err.message} \u2014 using existing binary at ${binaryPath}`);
+          return binaryPath;
+        }
+        throw new Error(`${err.message} and no existing iii binary found. Specify a version in nvent config (e.g. version: '0.8.0') to avoid GitHub API calls.`);
       }
+      throw err;
     }
   }
-  return Array.from(triggered);
-}
-function getAwaitDefaultTimeout(awaitConfig) {
-  if (!awaitConfig) return 0;
-  if (awaitConfig.timeout && awaitConfig.timeout > 0) {
-    return awaitConfig.timeout;
-  }
-  const type = awaitConfig.type;
-  switch (type) {
-    case "webhook":
-      return 24 * 60 * 60 * 1e3;
-    // 24 hours (matches flow.awaitDefaults.webhookTimeout)
-    case "event":
-      return 24 * 60 * 60 * 1e3;
-    // 24 hours (matches flow.awaitDefaults.eventTimeout)
-    case "time":
-      return 0;
-    // No timeout for time awaits by default
-    case "schedule":
-      return 0;
-    // No timeout for schedule awaits by default
-    default:
-      return 0;
+  if (existsSync(binaryPath)) {
+    const currentVersion = await getCurrentVersion(binaryPath);
+    const wantedSemver = semverFromTag$1(version);
+    if (currentVersion === wantedSemver) {
+      if (logLevel === "info") logger$1.info(`iii engine v${wantedSemver} already installed at ${binaryPath}`);
+      return binaryPath;
+    }
+    if (logLevel === "info") logger$1.info(`iii engine version mismatch (have v${currentVersion}, want v${wantedSemver}), reinstalling...`);
+  }
+  if (!existsSync(binDir)) {
+    mkdirSync(binDir, { recursive: true });
+  }
+  const asset = getPlatformAsset(version);
+  await downloadAndExtract(asset.url, asset.ext, binDir, logLevel);
+  if (process.platform !== "win32") {
+    chmodSync(binaryPath, 493);
   }
+  const installedVersion = await getCurrentVersion(binaryPath);
+  if (logLevel === "info") logger$1.info(`iii engine v${installedVersion} installed at ${binaryPath}`);
+  return binaryPath;
 }
-function getStepAwaitTimeout(step) {
-  let timeout = 0;
-  if (step.awaitBefore) {
-    timeout += getAwaitDefaultTimeout(step.awaitBefore);
+
+const execAsync = promisify(exec);
+const logger = consola.withTag("nvent:console");
+const GITHUB_RELEASE_BASE = "https://github.com/iii-hq/iii/releases/download";
+function getConsolePlatformAsset(version) {
+  const platform = process.platform;
+  const arch = process.arch;
+  const tag = toReleaseTag(version);
+  const base = `${GITHUB_RELEASE_BASE}/${tag}`;
+  if (platform === "linux" && arch === "x64") {
+    return { url: `${base}/iii-console-x86_64-unknown-linux-gnu.tar.gz`, ext: "tar.gz" };
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return { url: `${base}/iii-console-aarch64-unknown-linux-gnu.tar.gz`, ext: "tar.gz" };
   }
-  if (step.awaitAfter) {
-    timeout += getAwaitDefaultTimeout(step.awaitAfter);
+  if (platform === "darwin" && arch === "x64") {
+    return { url: `${base}/iii-console-x86_64-apple-darwin.tar.gz`, ext: "tar.gz" };
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return { url: `${base}/iii-console-aarch64-apple-darwin.tar.gz`, ext: "tar.gz" };
+  }
+  if (platform === "win32" && arch === "x64") {
+    return { url: `${base}/iii-console-x86_64-pc-windows-msvc.zip`, ext: "zip" };
+  }
+  if (platform === "win32" && arch === "arm64") {
+    return { url: `${base}/iii-console-aarch64-pc-windows-msvc.zip`, ext: "zip" };
+  }
+  throw new Error(`Unsupported platform for iii-console: ${platform}/${arch}`);
+}
+function semverFromTag(tag) {
+  return tag.replace(/^.*\/v?/, "").replace(/^v/, "");
+}
+function toReleaseTag(version) {
+  if (version.includes("/")) return version;
+  return `v${version.replace(/^v/, "")}`;
+}
+async function fetchLatestConsoleVersion() {
+  const res = await fetch("https://api.github.com/repos/iii-hq/iii/releases/latest", {
+    headers: { "Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28" }
+  });
+  if (res.status === 403 || res.status === 429) {
+    const retryAfter = res.headers.get("retry-after") ?? res.headers.get("x-ratelimit-reset");
+    throw new RateLimitError(`GitHub API rate limit exceeded${retryAfter ? ` (retry after ${retryAfter})` : ""}`);
   }
-  return timeout;
+  if (!res.ok) throw new Error(`Failed to fetch latest iii version: ${res.statusText}`);
+  const data = await res.json();
+  return data.tag_name;
 }
-function getStepExecutionTimeout(step, config) {
-  if (step.stepTimeout !== void 0) {
-    return step.stepTimeout;
+class RateLimitError extends Error {
+}
+async function getCurrentConsoleVersion(binaryPath) {
+  try {
+    const { stdout } = await execAsync(`"${binaryPath}" --version`);
+    const match = stdout.trim().match(/(\d+\.\d+\.\d+)/);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
   }
-  if (config?.flow?.stepTimeout !== void 0) {
-    return config.flow.stepTimeout;
+}
+async function downloadAndExtractConsole(assetUrl, ext, binDir, logLevel = "warn") {
+  const archivePath = join(binDir, ext === "zip" ? "iii-console.zip" : "iii-console.tar.gz");
+  if (logLevel === "info") logger.info(`Downloading iii-console from ${assetUrl}`);
+  const res = await fetch(assetUrl);
+  if (!res.ok) throw new Error(`Failed to download iii-console: ${res.status} ${res.statusText}`);
+  if (!res.body) throw new Error("Response body is empty");
+  const fileStream = createWriteStream(archivePath);
+  await pipeline(res.body, fileStream);
+  if (logLevel === "info") logger.info("Extracting iii-console archive...");
+  if (ext === "tar.gz") {
+    await execAsync(`tar -xzf "${archivePath}" -C "${binDir}"`);
+  } else {
+    await execAsync(`unzip -o "${archivePath}" -d "${binDir}"`);
   }
-  if (config?.queue?.defaultJobOptions?.timeout !== void 0) {
-    return config.queue.defaultJobOptions.timeout;
+  try {
+    unlinkSync(archivePath);
+  } catch {
   }
-  return void 0;
 }
-function calculateFlowStallTimeout(steps, levels) {
-  const DEFAULT_STALL_TIMEOUT = 30 * 60 * 1e3;
-  const MIN_BUFFER = 5 * 60 * 1e3;
-  const BUFFER_PERCENTAGE = 0.1;
-  const DEFAULT_STEP_TIMEOUT = 5 * 60 * 1e3;
-  const levelTimeouts = [];
-  for (const levelSteps of levels) {
-    let maxLevelTimeout = 0;
-    for (const stepName of levelSteps) {
-      const step = steps[stepName];
-      if (!step) continue;
-      const stepExecTimeout = step.stepTimeout ?? DEFAULT_STEP_TIMEOUT;
-      const awaitTimeout = getStepAwaitTimeout(step);
-      const totalStepTimeout = stepExecTimeout + awaitTimeout;
-      if (totalStepTimeout > 0) {
-        maxLevelTimeout = Math.max(maxLevelTimeout, totalStepTimeout);
+async function ensureIiiConsole(options) {
+  const { binDir } = options;
+  const logLevel = options.logLevel ?? "warn";
+  const binaryName = process.platform === "win32" ? "iii-console.exe" : "iii-console";
+  const binaryPath = join(binDir, binaryName);
+  let version = options.version;
+  if (!version || version === "latest") {
+    if (logLevel === "info") logger.info("Resolving latest iii-console version...");
+    try {
+      version = await fetchLatestConsoleVersion();
+      if (logLevel === "info") logger.info(`Latest iii-console version: ${version}`);
+    } catch (err) {
+      if (err instanceof RateLimitError) {
+        if (existsSync(binaryPath)) {
+          logger.warn(`[nvent] ${err.message} \u2014 using existing iii-console binary at ${binaryPath}`);
+          return binaryPath;
+        }
+        throw new Error(`${err.message} and no existing iii-console binary found. Specify a version in nvent config (e.g. console: { version: '0.8.0' }) to avoid GitHub API calls.`);
       }
+      throw err;
     }
-    if (maxLevelTimeout > 0) {
-      levelTimeouts.push(maxLevelTimeout);
+  }
+  if (existsSync(binaryPath)) {
+    const current = await getCurrentConsoleVersion(binaryPath);
+    const wantedSemver = semverFromTag(version);
+    if (current === wantedSemver) {
+      if (logLevel === "info") logger.info(`iii-console v${wantedSemver} already installed`);
+      return binaryPath;
     }
+    if (logLevel === "info") logger.info(`iii-console version mismatch (installed: ${current}, wanted: ${wantedSemver}) \u2014 updating`);
   }
-  if (levelTimeouts.length === 0) {
-    return DEFAULT_STALL_TIMEOUT;
+  if (!existsSync(binDir)) {
+    mkdirSync(binDir, { recursive: true });
   }
-  const totalAwaitTimeout = levelTimeouts.reduce((sum, timeout) => sum + timeout, 0);
-  const buffer = Math.max(totalAwaitTimeout * BUFFER_PERCENTAGE, MIN_BUFFER);
-  const calculatedTimeout = totalAwaitTimeout + buffer;
-  if (calculatedTimeout > DEFAULT_STALL_TIMEOUT * 2) {
-    console.log(
-      `[flow-analyzer] Flow stall timeout calculated across ${levelTimeouts.length} levels: ${calculatedTimeout / 1e3}s (total time: ${totalAwaitTimeout / 1e3}s, level timeouts: [${levelTimeouts.map((t) => `${t / 1e3}s`).join(", ")}])`
-    );
+  const asset = getConsolePlatformAsset(version);
+  await downloadAndExtractConsole(asset.url, asset.ext, binDir, logLevel);
+  if (!existsSync(binaryPath)) {
+    throw new Error(`iii-console binary not found at ${binaryPath} after extraction`);
   }
-  return calculatedTimeout;
+  chmodSync(binaryPath, 493);
+  if (logLevel === "info") logger.info(`iii-console ${version} installed at ${binaryPath}`);
+  return binaryPath;
+}
+
+function defaultIiiEngineConfig() {
+  return {
+    wsPort: 49134,
+    httpPort: 3111,
+    streamPort: 3112,
+    modules: {
+      state: true,
+      queue: true,
+      cron: true,
+      observability: true,
+      stream: true
+    }
+  };
+}
+function defaultStateAdapter(stateDir) {
+  return {
+    class: "modules::state::adapters::KvStore",
+    config: { store_method: "file_based", file_path: "./data/state_store" }
+  };
+}
+function defaultQueueAdapter(queueDir) {
+  return {
+    class: "modules::queue::BuiltinQueueAdapter",
+    config: { store_method: "file_based", file_path: "./data/queue_store" }
+  };
+}
+function defaultCronAdapter() {
+  return { class: "modules::cron::KvCronAdapter" };
 }
-function analyzeFlow(flow, config) {
-  const entryStepName = flow.entry?.step;
-  const steps = flow.steps || {};
-  const dependencies = buildDependencyGraph(entryStepName, steps, flow.entry);
-  const levels = calculateLevels(entryStepName, dependencies);
-  const analyzedSteps = {};
-  if (flow.entry && entryStepName) {
-    const hasAwaitPattern = !!(flow.entry.awaitBefore || flow.entry.awaitAfter);
-    const entryStep = {
-      queue: flow.entry.queue,
-      workerId: flow.entry.workerId,
-      emits: flow.entry.emits,
-      stepTimeout: flow.entry.stepTimeout,
-      // Include stepTimeout from flow metadata
-      awaitBefore: flow.entry.awaitBefore,
-      awaitAfter: flow.entry.awaitAfter,
-      name: entryStepName,
-      dependsOn: [],
-      triggers: findTriggeredSteps(entryStepName, flow.entry, steps),
-      level: 0,
-      hasAwaitPattern
+function defaultStreamAdapter() {
+  return { class: "modules::stream::adapters::KvStore" };
+}
+function generateIiiConfigYaml(cfg) {
+  const modules = [];
+  const restApiConfig = {
+    port: cfg.restApi?.port ?? cfg.httpPort
+  };
+  if (cfg.restApi?.host) restApiConfig.host = cfg.restApi.host;
+  if (cfg.restApi?.default_timeout != null) restApiConfig.default_timeout = cfg.restApi.default_timeout;
+  if (cfg.restApi?.concurrency_request_limit != null) restApiConfig.concurrency_request_limit = cfg.restApi.concurrency_request_limit;
+  modules.push({ class: "modules::api::RestApiModule", config: restApiConfig });
+  if (cfg.modules.state !== false) {
+    const adapter = cfg.state?.adapter ?? defaultStateAdapter();
+    modules.push({ class: "modules::state::StateModule", config: { adapter } });
+  }
+  if (cfg.modules.queue !== false) {
+    const adapter = cfg.queue?.adapter ?? defaultQueueAdapter();
+    const queueModCfg = { adapter };
+    const queueConfigs = cfg.queue?.queue_configs;
+    if (queueConfigs && Object.keys(queueConfigs).length > 0) {
+      queueModCfg.queue_configs = queueConfigs;
+    }
+    modules.push({ class: "modules::queue::QueueModule", config: queueModCfg });
+  }
+  if (cfg.modules.cron !== false) {
+    const adapter = cfg.cron?.adapter ?? defaultCronAdapter();
+    modules.push({ class: "modules::cron::CronModule", config: { adapter } });
+  }
+  if (cfg.modules.stream !== false) {
+    const streamCfg = {
+      port: cfg.stream?.port ?? cfg.streamPort
     };
-    entryStep.stepTimeout = getStepExecutionTimeout(entryStep, config);
-    analyzedSteps[entryStepName] = entryStep;
-  }
-  for (const [stepName, step] of Object.entries(steps)) {
-    const hasAwaitPattern = !!(step.awaitBefore || step.awaitAfter);
-    const analyzedStep = {
-      ...step,
-      name: stepName,
-      dependsOn: dependencies[stepName] || [],
-      triggers: findTriggeredSteps(stepName, step, steps),
-      level: levels[stepName] ?? 1,
-      hasAwaitPattern
-      // stepTimeout from ...step spread above (per-function config)
+    if (cfg.stream?.host) streamCfg.host = cfg.stream.host;
+    if (cfg.stream?.auth_function !== void 0) streamCfg.auth_function = cfg.stream.auth_function;
+    const streamAdapter = cfg.stream?.adapter ?? defaultStreamAdapter();
+    streamCfg.adapter = streamAdapter;
+    modules.push({ class: "modules::stream::StreamModule", config: streamCfg });
+  }
+  if (cfg.modules.observability !== false) {
+    const oCfg = cfg.observability ?? {};
+    const otelConfig = {
+      enabled: oCfg.enabled ?? true,
+      service_name: oCfg.service_name ?? "nvent",
+      exporter: oCfg.exporter ?? "memory"
     };
-    analyzedStep.stepTimeout = getStepExecutionTimeout(analyzedStep, config);
-    analyzedSteps[stepName] = analyzedStep;
-  }
-  const maxLevel = Math.max(0, ...Object.values(levels));
-  const levelGroups = Array.from({ length: maxLevel + 1 }, () => []);
-  if (entryStepName && flow.entry) {
-    levelGroups[0]?.push(entryStepName);
-  }
-  for (const [stepName, level] of Object.entries(levels)) {
-    if (stepName === entryStepName) continue;
-    const levelArray = levelGroups[level];
-    if (levelArray) {
-      levelArray.push(stepName);
-    }
+    if (oCfg.service_version) otelConfig.service_version = oCfg.service_version;
+    if (oCfg.service_namespace) otelConfig.service_namespace = oCfg.service_namespace;
+    if (oCfg.endpoint) otelConfig.endpoint = oCfg.endpoint;
+    if (oCfg.sampling_ratio != null) otelConfig.sampling_ratio = oCfg.sampling_ratio;
+    if (oCfg.memory_max_spans != null) otelConfig.memory_max_spans = oCfg.memory_max_spans;
+    if (oCfg.metrics_enabled != null) otelConfig.metrics_enabled = oCfg.metrics_enabled;
+    if (oCfg.metrics_exporter) otelConfig.metrics_exporter = oCfg.metrics_exporter;
+    if (oCfg.metrics_retention_seconds != null) otelConfig.metrics_retention_seconds = oCfg.metrics_retention_seconds;
+    if (oCfg.metrics_max_count != null) otelConfig.metrics_max_count = oCfg.metrics_max_count;
+    if (oCfg.logs_enabled != null) otelConfig.logs_enabled = oCfg.logs_enabled;
+    if (oCfg.logs_exporter) otelConfig.logs_exporter = oCfg.logs_exporter;
+    if (oCfg.logs_max_count != null) otelConfig.logs_max_count = oCfg.logs_max_count;
+    if (oCfg.logs_retention_seconds != null) otelConfig.logs_retention_seconds = oCfg.logs_retention_seconds;
+    if (oCfg.logs_batch_size != null) otelConfig.logs_batch_size = oCfg.logs_batch_size;
+    if (oCfg.logs_flush_interval_ms != null) otelConfig.logs_flush_interval_ms = oCfg.logs_flush_interval_ms;
+    if (oCfg.logs_sampling_ratio != null) otelConfig.logs_sampling_ratio = oCfg.logs_sampling_ratio;
+    if (oCfg.logs_console_output != null) otelConfig.logs_console_output = oCfg.logs_console_output;
+    if (oCfg.level) otelConfig.level = oCfg.level;
+    if (oCfg.format) otelConfig.format = oCfg.format;
+    modules.push({ class: "modules::observability::OtelModule", config: otelConfig });
   }
-  const stallTimeout = calculateFlowStallTimeout(analyzedSteps, levelGroups);
-  const awaitSteps = Object.values(analyzedSteps).filter((s) => s.hasAwaitPattern);
-  const totalTimeout = awaitSteps.reduce((sum, s) => {
-    let stepTimeout = 0;
-    if (s.awaitBefore?.timeout) stepTimeout += s.awaitBefore.timeout;
-    if (s.awaitAfter?.timeout) stepTimeout += s.awaitAfter.timeout;
-    return sum + stepTimeout;
-  }, 0);
-  const awaitPatterns = awaitSteps.length > 0 ? {
-    steps: awaitSteps.map((s) => s.name),
-    beforeCount: awaitSteps.filter((s) => s.awaitBefore).length,
-    afterCount: awaitSteps.filter((s) => s.awaitAfter).length,
-    totalTimeout
-  } : void 0;
+  return `# Auto-generated by nvent \u2014 do not edit manually
+` + stringifyYAML({ port: cfg.wsPort, modules });
+}
+function writeIiiConfig(outputPath, cfg) {
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, generateIiiConfigYaml(cfg), "utf-8");
+}
+function buildEngineConfig(iiiOpts) {
+  const queueConfigs = iiiOpts.queue?.queueConfigs;
+  const hasQueueConfigs = queueConfigs != null && Object.keys(queueConfigs).length > 0;
   return {
-    id: flow.id,
-    entry: flow.entry,
-    steps: analyzedSteps,
-    levels: levelGroups,
-    maxLevel,
-    stallTimeout,
-    awaitPatterns
+    ...defaultIiiEngineConfig(),
+    wsPort: iiiOpts.wsPort ?? 49134,
+    httpPort: iiiOpts.httpPort ?? 3111,
+    streamPort: iiiOpts.streamPort ?? 3112,
+    modules: { state: true, queue: true, cron: true, observability: true, stream: true, ...iiiOpts.modules },
+    state: iiiOpts.state ? { adapter: mapStateAdapter(iiiOpts.state) } : void 0,
+    queue: iiiOpts.queue ? {
+      adapter: mapQueueAdapter(iiiOpts.queue?.adapter),
+      queue_configs: hasQueueConfigs ? Object.fromEntries(
+        Object.entries(queueConfigs).map(([name, cfg]) => [
+          name,
+          { type: cfg.type, concurrency: cfg.concurrency, max_retries: cfg.maxRetries, backoff_ms: cfg.backoffMs, message_group_field: cfg.messageGroupField }
+        ])
+      ) : void 0
+    } : void 0,
+    cron: iiiOpts.cron ? { adapter: mapCronAdapter(iiiOpts.cron) } : void 0,
+    stream: iiiOpts.stream ? {
+      host: iiiOpts.stream.host,
+      auth_function: iiiOpts.stream.authFunction,
+      adapter: mapStreamAdapter(iiiOpts.stream)
+    } : void 0,
+    restApi: iiiOpts.restApi ? {
+      host: iiiOpts.restApi.host,
+      default_timeout: iiiOpts.restApi.defaultTimeout,
+      concurrency_request_limit: iiiOpts.restApi.concurrencyRequestLimit
+    } : void 0,
+    observability: iiiOpts.observability ? {
+      enabled: iiiOpts.observability.enabled,
+      service_name: iiiOpts.observability.serviceName,
+      service_version: iiiOpts.observability.serviceVersion,
+      service_namespace: iiiOpts.observability.serviceNamespace,
+      exporter: iiiOpts.observability.exporter,
+      endpoint: iiiOpts.observability.endpoint,
+      sampling_ratio: iiiOpts.observability.samplingRatio,
+      memory_max_spans: iiiOpts.observability.memoryMaxSpans,
+      metrics_enabled: iiiOpts.observability.metricsEnabled,
+      metrics_exporter: iiiOpts.observability.metricsExporter,
+      metrics_retention_seconds: iiiOpts.observability.metricsRetentionSeconds,
+      metrics_max_count: iiiOpts.observability.metricsMaxCount,
+      logs_enabled: iiiOpts.observability.logsEnabled,
+      logs_exporter: iiiOpts.observability.logsExporter,
+      logs_max_count: iiiOpts.observability.logsMaxCount,
+      logs_retention_seconds: iiiOpts.observability.logsRetentionSeconds,
+      logs_batch_size: iiiOpts.observability.logsBatchSize,
+      logs_flush_interval_ms: iiiOpts.observability.logsFlushIntervalMs,
+      logs_sampling_ratio: iiiOpts.observability.logsSamplingRatio,
+      logs_console_output: iiiOpts.observability.logsConsoleOutput,
+      level: iiiOpts.observability.level,
+      format: iiiOpts.observability.format
+    } : void 0
   };
 }
-
-async function compileRegistryFromServerWorkers(layers, queuesDir = "queues", defaults) {
-  const { workers, flowSources } = await scanWorkers(layers, queuesDir);
-  const mergedWorkers = defaults ? mergeAllWorkerConfigs(workers, defaults) : workers;
-  const { flows, eventIndex } = buildFlows(flowSources);
-  const compiled = {
-    workers: mergedWorkers,
-    flows,
-    eventIndex
+function mapStateAdapter(a) {
+  if (!a?.adapter) return void 0;
+  if (a.adapter.type === "redis")
+    return { class: "modules::state::adapters::RedisAdapter", config: { redis_url: a.adapter.redisUrl } };
+  return {
+    class: "modules::state::adapters::KvStore",
+    config: { store_method: a.adapter.storeMethod, file_path: a.adapter.filePath }
   };
-  return compiled;
 }
-
-const logger = useLogger("nvent");
-function watchQueueFiles(options) {
-  const { nuxt, layerInfos, queuesDir, onRefresh } = options;
-  const dirsToWatch = layerInfos.map((layer) => {
-    const serverDir = layer.serverDir || join$1(layer.rootDir, "server");
-    return join$1(serverDir, queuesDir);
-  }).filter(Boolean);
-  if (dirsToWatch.length === 0) {
-    logger.warn("No queue directories found to watch");
-    return;
-  }
-  logger.info("Watching queue directories:", dirsToWatch);
-  const watcher = chokidar.watch(dirsToWatch, {
-    ignoreInitial: true,
-    persistent: true,
-    ignorePermissionErrors: true,
-    ignored: [
-      "**/node_modules/**",
-      "**/__pycache__/**",
-      "**/.git/**",
-      "**/dist/**",
-      "**/.nuxt/**"
-    ],
-    // Watch only specific file types
-    awaitWriteFinish: {
-      stabilityThreshold: 100,
-      pollInterval: 100
-    }
-  });
-  logger.info("Chokidar watcher initialized");
-  logger.info("Watched patterns:", dirsToWatch.map((dir) => `${dir}/**/*.{ts,js,py}`));
-  watcher.on("ready", () => {
-    const watched = watcher.getWatched();
-    const fileCount = Object.values(watched).reduce((sum, files) => sum + files.length, 0);
-    logger.success(`Queue file watcher ready - watching ${fileCount} files`);
-  });
-  const debouncedRefresh = debounce(onRefresh, 150);
-  watcher.on("all", (event, path) => {
-    logger.info(`Watcher event: ${event} - ${path}`);
-  });
-  watcher.on("add", async (path) => {
-    logger.info(`Queue file added: ${path}`);
-    await debouncedRefresh("add", path);
-  });
-  watcher.on("change", async (path) => {
-    logger.info(`Queue file changed: ${path}`);
-    await debouncedRefresh("change", path);
-  });
-  watcher.on("unlink", async (path) => {
-    logger.info(`Queue file removed: ${path}`);
-    await debouncedRefresh("unlink", path);
-  });
-  watcher.on("error", (error) => {
-    logger.error("Watcher error:", error);
-  });
-  nuxt.hook("close", () => {
-    logger.info("Closing queue file watcher");
-    watcher.close();
-  });
-  return watcher;
+function mapQueueAdapter(a) {
+  if (!a) return void 0;
+  if (a.type === "redis")
+    return { class: "modules::queue::RedisAdapter", config: { redis_url: a.redisUrl } };
+  if (a.type === "rabbitmq")
+    return { class: "modules::queue::RabbitMQAdapter", config: { amqp_url: a.amqpUrl } };
+  return {
+    class: "modules::queue::BuiltinQueueAdapter",
+    config: { store_method: a.storeMethod, file_path: a.filePath }
+  };
+}
+function mapCronAdapter(a) {
+  if (!a?.adapter) return void 0;
+  if (a.adapter.type === "redis")
+    return { class: "modules::cron::RedisCronAdapter", config: { redis_url: a.adapter.redisUrl } };
+  return { class: "modules::cron::KvCronAdapter" };
+}
+function mapStreamAdapter(a) {
+  if (!a?.adapter) return void 0;
+  if (a.adapter.type === "redis")
+    return { class: "modules::stream::adapters::RedisAdapter", config: { redis_url: a.adapter.redisUrl } };
+  return {
+    class: "modules::stream::adapters::KvStore",
+    config: { store_method: a.adapter.storeMethod, file_path: a.adapter.filePath }
+  };
 }
 
-function analyzeTriggerDefinitions(workers) {
-  const triggers = [];
-  const seenTriggers = /* @__PURE__ */ new Set();
-  for (const worker of workers) {
-    const triggerDef = worker.flow?.triggers?.define;
-    if (!triggerDef) continue;
-    if (seenTriggers.has(triggerDef.name)) continue;
-    seenTriggers.add(triggerDef.name);
-    triggers.push({
-      name: triggerDef.name,
-      type: triggerDef.type,
-      scope: triggerDef.scope || "flow",
-      displayName: triggerDef.displayName,
-      description: triggerDef.description,
-      source: `function:${worker.name}`,
-      expectedSubscribers: triggerDef.expectedSubscribers,
-      webhook: triggerDef.webhook,
-      schedule: triggerDef.schedule,
-      config: triggerDef.config,
-      registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      registeredBy: "code"
-    });
-  }
-  return triggers;
+function filePathToFunctionId(relPath) {
+  const noExt = relPath.replace(/\.[a-zA-Z]+$/, "");
+  return noExt.split(/[\\/]/).join("::");
 }
-function analyzeTriggerSubscriptions(workers) {
-  const subscriptions = [];
-  for (const worker of workers) {
-    if (!worker.flow?.triggers?.subscribe) continue;
-    const flowNames = Array.isArray(worker.flow.names) ? worker.flow.names : [worker.flow.names];
-    for (const flowName of flowNames) {
-      for (const triggerName of worker.flow.triggers.subscribe) {
-        subscriptions.push({
-          triggerName,
-          flowName,
-          mode: worker.flow.triggers.mode || "auto",
-          source: "config",
-          registeredAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
+function detectPythonStandalone(absPath) {
+  try {
+    const src = readFileSync(absPath, "utf-8");
+    return /['"]standalone['"]\s*:\s*True/.test(src);
+  } catch {
+    return false;
   }
-  return subscriptions;
 }
-function buildTriggerIndex(subscriptions) {
-  const triggerToFlows = /* @__PURE__ */ new Map();
-  const flowToTriggers = /* @__PURE__ */ new Map();
-  for (const sub of subscriptions) {
-    if (!triggerToFlows.has(sub.triggerName)) {
-      triggerToFlows.set(sub.triggerName, /* @__PURE__ */ new Set());
+async function scanFunctions(opts) {
+  const { layerInfos, functionsDir = "functions" } = opts;
+  const functions = [];
+  const pythonFunctions = [];
+  for (const layer of layerInfos) {
+    const serverDir = layer.serverDir || join(layer.rootDir, "server");
+    const fnDir = join(serverDir, functionsDir);
+    if (!existsSync(fnDir)) continue;
+    const [jsFiles, pyFiles] = await Promise.all([
+      globby(["**/*.{ts,js,mts,mjs}"], {
+        cwd: fnDir,
+        absolute: false,
+        ignore: ["**/*.d.ts", "**/*.test.*", "**/*.spec.*"]
+      }),
+      globby(["**/*.py"], {
+        cwd: fnDir,
+        absolute: false,
+        ignore: ["**/__pycache__/**", "**/*.pyc"]
+      })
+    ]);
+    for (const file of jsFiles) {
+      functions.push({ id: filePathToFunctionId(file), absPath: join(fnDir, file), relativePath: file });
     }
-    triggerToFlows.get(sub.triggerName).add(sub.flowName);
-    if (!flowToTriggers.has(sub.flowName)) {
-      flowToTriggers.set(sub.flowName, /* @__PURE__ */ new Set());
+    for (const file of pyFiles) {
+      const absPath = join(fnDir, file);
+      const standalone = detectPythonStandalone(absPath);
+      pythonFunctions.push({ id: filePathToFunctionId(file), absPath, relativePath: file, standalone });
     }
-    flowToTriggers.get(sub.flowName).add(sub.triggerName);
   }
-  return { triggerToFlows, flowToTriggers };
-}
-
-function generateRegistryTemplate(registry) {
-  return `// auto-generated by nvent
-export const registry = ${JSON.stringify(registry, null, 2)};
-
-export const useFunctionRegistry = () => registry;
-
-export default useFunctionRegistry;
-`;
+  return { functions, pythonFunctions };
 }
-function generateHandlersTemplate(registry) {
-  const regWorkers = registry?.workers || [];
-  const lines = [];
-  const entries = [];
-  regWorkers.filter((w) => w?.kind === "ts" && (w?.runtype ? w.runtype !== "task" : registry?.runner?.ts?.isolate !== "task")).forEach((w, i) => {
-    const varName = `h${i}`;
-    const moduleVar = `m${i}`;
-    const src = w && (w.absPath || w.abs || w.cwd && w.file && join(w.cwd, w.file) || w.entry || w.path) || "";
-    if (!src) return;
-    const importPath = String(src);
-    lines.push(`import ${varName} from '${importPath}'`);
-    lines.push(`import * as ${moduleVar} from '${importPath}'`);
-    const queue = String(w?.queue?.name || `w${i}`);
-    const id = String(w?.id || `w${i}`);
-    const absPath = importPath;
-    entries.push(`{ queue: '${queue}', id: '${id}', absPath: '${absPath}', handler: ${varName}, module: ${moduleVar} }`);
+function generateIiiRegistryTemplate(scanned, pythonPathRewrite) {
+  const lines = ["// auto-generated by nvent \u2014 do not edit", ""];
+  lines.push(`function _stepEntry(ns, fallbackName, absPath) {`);
+  lines.push(`  const def = ns.default`);
+  lines.push(`  const meta = ns.meta`);
+  lines.push(`  const triggers = ns.triggers`);
+  lines.push(`  if (def?.__nventStep) {`);
+  lines.push(`    const name = def.name ?? fallbackName`);
+  lines.push(`    return { name, description: def.description, handler: def.handler, triggers: (def.triggers ?? []).map(t => ({ ...t, function_id: name })), enqueues: def.enqueues ?? [], flows: def.flows ?? [], stream: def.stream, filePath: absPath }`);
+  lines.push(`  }`);
+  lines.push(`  const name = meta?.name ?? fallbackName`);
+  lines.push(`  return { name, description: meta?.description, handler: def, triggers: (triggers ?? []).map(t => ({ ...t, function_id: name })), enqueues: [], flows: [], stream: undefined, filePath: absPath }`);
+  lines.push(`}`);
+  lines.push("");
+  const entries = scanned.functions.map((fn, i) => {
+    const ns = `fn${i}`;
+    lines.push(`import * as ${ns} from ${genString(fn.absPath)}`);
+    return `_stepEntry(${ns}, ${genString(fn.id)}, ${genString(fn.absPath)})`;
   });
-  return `// auto-generated by nvent
-${lines.join("\n")}
-
-export const handlers = [
-  ${entries.join(",\n  ")}
-]
-
-export const useWorkerHandlers = () => handlers;
-
-export default useWorkerHandlers;
-`;
+  lines.push("");
+  lines.push(`export const registry = {`);
+  lines.push(`  functions: [${entries.join(", ")}],`);
+  lines.push(`  get triggers() { return this.functions.flatMap(f => f.triggers ?? []) },`);
+  lines.push(`}`);
+  lines.push("");
+  lines.push("export default registry");
+  lines.push("");
+  lines.push(`export const pythonFunctions = ${JSON.stringify(scanned.pythonFunctions.map((fn) => ({
+    id: fn.id,
+    absPath: pythonPathRewrite?.get(fn.absPath) ?? fn.absPath,
+    standalone: fn.standalone
+  })))}`);
+  lines.push("");
+  return lines.join("\n");
 }
-function generateAnalyzedFlowsTemplate(registry) {
-  const flows = registry?.flows || {};
-  const workers = registry?.workers || [];
-  const workerMetaMap = /* @__PURE__ */ new Map();
-  for (const worker of workers) {
-    workerMetaMap.set(worker.id, {
-      runtime: worker.kind === "py" ? "python" : "nodejs",
-      runtype: worker.runtype,
-      queue: worker.queue,
-      worker: worker.worker,
-      emits: worker.flow?.emits
+
+async function installPythonRequirements(requirementsPath, pythonBin, logLevel) {
+  if (!existsSync(requirementsPath)) return;
+  if (logLevel !== "none") console.log(`[nvent] Installing Python requirements from ${requirementsPath}`);
+  return new Promise((resolve) => {
+    const proc = spawn(pythonBin, ["-m", "pip", "install", "-r", requirementsPath, "--quiet"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    proc.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("exit", (code) => {
+      if (code !== 0 && logLevel !== "none") console.error(`[nvent] pip install failed (code=${code}):
+${stderr.trim()}`);
+      else if (code === 0 && logLevel !== "none") console.log("[nvent] Python requirements installed");
+      resolve();
+    });
+    proc.on("error", (err) => {
+      if (logLevel !== "none") console.error(`[nvent] pip install error: ${err.message}`);
+      resolve();
     });
-  }
-  const analyzedFlows = Object.entries(flows).map(([id, meta]) => {
-    const workerMeta = meta?.entry ? workerMetaMap.get(meta.entry.workerId) : void 0;
-    const entry = meta?.entry ? {
-      ...meta.entry,
-      runtime: workerMeta?.runtime,
-      runtype: workerMeta?.runtype,
-      emits: workerMeta?.emits
-    } : void 0;
-    const steps = meta?.steps ? Object.fromEntries(
-      Object.entries(meta.steps).map(([stepName, stepData]) => {
-        const stepWorkerMeta = workerMetaMap.get(stepData.workerId);
-        return [
-          stepName,
-          {
-            ...stepData,
-            runtime: stepWorkerMeta?.runtime,
-            runtype: stepWorkerMeta?.runtype,
-            emits: stepWorkerMeta?.emits
-          }
-        ];
-      })
-    ) : {};
-    const flowMeta = {
-      id,
-      entry,
-      steps
-    };
-    const analyzed = analyzeFlow(flowMeta, registry.config);
-    return {
-      ...flowMeta,
-      analyzed: {
-        levels: analyzed.levels,
-        maxLevel: analyzed.maxLevel,
-        stallTimeout: analyzed.stallTimeout,
-        awaitPatterns: analyzed.awaitPatterns,
-        steps: analyzed.steps
-      }
-    };
   });
-  return `// auto-generated by nvent
-export const analyzedFlows = ${JSON.stringify(analyzedFlows, null, 2)};
-
-export const useAnalyzedFlows = () => analyzedFlows;
-
-export default useAnalyzedFlows;
-`;
-}
-function generateTriggerRegistryTemplate(registry) {
-  const workers = registry?.workers || [];
-  const triggers = analyzeTriggerDefinitions(workers);
-  const subscriptions = analyzeTriggerSubscriptions(workers);
-  const index = buildTriggerIndex(subscriptions);
-  const triggerToFlows = {};
-  for (const [trigger, subs] of index.triggerToFlows.entries()) {
-    triggerToFlows[trigger] = Array.from(subs);
-  }
-  const flowToTriggers = {};
-  for (const [flow, triggers2] of index.flowToTriggers.entries()) {
-    flowToTriggers[flow] = Array.from(triggers2);
-  }
-  const triggerRegistry = {
-    triggers,
-    subscriptions,
-    index: {
-      triggerToFlows,
-      flowToTriggers
-    },
-    compiledAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  return `// auto-generated by nvent
-export const triggerRegistry = ${JSON.stringify(triggerRegistry, null, 2)};
-
-export const useTriggerRegistry = () => triggerRegistry;
-
-export default useTriggerRegistry;
-`;
-}
-function generateAdapterTypesTemplate(resolverFn) {
-  return `// Auto-generated adapter type definitions
-// External adapter packages can import these types
-
-// Queue Adapter
-export type {
-  QueueAdapter,
-  JobInput,
-  Job,
-  JobsQuery,
-  JobOptions,
-  JobState,
-  ScheduleOptions,
-  JobCounts,
-  QueueEvent,
-  WorkerHandler,
-  WorkerContext,
-  WorkerOptions,
-} from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/queue"))}
-
-// Stream Adapter
-export type {
-  StreamAdapter,
-  StreamEvent,
-  SubscribeOptions,
-  SubscriptionHandle,
-} from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/stream"))}
-
-// Store Adapter
-export type {
-  StoreAdapter,
-  EventRecord,
-  EventReadOptions,
-  EventSubscription,
-  ListOptions,
-} from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/store"))}
-
-// Flow Types
-export type {
-  FlowStats,
-  StartFlowResult,
-  CancelFlowResult,
-  RestartFlowResult,
-  RunningFlow,
-  FlowComposable,
-} from ${JSON.stringify(resolverFn("./runtime/nitro/utils/useFlow"))}
-
-// Runner Context Types
-export type {
-  QueueJob,
-  RunLogger,
-  RunState,
-  RunContextFlow,
-  RunContext,
-  NodeHandler,
-} from ${JSON.stringify(resolverFn("./runtime/worker/node/runner"))}
-
-// Event Types
-export type {
-  EventType,
-  BaseEvent,
-  StepEvent,
-  FlowStartEvent,
-  FlowCompletedEvent,
-  FlowFailedEvent,
-  FlowCancelEvent,
-  FlowStalledEvent,
-  StepStartedEvent,
-  StepCompletedEvent,
-  StepFailedEvent,
-  StepRetryEvent,
-  LogEvent,
-  EmitEvent,
-  StateEvent,
-  FlowEvent,
-} from ${JSON.stringify(resolverFn("./runtime/events/types"))}
-
-// Adapter Registry
-export type { AdapterRegistry } from ${JSON.stringify(resolverFn("./runtime/adapters/registry"))}`;
 }
-
-function getServerImports(resolverFn, buildDir) {
-  return [
-    // Generated templates
-    {
-      name: "useFunctionRegistry",
-      as: "$useFunctionRegistry",
-      from: resolverFn(buildDir + "/function-registry")
-    },
-    {
-      name: "useWorkerHandlers",
-      as: "$useWorkerHandlers",
-      from: resolverFn(buildDir + "/worker-handlers")
-    },
-    {
-      name: "useAnalyzedFlows",
-      as: "$useAnalyzedFlows",
-      from: resolverFn(buildDir + "/analyzed-flows")
-    },
-    {
-      name: "useTriggerRegistry",
-      as: "$useTriggerRegistry",
-      from: resolverFn(buildDir + "/trigger-registry")
-    },
-    // Core utilities for user code
-    {
-      name: "defineFunctionConfig",
-      from: resolverFn("./runtime/nitro/utils/defineFunctionConfig")
-    },
-    {
-      name: "defineFunction",
-      from: resolverFn("./runtime/nitro/utils/defineFunction")
-    },
-    // Composables users may need in server code
-    {
-      name: "useEventManager",
-      from: resolverFn("./runtime/nitro/utils/useEventManager")
-    },
-    {
-      name: "usePeerManager",
-      from: resolverFn("./runtime/nitro/utils/wsPeerManager")
-    },
-    {
-      name: "useNventLogger",
-      from: resolverFn("./runtime/nitro/utils/useNventLogger")
-    },
-    {
-      name: "useHookRegistry",
-      from: resolverFn("./runtime/nitro/utils/useHookRegistry")
-    },
-    {
-      name: "useAwait",
-      from: resolverFn("./runtime/nitro/utils/useAwait")
-    },
-    {
-      name: "useRunContext",
-      from: resolverFn("./runtime/nitro/utils/useRunContext")
-    },
-    {
-      name: "defineAwaitRegisterHook",
-      from: resolverFn("./runtime/nitro/utils/defineHooks")
-    },
-    {
-      name: "defineAwaitResolveHook",
-      from: resolverFn("./runtime/nitro/utils/defineHooks")
-    },
-    {
-      name: "defineAwaitTimeoutHook",
-      from: resolverFn("./runtime/nitro/utils/defineHooks")
-    },
-    // Adapter composables
-    {
-      name: "useQueueAdapter",
-      from: resolverFn("./runtime/nitro/utils/adapters")
-    },
-    {
-      name: "useStoreAdapter",
-      from: resolverFn("./runtime/nitro/utils/adapters")
-    },
-    {
-      name: "useStreamAdapter",
-      from: resolverFn("./runtime/nitro/utils/adapters")
-    },
-    {
-      name: "useStateAdapter",
-      from: resolverFn("./runtime/nitro/utils/adapters")
-    },
-    {
-      name: "getAdapters",
-      from: resolverFn("./runtime/nitro/utils/adapters")
-    },
-    {
-      name: "setAdapters",
-      from: resolverFn("./runtime/nitro/utils/adapters")
-    },
-    // Runtime utilities
-    {
-      name: "useStreamTopics",
-      from: resolverFn("./runtime/nitro/utils/useStreamTopics")
-    },
-    {
-      name: "useTrigger",
-      from: resolverFn("./runtime/nitro/utils/useTrigger")
-    },
-    {
-      name: "useFlow",
-      from: resolverFn("./runtime/nitro/utils/useFlow")
-    },
-    // Scheduler
-    {
-      name: "useScheduler",
-      from: resolverFn("./runtime/scheduler")
-    },
-    {
-      name: "initializeScheduler",
-      from: resolverFn("./runtime/scheduler")
-    },
-    {
-      name: "shutdownScheduler",
-      from: resolverFn("./runtime/scheduler")
-    },
-    // Adapter registration utilities for external modules
-    {
-      name: "registerQueueAdapter",
-      from: resolverFn("./runtime/nitro/utils/registerAdapter")
-    },
-    {
-      name: "registerStreamAdapter",
-      from: resolverFn("./runtime/nitro/utils/registerAdapter")
-    },
-    {
-      name: "registerStoreAdapter",
-      from: resolverFn("./runtime/nitro/utils/registerAdapter")
-    },
-    // Adapter base utilities for external adapter packages
-    {
-      name: "createStoreValidator",
-      from: resolverFn("./runtime/adapters/base/store-validator")
-    }
-  ];
+function installNventPyToSitePackages(pythonBin, nventPyContent) {
+  if (!nventPyContent) return;
+  try {
+    const sitePackages = execFileSync(pythonBin, [
+      "-c",
+      "import site; dirs = site.getsitepackages(); print(dirs[0])"
+    ], { encoding: "utf-8", timeout: 5e3 }).trim();
+    writeFileSync(join(sitePackages, "nvent.py"), nventPyContent, "utf-8");
+  } catch {
+  }
 }
 
 const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -1172,140 +1143,230 @@ const meta = {
   version: packageJson.version,
   configKey: "nvent"
 };
-const module$1 = defineNuxtModule().with({
+const III_REGISTRY_TEMPLATE = "iii-registry.mjs";
+const module$1 = defineNuxtModule({
   meta,
   defaults: {},
+  moduleDependencies: {
+    "@nvent-addon/app": {
+      optional: true
+    }
+  },
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    const userConfig = nuxt.options[meta.configKey] || {};
-    const mergedOptions = { ...userConfig, ...options };
-    const config = normalizeModuleOptions(mergedOptions);
-    nuxt.hook("nitro:config", (nitro) => {
-      const redisConfig = getRedisStorageConfig(config);
-      nitro.storage = defu(nitro.storage || {}, {
-        redis: {
-          driver: "redis",
-          ...redisConfig
-          // base namespace handled in provider; keep storage base default
-        }
-      });
-      nitro.experimental = defu(nitro.experimental || {}, {
-        websocket: true
-      });
-    });
-    const runtimeConfig = nuxt.options.runtimeConfig;
-    runtimeConfig.nvent = defu(toRuntimeConfig(config), runtimeConfig.nvent || {});
-    if (!runtimeConfig.nvent) runtimeConfig.nvent = {};
-    runtimeConfig.nvent.rootDir = nuxt.options.rootDir;
+    const PYTHON_RUNTIME_SRC = resolve("./runtime/python/worker_runtime.py");
+    const PYTHON_NVENT_HELPER_SRC = resolve("./runtime/python/nvent.py");
+    const userConfig = nuxt.options[meta.configKey] ?? {};
+    const opts = { ...userConfig, ...options };
+    const iiiOpts = opts.iii ?? {};
+    const functionsDir = opts.functions?.dir ?? "functions";
+    const pythonBin = opts.functions?.python?.devPath ? join(nuxt.options.rootDir, opts.functions.python.devPath) : "python3";
+    const skipPython = opts.functions?.python?.skip ?? false;
+    const wsUrl = iiiOpts.wsUrl ?? "ws://localhost:49134";
+    const mode = iiiOpts.mode ?? "local";
+    const managed = iiiOpts.managed ?? mode === "local";
+    const version = iiiOpts.version ?? "latest";
+    const logLevel = iiiOpts.logLevel ?? "warn";
+    const consoleCfg = typeof iiiOpts.console === "object" ? iiiOpts.console : {};
+    installNventPyToSitePackages(pythonBin, readFileSync(PYTHON_NVENT_HELPER_SRC, "utf-8"));
+    if (hasNuxtModule("@nvent-addon/app")) {
+      const nventOpts = nuxt.options;
+      nventOpts.nventapp ??= {};
+      nventOpts.nventapp.route ??= opts.app?.enabled !== false;
+      if (opts.app?.routePath) nventOpts.nventapp.routePath ??= opts.app.routePath;
+      if (opts.app?.layout !== void 0) nventOpts.nventapp.layout ??= opts.app.layout;
+    }
+    const engineCfg = buildEngineConfig(iiiOpts);
+    const engineConfigYaml = generateIiiConfigYaml(engineCfg);
+    writeIiiConfig(join(nuxt.options.buildDir, "iii-config.yaml"), engineCfg);
+    const rc = nuxt.options.runtimeConfig;
+    rc.nvent = {
+      ...rc.nvent ?? {},
+      iii: {
+        wsUrl,
+        httpPort: engineCfg.httpPort,
+        httpHost: iiiOpts.httpHost ?? "localhost",
+        wsPort: engineCfg.wsPort,
+        streamPort: engineCfg.streamPort,
+        managed,
+        mode,
+        version,
+        modules: engineCfg.modules,
+        logLevel,
+        // YAML config embedded at build time so the production lifecycle plugin can
+        // write iii-config.yaml without needing confbox or rebuilding from options.
+        engineConfigYaml
+      },
+      python: {
+        runtimeContent: skipPython ? "" : readFileSync(PYTHON_RUNTIME_SRC, "utf-8"),
+        nventHelperContent: skipPython ? "" : readFileSync(PYTHON_NVENT_HELPER_SRC, "utf-8"),
+        skip: skipPython
+      },
+      console: {
+        enabled: !!iiiOpts.console,
+        version: consoleCfg.version ?? "",
+        port: consoleCfg.port ?? 3113,
+        host: consoleCfg.host ?? "localhost",
+        flow: consoleCfg.flow ?? true
+      }
+    };
     const layerInfos = nuxt.options._layers.map((l) => ({
       rootDir: l.config.rootDir,
-      serverDir: l.config?.serverDir || join(l.config.rootDir, "server")
+      serverDir: l.config?.serverDir ?? join(l.config.rootDir, "server")
     }));
-    const { worker, ...queueOptions } = config.queue;
-    const defaultConfigs = {
-      queue: queueOptions,
-      worker
-    };
-    const compiledRegistry = await compileRegistryFromServerWorkers(layerInfos, config.dir || "functions", defaultConfigs);
-    const compiledWithMeta = defu(compiledRegistry, {
-      version: 1,
-      compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
-      provider: { name: config.queue.adapter === "postgres" ? "pgboss" : "bullmq" },
-      logger: { name: "console", level: "info" },
-      runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
-      flows: {},
-      eventIndex: {},
-      config: {
-        flow: config.flow,
-        queue: config.queue
+    let lastScanned = await scanFunctions({ layerInfos, functionsDir });
+    let pythonPathRewrite;
+    if (!nuxt.options.dev && !skipPython && lastScanned.pythonFunctions.length > 0) {
+      pythonPathRewrite = /* @__PURE__ */ new Map();
+      for (const fn of lastScanned.pythonFunctions) {
+        for (const layer of layerInfos) {
+          const fnDir = join(layer.serverDir, functionsDir);
+          if (fn.absPath.startsWith(fnDir)) {
+            pythonPathRewrite.set(fn.absPath, relative(fnDir, fn.absPath));
+            break;
+          }
+        }
       }
-    });
-    const compiledSnapshot = JSON.parse(JSON.stringify(compiledWithMeta));
-    let lastCompiledRegistry = compiledSnapshot;
-    const REGISTRY_TEMPLATE = "function-registry.mjs";
-    const HANDLERS_TEMPLATE = "worker-handlers.mjs";
-    const ANALYZED_FLOWS_TEMPLATE = "analyzed-flows.mjs";
-    const TRIGGER_REGISTRY_TEMPLATE = "trigger-registry.mjs";
-    for (const templateName of [REGISTRY_TEMPLATE, HANDLERS_TEMPLATE, ANALYZED_FLOWS_TEMPLATE, TRIGGER_REGISTRY_TEMPLATE]) {
-      const templatePath = resolve(nuxt.options.buildDir, templateName);
-      nuxt.options.build.transpile.push(templatePath);
     }
     addTemplate({
-      filename: REGISTRY_TEMPLATE,
-      write: true,
-      getContents: () => generateRegistryTemplate(lastCompiledRegistry)
-    });
-    addTemplate({
-      filename: HANDLERS_TEMPLATE,
-      write: true,
-      getContents: () => generateHandlersTemplate(lastCompiledRegistry)
-    });
-    addTemplate({
-      filename: ANALYZED_FLOWS_TEMPLATE,
-      write: true,
-      getContents: () => generateAnalyzedFlowsTemplate(lastCompiledRegistry)
-    });
-    addTemplate({
-      filename: TRIGGER_REGISTRY_TEMPLATE,
+      filename: III_REGISTRY_TEMPLATE,
       write: true,
-      getContents: () => generateTriggerRegistryTemplate(lastCompiledRegistry)
+      getContents: () => generateIiiRegistryTemplate(lastScanned, pythonPathRewrite)
     });
-    addTypeTemplate({
-      filename: "types/nvent-adapters.d.ts",
-      getContents: () => generateAdapterTypesTemplate(resolve)
-    });
-    nuxt.options.alias["#nvent/adapters"] = resolve(nuxt.options.buildDir, "types/nvent-adapters");
-    addServerPlugin(resolve("./runtime/nitro/plugins/00.adapters"));
-    addServerPlugin(resolve("./runtime/nitro/plugins/01.ws-lifecycle"));
-    addServerPlugin(resolve("./runtime/nitro/plugins/02.workers"));
-    addServerPlugin(resolve("./runtime/nitro/plugins/03.triggers"));
-    addServerHandler({
-      route: "/api/_webhook/await/:flowName/:runId/:stepName",
-      handler: resolve("./runtime/nitro/routes/webhook.await")
-    });
-    addServerHandler({
-      route: "/api/_webhook/trigger/:triggerName",
-      handler: resolve("./runtime/nitro/routes/webhook.trigger")
-    });
-    addServerImports(getServerImports(resolve, nuxt.options.buildDir));
-    const refreshRegistry = async (reason, changedPath) => {
-      const functionsDir = config.dir || "functions";
-      const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, functionsDir, defaultConfigs);
-      lastCompiledRegistry = JSON.parse(JSON.stringify(defu(updatedRegistry, {
-        version: 1,
-        compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
-        provider: { name: config.queue.adapter === "postgres" ? "pgboss" : "bullmq" },
-        logger: { name: "console", level: "info" },
-        runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
-        flows: {},
-        eventIndex: {},
-        config: {
-          flow: config.flow,
-          queue: config.queue
-        }
-      })));
-      console.log(`[nvent] registry refreshed (${reason})`, changedPath || "");
-      console.log(`[nvent] new registry has ${lastCompiledRegistry.workers?.length || 0} workers`);
-      console.log(`[nvent] new registry compiled at: ${lastCompiledRegistry.compiledAt}`);
-      await updateTemplates({
-        filter: (template) => {
-          const match = template.filename === REGISTRY_TEMPLATE || template.filename === HANDLERS_TEMPLATE || template.filename === ANALYZED_FLOWS_TEMPLATE || template.filename === TRIGGER_REGISTRY_TEMPLATE;
-          if (match) {
-            console.log(`[nvent] updating template: ${template.filename}`);
-          }
-          return match;
-        }
-      });
-      console.log(`[nvent] templates updated`);
+    const registryTemplatePath = resolve(nuxt.options.buildDir, III_REGISTRY_TEMPLATE);
+    nuxt.options.alias["#nvent/iii-registry"] = registryTemplatePath;
+    nuxt.options.build.transpile.push(registryTemplatePath);
+    addServerPlugin(resolve("./runtime/nitro/plugins/00.iii-lifecycle"));
+    addServerPlugin(resolve("./runtime/nitro/plugins/01.iii-worker"));
+    const nitroOpts = nuxt.options.nitro ??= {};
+    nitroOpts.routeRules ??= {};
+    nitroOpts.routeRules["/functions/**"] = {
+      proxy: `http://${iiiOpts.httpHost ?? "localhost"}:${engineCfg.httpPort}/**`
     };
+    nitroOpts.experimental ??= {};
+    nitroOpts.experimental.websocket = true;
+    addServerHandler({ route: "/stream/**", handler: resolve("./runtime/nitro/routes/stream-proxy") });
+    addServerImports([
+      { from: resolve("./runtime/nitro/utils/useIii"), name: "useIii" },
+      { from: resolve("./runtime/nitro/utils/useIii"), name: "useIiiHealth" },
+      { from: resolve("./runtime/nitro/utils/useIii"), name: "getContext" },
+      { from: resolve("./runtime/nitro/utils/defineFunction"), name: "defineFunction" },
+      { from: resolve("./runtime/nitro/utils/defineFunction"), name: "FunctionContext" }
+    ]);
+    addImports([
+      { from: resolve("./runtime/app/composables/useFunctionCall"), name: "useFunctionCall" },
+      { from: resolve("./runtime/app/composables/useNventStream"), name: "useNventStream" }
+    ]);
     if (nuxt.options.dev) {
-      const functionsDir = config.dir || "functions";
-      watchQueueFiles({
-        nuxt,
-        layerInfos,
-        queuesDir: functionsDir,
-        onRefresh: refreshRegistry
-      });
+      const nventDir = join(nuxt.options.rootDir, "node_modules", ".nvent");
+      const binDir = join(nventDir, "bin");
+      if (managed && mode === "local") {
+        const binaryPath = await ensureIiiEngine({ binDir, version, logLevel });
+        const consoleBinaryPath = iiiOpts.console ? await ensureIiiConsole({ binDir, version: consoleCfg.version ?? version, logLevel }) : void 0;
+        const nventConfigPath = join(nventDir, "iii-config.yaml");
+        writeIiiConfig(nventConfigPath, engineCfg);
+        const engine = createEngineManager({
+          binaryPath,
+          configPath: nventConfigPath,
+          httpPort: engineCfg.httpPort,
+          wsPort: engineCfg.wsPort,
+          logLevel
+        });
+        await engine.start();
+        nuxt.hook("close", async () => {
+          await engine.stop();
+        });
+        if (consoleBinaryPath) {
+          const consoleManager = new ConsoleManager({
+            binaryPath: consoleBinaryPath,
+            port: consoleCfg.port ?? 3113,
+            enginePort: engineCfg.httpPort,
+            bridgePort: engineCfg.wsPort,
+            flow: consoleCfg.flow ?? true,
+            logLevel
+          });
+          await consoleManager.start();
+          nuxt.hook("close", async () => {
+            await consoleManager.stop();
+          });
+        }
+      }
+      if (!skipPython) {
+        const nventDir2 = join(nuxt.options.rootDir, "node_modules", ".nvent");
+        for (const reqPath of [
+          join(nuxt.options.rootDir, "requirements.txt"),
+          join(nuxt.options.rootDir, "server", "requirements.txt")
+        ]) {
+          await installPythonRequirements(reqPath, pythonBin, logLevel);
+        }
+        const workersDir = join(nventDir2, "workers");
+        const pythonOrchestrator = new PythonWorkersOrchestrator(
+          workersDir,
+          readFileSync(PYTHON_RUNTIME_SRC, "utf-8"),
+          readFileSync(PYTHON_NVENT_HELPER_SRC, "utf-8"),
+          wsUrl,
+          pythonBin,
+          logLevel
+        );
+        await pythonOrchestrator.start(lastScanned.pythonFunctions);
+        nuxt.hook("close", async () => {
+          await pythonOrchestrator.stop();
+        });
+        nuxt.__nventPythonOrchestrator = pythonOrchestrator;
+      }
+      const dirsToWatch = layerInfos.map(
+        (l) => join(l.serverDir ?? join(l.rootDir, "server"), functionsDir)
+      );
+      const refresh = debounce(async (changedPath) => {
+        lastScanned = await scanFunctions({ layerInfos, functionsDir });
+        await updateTemplates({ filter: (t) => t.filename === III_REGISTRY_TEMPLATE });
+        console.log(`[nvent] registry refreshed${changedPath ? ` (${changedPath})` : ""}`);
+        if (!skipPython && changedPath?.endsWith(".py")) {
+          const orchestrator = nuxt.__nventPythonOrchestrator;
+          await orchestrator?.onFileChanged(changedPath, lastScanned.pythonFunctions);
+        }
+      }, 200);
+      chokidar.watch(dirsToWatch, {
+        ignoreInitial: true,
+        ignored: ["**/node_modules/**", "**/.nuxt/**", "**/__pycache__/**", "**/*.pyc"],
+        awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 100 }
+      }).on("all", (_event, path) => refresh(path));
+    } else {
+      if (managed && mode === "local") {
+        const binDir = join(nuxt.options.rootDir, "node_modules", ".nvent", "bin");
+        const binaryPath = await ensureIiiEngine({ binDir, version, logLevel });
+        const consoleBinaryPath = iiiOpts.console ? await ensureIiiConsole({ binDir, version: consoleCfg.version ?? version, logLevel }) : void 0;
+        nuxt.hook("nitro:build:public-assets", async (nitro) => {
+          const outputNventDir = join(nitro.options.output.dir, "nvent");
+          const outputBinDir = join(outputNventDir, "bin");
+          mkdirSync(outputBinDir, { recursive: true });
+          copyFileSync(binaryPath, join(outputBinDir, basename(binaryPath)));
+          if (consoleBinaryPath) copyFileSync(consoleBinaryPath, join(outputBinDir, basename(consoleBinaryPath)));
+          writeFileSync(join(outputNventDir, "iii-config.yaml"), engineConfigYaml, "utf-8");
+          console.log("[nvent] Engine binaries + config copied to .output/nvent/");
+        });
+      }
+      if (!skipPython) {
+        nuxt.hook("nitro:build:public-assets", async (nitro) => {
+          const outputNventDir = join(nitro.options.output.dir, "nvent");
+          const workersDir = join(outputNventDir, "workers");
+          mkdirSync(workersDir, { recursive: true });
+          copyFileSync(PYTHON_RUNTIME_SRC, join(workersDir, "_runtime.py"));
+          copyFileSync(PYTHON_NVENT_HELPER_SRC, join(workersDir, "nvent.py"));
+          for (const fn of lastScanned.pythonFunctions) {
+            for (const layer of layerInfos) {
+              const fnDir = join(layer.serverDir, functionsDir);
+              if (fn.absPath.startsWith(fnDir)) {
+                const dest = join(outputNventDir, "functions", relative(fnDir, fn.absPath));
+                mkdirSync(join(dest, ".."), { recursive: true });
+                copyFileSync(fn.absPath, dest);
+                break;
+              }
+            }
+          }
+          console.log("[nvent] Python worker files copied to .output/nvent/");
+        });
+      }
     }
   }
 });