@walkeros/cli 2.1.1 → 2.2.0-next-1773136823705

package/dist/index.js

@@ -1,11 +1,5 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
-  get: (a2, b2) => (typeof require !== "undefined" ? require : a2)[b2]
-}) : x2)(function(x2) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x2 + '" is not supported');
-});
 var __esm = (fn2, res) => function __init() {
   return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
 };
@@ -54,6 +48,87 @@ var init_cli_logger = __esm({
   }
 });
 
+// src/core/timer.ts
+function createTimer() {
+  let startTime = 0;
+  let endTime = 0;
+  return {
+    start() {
+      startTime = Date.now();
+      endTime = 0;
+    },
+    end() {
+      endTime = Date.now();
+      return endTime - startTime;
+    },
+    getElapsed() {
+      const currentTime = endTime || Date.now();
+      return currentTime - startTime;
+    },
+    format() {
+      const elapsed = this.getElapsed();
+      return (elapsed / 1e3).toFixed(2) + "s";
+    }
+  };
+}
+var init_timer = __esm({
+  "src/core/timer.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/output.ts
+import fs from "fs-extra";
+import path from "path";
+async function writeResult(content, options) {
+  if (options.output) {
+    const outputPath = path.resolve(options.output);
+    await fs.ensureDir(path.dirname(outputPath));
+    await fs.writeFile(outputPath, content);
+  } else {
+    process.stdout.write(content);
+    process.stdout.write("\n");
+  }
+}
+function createJsonOutput(success, data, error, duration) {
+  return {
+    success,
+    ...data && { data },
+    ...error && { error },
+    ...duration && { duration }
+  };
+}
+function createSuccessOutput(data, duration) {
+  return createJsonOutput(true, data, void 0, duration);
+}
+function createErrorOutput(error, duration) {
+  return createJsonOutput(false, void 0, error, duration);
+}
+function formatBytes(bytes) {
+  return (bytes / 1024).toFixed(2);
+}
+var init_output = __esm({
+  "src/core/output.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/tmp.ts
+import os from "os";
+import path2 from "path";
+function getTmpPath(tmpDir, ...segments) {
+  const root = tmpDir || DEFAULT_TMP_ROOT;
+  const absoluteRoot = path2.isAbsolute(root) ? root : path2.resolve(root);
+  return path2.join(absoluteRoot, ...segments);
+}
+var DEFAULT_TMP_ROOT;
+var init_tmp = __esm({
+  "src/core/tmp.ts"() {
+    "use strict";
+    DEFAULT_TMP_ROOT = os.tmpdir();
+  }
+});
+
 // src/lib/config-file.ts
 import {
   readFileSync,
@@ -149,6 +224,9 @@ async function deployAuthenticatedFetch(url, init) {
     headers: { ...existingHeaders, Authorization: `Bearer ${token}` }
   });
 }
+function resolveRunToken() {
+  return resolveDeployToken() ?? resolveToken()?.token ?? null;
+}
 function resolveBaseUrl() {
   return resolveAppUrl();
 }
@@ -164,220 +242,10 @@ var init_auth = __esm({
   }
 });
 
-// src/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join2 } from "path";
-function findPackageJson() {
-  const paths = [
-    join2(versionDirname, "../package.json"),
-    // dist/ or src/
-    join2(versionDirname, "../../package.json")
-    // src/core/ (not used, but safe)
-  ];
-  for (const p2 of paths) {
-    try {
-      return readFileSync2(p2, "utf-8");
-    } catch {
-    }
-  }
-  return JSON.stringify({ version: "0.0.0" });
-}
-var versionFilename, versionDirname, VERSION;
-var init_version = __esm({
-  "src/version.ts"() {
-    "use strict";
-    versionFilename = fileURLToPath2(import.meta.url);
-    versionDirname = dirname2(versionFilename);
-    VERSION = JSON.parse(findPackageJson()).version;
-  }
-});
-
-// src/commands/run/heartbeat.ts
-var heartbeat_exports = {};
-__export(heartbeat_exports, {
-  startHeartbeat: () => startHeartbeat
-});
-import { randomUUID } from "crypto";
-async function startHeartbeat(options) {
-  const projectId = options.projectId ?? requireProjectId();
-  const base = resolveBaseUrl();
-  const instanceId2 = randomUUID();
-  const healthEndpoint = options.healthEndpoint ?? "/health";
-  const intervalSec = options.heartbeatInterval ?? 60;
-  const log = createCLILogger();
-  const startTime = Date.now();
-  const heartbeatUrl = `${base}/api/projects/${projectId}/deployments/${options.deployment}/heartbeat`;
-  const initResponse = await deployAuthenticatedFetch(heartbeatUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      url: options.url,
-      healthEndpoint,
-      instanceId: instanceId2,
-      cliVersion: VERSION
-    })
-  });
-  if (!initResponse.ok) {
-    const err = await initResponse.json().catch(() => ({}));
-    throw new Error(
-      err.error?.message || `Initial heartbeat failed (${initResponse.status})`
-    );
-  }
-  const initData = await initResponse.json();
-  log.info(
-    `Registered as ${instanceId2} on deployment ${options.deployment} (${initData.deploymentId})`
-  );
-  const heartbeatTimer = setInterval(async () => {
-    try {
-      const resp = await deployAuthenticatedFetch(heartbeatUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          instanceId: instanceId2,
-          uptime: Math.floor((Date.now() - startTime) / 1e3),
-          cliVersion: VERSION,
-          metadata: {
-            nodeVersion: process.version,
-            platform: process.platform
-          }
-        })
-      });
-      if (resp.ok) {
-        const data = await resp.json();
-        if (data.action === "update" && data.bundleUrl) {
-          log.info(
-            `Update available: version ${data.versionNumber}, downloading from ${data.bundleUrl}`
-          );
-        } else if (data.action === "stop") {
-          log.info("Received stop signal from server, shutting down...");
-          await cleanup();
-          process.exit(0);
-        }
-      }
-    } catch (err) {
-      log.error(
-        `Heartbeat failed: ${err instanceof Error ? err.message : "Unknown error"}`
-      );
-    }
-  }, intervalSec * 1e3);
-  const cleanup = async () => {
-    clearInterval(heartbeatTimer);
-    try {
-      await deployAuthenticatedFetch(heartbeatUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          instanceId: instanceId2,
-          uptime: Math.floor((Date.now() - startTime) / 1e3),
-          shutting_down: true
-        })
-      });
-    } catch {
-    }
-  };
-  process.on("SIGTERM", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-  process.on("SIGINT", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-  return { instanceId: instanceId2, deploymentId: initData.deploymentId, cleanup };
-}
-var init_heartbeat = __esm({
-  "src/commands/run/heartbeat.ts"() {
-    "use strict";
-    init_auth();
-    init_cli_logger();
-    init_version();
-  }
-});
-
-// src/commands/bundle/index.ts
-init_cli_logger();
-import path10 from "path";
-import fs10 from "fs-extra";
-import { getPlatform as getPlatform2 } from "@walkeros/core";
-
-// src/core/index.ts
-init_cli_logger();
-
-// src/core/timer.ts
-function createTimer() {
-  let startTime = 0;
-  let endTime = 0;
-  return {
-    start() {
-      startTime = Date.now();
-      endTime = 0;
-    },
-    end() {
-      endTime = Date.now();
-      return endTime - startTime;
-    },
-    getElapsed() {
-      const currentTime = endTime || Date.now();
-      return currentTime - startTime;
-    },
-    format() {
-      const elapsed = this.getElapsed();
-      return (elapsed / 1e3).toFixed(2) + "s";
-    }
-  };
-}
-
-// src/core/output.ts
-import fs from "fs-extra";
-import path from "path";
-async function writeResult(content, options) {
-  if (options.output) {
-    const outputPath = path.resolve(options.output);
-    await fs.ensureDir(path.dirname(outputPath));
-    await fs.writeFile(outputPath, content);
-  } else {
-    process.stdout.write(content);
-    process.stdout.write("\n");
-  }
-}
-function createJsonOutput(success, data, error, duration) {
-  return {
-    success,
-    ...data && { data },
-    ...error && { error },
-    ...duration && { duration }
-  };
-}
-function createSuccessOutput(data, duration) {
-  return createJsonOutput(true, data, void 0, duration);
-}
-function createErrorOutput(error, duration) {
-  return createJsonOutput(false, void 0, error, duration);
-}
-function formatBytes(bytes) {
-  return (bytes / 1024).toFixed(2);
-}
-
-// src/core/tmp.ts
-import os from "os";
-import path2 from "path";
-var DEFAULT_TMP_ROOT = os.tmpdir();
-function getTmpPath(tmpDir, ...segments) {
-  const root = tmpDir || DEFAULT_TMP_ROOT;
-  const absoluteRoot = path2.isAbsolute(root) ? root : path2.resolve(root);
-  return path2.join(absoluteRoot, ...segments);
-}
-
-// src/core/asset-resolver.ts
-import { fileURLToPath } from "url";
-import { existsSync as existsSync2 } from "fs";
-import path4 from "path";
-
 // src/config/utils.ts
+import crypto from "crypto";
 import fs2 from "fs-extra";
 import path3 from "path";
-init_auth();
 function isUrl(str) {
   try {
     const url = new URL(str);
@@ -400,7 +268,8 @@ async function downloadFromUrl(url) {
     const content = await response.text();
     const downloadsDir = getTmpPath(void 0, "downloads");
     await fs2.ensureDir(downloadsDir);
-    const tempPath = path3.join(downloadsDir, "flow.json");
+    const downloadId = crypto.randomUUID().slice(0, 8);
+    const tempPath = path3.join(downloadsDir, `flow-${downloadId}.json`);
     await fs2.writeFile(tempPath, content, "utf-8");
     return tempPath;
   } catch (error) {
@@ -491,9 +360,19 @@ async function loadJsonFromSource(source, options) {
     );
   }
 }
+var init_utils = __esm({
+  "src/config/utils.ts"() {
+    "use strict";
+    init_core();
+    init_tmp();
+    init_auth();
+  }
+});
 
 // src/core/asset-resolver.ts
-var cachedAssetDir;
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
 function getAssetDir() {
   if (cachedAssetDir) return cachedAssetDir;
   const currentFile = fileURLToPath(import.meta.url);
@@ -521,16 +400,28 @@ function resolveAsset(assetPath, assetType, baseDir) {
   }
   return path4.resolve(baseDir || process.cwd(), assetPath);
 }
+var cachedAssetDir;
+var init_asset_resolver = __esm({
+  "src/core/asset-resolver.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
 
 // src/core/utils.ts
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+var init_utils2 = __esm({
+  "src/core/utils.ts"() {
+    "use strict";
+  }
+});
 
 // src/core/local-packages.ts
 import path5 from "path";
 import fs3 from "fs-extra";
-async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
+async function resolveLocalPackage(packageName, localPath, configDir, logger) {
   const absolutePath = path5.isAbsolute(localPath) ? localPath : path5.resolve(configDir, localPath);
   if (!await fs3.pathExists(absolutePath)) {
     throw new Error(
@@ -546,7 +437,7 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
   const distPath = path5.join(absolutePath, "dist");
   const hasDistFolder = await fs3.pathExists(distPath);
   if (!hasDistFolder) {
-    logger2.warn(
+    logger.warn(
       `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
     );
   }
@@ -557,7 +448,7 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
     hasDistFolder
   };
 }
-async function copyLocalPackage(localPkg, targetDir, logger2) {
+async function copyLocalPackage(localPkg, targetDir, logger) {
   const packageDir = path5.join(targetDir, "node_modules", localPkg.name);
   await fs3.ensureDir(path5.dirname(packageDir));
   await fs3.copy(
@@ -577,13 +468,17 @@ async function copyLocalPackage(localPkg, targetDir, logger2) {
       }
     }
   }
-  logger2.info(`\u{1F4E6} Using local: ${localPkg.name} from ${localPkg.absolutePath}`);
+  logger.info(`\u{1F4E6} Using local: ${localPkg.name} from ${localPkg.absolutePath}`);
   return packageDir;
 }
+var init_local_packages = __esm({
+  "src/core/local-packages.ts"() {
+    "use strict";
+  }
+});
 
 // src/core/input-detector.ts
 import fs4 from "fs-extra";
-init_auth();
 async function detectInput(inputPath, platformOverride) {
   const content = await loadContent(inputPath);
   try {
@@ -608,6 +503,13 @@ async function loadContent(inputPath) {
   }
   return fs4.readFile(inputPath, "utf8");
 }
+var init_input_detector = __esm({
+  "src/core/input-detector.ts"() {
+    "use strict";
+    init_utils();
+    init_auth();
+  }
+});
 
 // src/core/stdin.ts
 function isStdinPiped() {
@@ -624,9 +526,11 @@ async function readStdin() {
   }
   return content;
 }
-
-// src/core/index.ts
-init_auth();
+var init_stdin = __esm({
+  "src/core/stdin.ts"() {
+    "use strict";
+  }
+});
 
 // src/core/sse.ts
 function parseSSEEvents(buffer) {
@@ -650,83 +554,115 @@ function parseSSEEvents(buffer) {
   }
   return { parsed: events, remainder };
 }
+var init_sse = __esm({
+  "src/core/sse.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/index.ts
+var init_core = __esm({
+  "src/core/index.ts"() {
+    "use strict";
+    init_cli_logger();
+    init_timer();
+    init_output();
+    init_tmp();
+    init_asset_resolver();
+    init_utils2();
+    init_local_packages();
+    init_input_detector();
+    init_stdin();
+  }
+});
 
 // src/config/validators.ts
 import { schemas } from "@walkeros/core/dev";
-var { safeParseSetup } = schemas;
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
 }
-function validateFlowSetup(data) {
-  const result = safeParseSetup(data);
+function validateFlowConfig(data) {
+  const result = safeParseConfig(data);
   if (!result.success) {
     const errors = result.error.issues.map((issue) => {
-      const path14 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-      return `  - ${path14}: ${issue.message}`;
+      const path15 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path15}: ${issue.message}`;
     }).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
   }
   return result.data;
 }
-function getAvailableFlows(setup) {
-  return Object.keys(setup.flows);
+function getAvailableFlows(config) {
+  return Object.keys(config.flows);
 }
+var safeParseConfig;
+var init_validators = __esm({
+  "src/config/validators.ts"() {
+    "use strict";
+    ({ safeParseConfig } = schemas);
+  }
+});
 
 // src/config/build-defaults.ts
-var WEB_BUILD_DEFAULTS = {
-  format: "iife",
-  platform: "browser",
-  target: "es2020",
-  minify: true,
-  sourcemap: false,
-  cache: true,
-  windowCollector: "collector",
-  windowElb: "elb"
-};
-var SERVER_BUILD_DEFAULTS = {
-  format: "esm",
-  platform: "node",
-  target: "node20",
-  minify: true,
-  sourcemap: false,
-  cache: true
-};
-var DEFAULT_OUTPUT_PATHS = {
-  web: "./dist/walker.js",
-  server: "./dist/bundle.mjs"
-};
 function getBuildDefaults(platform) {
   return platform === "web" ? WEB_BUILD_DEFAULTS : SERVER_BUILD_DEFAULTS;
 }
 function getDefaultOutput(platform) {
   return DEFAULT_OUTPUT_PATHS[platform];
 }
+var WEB_BUILD_DEFAULTS, SERVER_BUILD_DEFAULTS, DEFAULT_OUTPUT_PATHS;
+var init_build_defaults = __esm({
+  "src/config/build-defaults.ts"() {
+    "use strict";
+    WEB_BUILD_DEFAULTS = {
+      format: "iife",
+      platform: "browser",
+      target: "es2020",
+      minify: true,
+      sourcemap: false,
+      cache: true,
+      windowCollector: "collector",
+      windowElb: "elb"
+    };
+    SERVER_BUILD_DEFAULTS = {
+      format: "esm",
+      platform: "node",
+      target: "node20",
+      minify: true,
+      sourcemap: false,
+      cache: true
+    };
+    DEFAULT_OUTPUT_PATHS = {
+      web: "./dist/walker.js",
+      server: "./dist/bundle.mjs"
+    };
+  }
+});
 
 // src/config/loader.ts
 import path6 from "path";
 import fs5 from "fs-extra";
-import { getFlowConfig, getPlatform } from "@walkeros/core";
-var DEFAULT_INCLUDE_FOLDER = "./shared";
+import { getFlowSettings, getPlatform } from "@walkeros/core";
 function loadBundleConfig(rawConfig, options) {
-  const setup = validateFlowSetup(rawConfig);
-  const availableFlows = getAvailableFlows(setup);
-  const flowName = resolveFlow(setup, options.flowName, availableFlows);
-  let flowConfig = getFlowConfig(setup, flowName, { deferred: true });
-  const platform = getPlatform(flowConfig);
+  const config = validateFlowConfig(rawConfig);
+  const availableFlows = getAvailableFlows(config);
+  const flowName = resolveFlow(config, options.flowName, availableFlows);
+  let flowSettings = getFlowSettings(config, flowName, { deferred: true });
+  const platform = getPlatform(flowSettings);
   if (!platform) {
     throw new Error(
       `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
     );
   }
   if (platform === "web") {
-    flowConfig = getFlowConfig(setup, flowName);
+    flowSettings = getFlowSettings(config, flowName);
   }
   const buildDefaults = getBuildDefaults(platform);
-  const packages = flowConfig.packages || {};
+  const packages = flowSettings.packages || {};
   const output = options.buildOverrides?.output || getDefaultOutput(platform);
   const configDir = isUrl(options.configPath) ? process.cwd() : path6.dirname(options.configPath);
-  let includes = setup.include;
+  let includes = config.include;
   if (!includes) {
     const defaultIncludePath = path6.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
     if (fs5.pathExistsSync(defaultIncludePath)) {
@@ -748,14 +684,14 @@ function loadBundleConfig(rawConfig, options) {
     );
   }
   return {
-    flowConfig,
+    flowSettings,
     buildOptions,
     flowName,
     isMultiFlow,
     availableFlows
   };
 }
-function resolveFlow(setup, requestedFlow, available) {
+function resolveFlow(config, requestedFlow, available) {
   if (available.length === 1) {
     return available[0];
   }
@@ -774,8 +710,8 @@ Available flows: ${available.join(", ")}`
   return requestedFlow;
 }
 function loadAllFlows(rawConfig, options) {
-  const setup = validateFlowSetup(rawConfig);
-  const flows = getAvailableFlows(setup);
+  const config = validateFlowConfig(rawConfig);
+  const flows = getAvailableFlows(config);
   if (options.logger) {
     options.logger.info(
       `\u{1F4E6} Loading all ${flows.length} flows: ${flows.join(", ")}`
@@ -792,21 +728,29 @@ async function loadFlowConfig(configPath, options) {
   const rawConfig = await loadJsonConfig(configPath);
   return loadBundleConfig(rawConfig, { configPath, ...options });
 }
+var DEFAULT_INCLUDE_FOLDER;
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    init_validators();
+    init_build_defaults();
+    init_utils();
+    DEFAULT_INCLUDE_FOLDER = "./shared";
+  }
+});
 
-// src/commands/bundle/bundler.ts
-import esbuild from "esbuild";
-import path9 from "path";
-import fs8 from "fs-extra";
-import { packageNameToVariable, ENV_MARKER_PREFIX } from "@walkeros/core";
-
-// src/commands/bundle/package-manager.ts
-import pacote from "pacote";
-import path7 from "path";
-import fs6 from "fs-extra";
+// src/config/index.ts
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_validators();
+    init_utils();
+    init_loader();
+  }
+});
 
 // src/core/cache-utils.ts
 import { getHashServer } from "@walkeros/server-core";
-var HASH_LENGTH = 12;
 function isMutableVersion(version) {
   return version === "latest" || version.includes("^") || version.includes("~") || version.includes("*") || version.includes("x");
 }
@@ -827,15 +771,25 @@ function normalizeJson(content) {
   const parsed = JSON.parse(content);
   return JSON.stringify(parsed);
 }
-async function getFlowConfigCacheKey(content, date) {
+async function getFlowSettingsCacheKey(content, date) {
   const dateStr = date ?? getTodayDate();
   const normalized = normalizeJson(content);
   const input = `${normalized}:${dateStr}`;
   return getHashServer(input, HASH_LENGTH);
 }
+var HASH_LENGTH;
+var init_cache_utils = __esm({
+  "src/core/cache-utils.ts"() {
+    "use strict";
+    HASH_LENGTH = 12;
+  }
+});
 
 // src/commands/bundle/package-manager.ts
-var PACKAGE_DOWNLOAD_TIMEOUT_MS = 6e4;
+import pacote from "pacote";
+import path7 from "path";
+import fs6 from "fs-extra";
+import semver from "semver";
 async function withTimeout(promise, ms, errorMessage) {
   let timer;
   const timeout = new Promise((_2, reject) => {
@@ -847,132 +801,199 @@ async function withTimeout(promise, ms, errorMessage) {
     clearTimeout(timer);
   }
 }
-function getPackageDirectory(baseDir, packageName, version) {
+function getPackageDirectory(baseDir, packageName) {
   return path7.join(baseDir, "node_modules", packageName);
 }
-async function getCachedPackagePath(pkg, tmpDir) {
-  const cacheDir = getTmpPath(tmpDir, "cache", "packages");
-  const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
-  return path7.join(cacheDir, cacheKey);
-}
-async function isPackageCached(pkg, tmpDir) {
-  const cachedPath = await getCachedPackagePath(pkg, tmpDir);
-  return fs6.pathExists(cachedPath);
-}
-function validateNoDuplicatePackages(packages) {
-  const packageMap = /* @__PURE__ */ new Map();
-  for (const pkg of packages) {
-    if (!packageMap.has(pkg.name)) {
-      packageMap.set(pkg.name, []);
+async function collectAllSpecs(packages, logger, configDir) {
+  const allSpecs = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = packages.map((pkg) => ({
+    name: pkg.name,
+    spec: pkg.version,
+    source: "direct",
+    from: "flow.json",
+    optional: false,
+    localPath: pkg.path
+  }));
+  while (queue.length > 0) {
+    const item = queue.shift();
+    const visitKey = `${item.name}@${item.spec}`;
+    if (visited.has(visitKey)) continue;
+    visited.add(visitKey);
+    if (!allSpecs.has(item.name)) allSpecs.set(item.name, []);
+    allSpecs.get(item.name).push({
+      spec: item.spec,
+      source: item.source,
+      from: item.from,
+      optional: item.optional,
+      localPath: item.localPath
+    });
+    if (item.localPath) continue;
+    let manifest;
+    try {
+      manifest = await withTimeout(
+        pacote.manifest(`${item.name}@${item.spec}`, PACOTE_OPTS),
+        PACKAGE_DOWNLOAD_TIMEOUT_MS,
+        `Manifest fetch timed out: ${item.name}@${item.spec}`
+      );
+    } catch (error) {
+      logger.debug(
+        `Failed to fetch manifest for ${item.name}@${item.spec}: ${error}`
+      );
+      continue;
     }
-    packageMap.get(pkg.name).push(pkg.version);
-  }
-  const conflicts = [];
-  for (const [name, versions] of packageMap.entries()) {
-    const uniqueVersions = [...new Set(versions)];
-    if (uniqueVersions.length > 1) {
-      conflicts.push(`${name}: [${uniqueVersions.join(", ")}]`);
+    const m2 = manifest;
+    const deps = m2.dependencies || {};
+    for (const [depName, depSpec] of Object.entries(deps)) {
+      if (typeof depSpec === "string") {
+        queue.push({
+          name: depName,
+          spec: depSpec,
+          source: "dependency",
+          from: item.name,
+          optional: false
+        });
+      }
+    }
+    const peerDeps = m2.peerDependencies || {};
+    const peerMeta = m2.peerDependenciesMeta || {};
+    for (const [depName, depSpec] of Object.entries(peerDeps)) {
+      if (typeof depSpec === "string") {
+        const isOptional = peerMeta[depName]?.optional === true;
+        queue.push({
+          name: depName,
+          spec: depSpec,
+          source: "peerDependency",
+          from: item.name,
+          optional: isOptional
+        });
+      }
     }
   }
-  if (conflicts.length > 0) {
-    throw new Error(
-      `Version conflicts detected:
-${conflicts.map((c2) => `  - ${c2}`).join("\n")}
-
-Each package must use the same version across all declarations. Please update your configuration to use consistent versions.`
-    );
-  }
+  return allSpecs;
 }
-async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PURE__ */ new Set()) {
-  const dependencies = [];
-  const pkgKey = `${pkg.name}@${pkg.version}`;
-  if (visited.has(pkgKey)) {
-    return dependencies;
-  }
-  visited.add(pkgKey);
-  try {
-    const packageJsonPath = path7.join(packageDir, "package.json");
-    if (await fs6.pathExists(packageJsonPath)) {
-      const packageJson = await fs6.readJson(packageJsonPath);
-      const deps = {
-        ...packageJson.dependencies,
-        ...packageJson.peerDependencies
-      };
-      for (const [name, versionSpec] of Object.entries(deps)) {
-        if (typeof versionSpec === "string") {
-          dependencies.push({ name, version: versionSpec });
+function resolveVersionConflicts(allSpecs, logger) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [name, specs] of allSpecs) {
+    const localSpec = specs.find((s2) => s2.localPath);
+    if (localSpec) {
+      resolved.set(name, {
+        name,
+        version: "local",
+        localPath: localSpec.localPath
+      });
+      continue;
+    }
+    const nonPeerSpecs = specs.filter((s2) => s2.source !== "peerDependency");
+    const peerSpecs = specs.filter((s2) => s2.source === "peerDependency");
+    let activeSpecs;
+    if (nonPeerSpecs.length > 0) {
+      activeSpecs = nonPeerSpecs;
+    } else {
+      const requiredPeers = peerSpecs.filter((s2) => !s2.optional);
+      if (requiredPeers.length === 0) {
+        logger.debug(`Skipping optional peer dependency: ${name}`);
+        continue;
+      }
+      activeSpecs = requiredPeers;
+    }
+    activeSpecs.sort(
+      (a2, b2) => SOURCE_PRIORITY[a2.source] - SOURCE_PRIORITY[b2.source]
+    );
+    const directSpecs = activeSpecs.filter((s2) => s2.source === "direct");
+    const directExact = directSpecs.find((s2) => semver.valid(s2.spec) !== null);
+    let chosenVersion;
+    if (directExact) {
+      chosenVersion = directExact.spec;
+    } else if (directSpecs.length > 0) {
+      chosenVersion = directSpecs[0].spec;
+    } else {
+      const exactVersions = activeSpecs.filter((s2) => semver.valid(s2.spec) !== null).map((s2) => s2.spec);
+      const uniqueExact = [...new Set(exactVersions)];
+      if (uniqueExact.length > 1) {
+        throw new Error(
+          `Version conflict for ${name}: ${uniqueExact.join(" vs ")} (from ${activeSpecs.map((s2) => `${s2.spec} via ${s2.from}`).join(", ")})`
+        );
+      } else if (uniqueExact.length === 1) {
+        chosenVersion = uniqueExact[0];
+      } else {
+        chosenVersion = activeSpecs[0].spec;
+      }
+    }
+    if (semver.valid(chosenVersion)) {
+      for (const spec of specs) {
+        if (spec.localPath) continue;
+        if (semver.valid(spec.spec)) {
+          if (spec.spec !== chosenVersion) {
+            if (spec.source === "peerDependency") {
+              logger.warn(
+                `${name}@${chosenVersion} differs from peer constraint ${spec.spec} (from ${spec.from})`
+              );
+            }
+          }
+        } else {
+          if (!semver.satisfies(chosenVersion, spec.spec, {
+            includePrerelease: true
+          })) {
+            if (spec.source === "peerDependency") {
+              logger.warn(
+                `${name}@${chosenVersion} may not satisfy peer constraint ${spec.spec} (from ${spec.from})`
+              );
+            } else {
+              throw new Error(
+                `Version conflict: ${name}@${chosenVersion} does not satisfy ${spec.spec} required by ${spec.from}`
+              );
+            }
+          }
         }
       }
     }
-  } catch (error) {
-    logger2.debug(`Failed to read dependencies for ${pkgKey}: ${error}`);
+    resolved.set(name, { name, version: chosenVersion });
   }
-  return dependencies;
+  return resolved;
 }
-async function downloadPackages(packages, targetDir, logger2, useCache = true, configDir, tmpDir) {
+async function downloadPackages(packages, targetDir, logger, useCache = true, configDir, tmpDir) {
   const packagePaths = /* @__PURE__ */ new Map();
-  const downloadQueue = [...packages];
-  const processed = /* @__PURE__ */ new Set();
   const userSpecifiedPackages = new Set(packages.map((p2) => p2.name));
+  validateNoDuplicatePackages(packages);
+  logger.debug("Resolving dependencies");
+  const allSpecs = await collectAllSpecs(packages, logger, configDir);
+  const resolved = resolveVersionConflicts(allSpecs, logger);
+  await fs6.ensureDir(targetDir);
   const localPackageMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
-    if (pkg.path) {
-      localPackageMap.set(pkg.name, pkg.path);
-    }
+    if (pkg.path) localPackageMap.set(pkg.name, pkg.path);
   }
-  validateNoDuplicatePackages(packages);
-  await fs6.ensureDir(targetDir);
-  while (downloadQueue.length > 0) {
-    const pkg = downloadQueue.shift();
-    const pkgKey = `${pkg.name}@${pkg.version}`;
-    if (processed.has(pkgKey)) {
-      continue;
-    }
-    processed.add(pkgKey);
-    if (!pkg.path && localPackageMap.has(pkg.name)) {
-      pkg.path = localPackageMap.get(pkg.name);
-    }
-    if (pkg.path) {
+  for (const [name, pkg] of resolved) {
+    if (pkg.localPath || localPackageMap.has(name)) {
+      const localPath = pkg.localPath || localPackageMap.get(name);
       const localPkg = await resolveLocalPackage(
-        pkg.name,
-        pkg.path,
+        name,
+        localPath,
         configDir || process.cwd(),
-        logger2
+        logger
       );
-      const installedPath = await copyLocalPackage(localPkg, targetDir, logger2);
-      packagePaths.set(pkg.name, installedPath);
-      const deps = await resolveDependencies(pkg, installedPath, logger2);
-      for (const dep of deps) {
-        const depKey = `${dep.name}@${dep.version}`;
-        if (!processed.has(depKey)) {
-          downloadQueue.push(dep);
-        }
-      }
+      const installedPath = await copyLocalPackage(localPkg, targetDir, logger);
+      packagePaths.set(name, installedPath);
       continue;
     }
-    const packageSpec = `${pkg.name}@${pkg.version}`;
-    const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
-    const cachedPath = await getCachedPackagePath(pkg, tmpDir);
-    if (useCache && await isPackageCached(pkg, tmpDir)) {
-      if (userSpecifiedPackages.has(pkg.name)) {
-        logger2.debug(`Downloading ${packageSpec} (cached)`);
+    const packageSpec = `${name}@${pkg.version}`;
+    const packageDir = getPackageDirectory(targetDir, name);
+    const cachedPath = await getCachedPackagePath(
+      { name, version: pkg.version },
+      tmpDir
+    );
+    if (useCache && await isPackageCached({ name, version: pkg.version }, tmpDir)) {
+      if (userSpecifiedPackages.has(name)) {
+        logger.debug(`Downloading ${packageSpec} (cached)`);
       }
       try {
         await fs6.ensureDir(path7.dirname(packageDir));
         await fs6.copy(cachedPath, packageDir);
-        packagePaths.set(pkg.name, packageDir);
-        const deps = await resolveDependencies(pkg, packageDir, logger2);
-        for (const dep of deps) {
-          const depKey = `${dep.name}@${dep.version}`;
-          if (!processed.has(depKey)) {
-            downloadQueue.push(dep);
-          }
-        }
+        packagePaths.set(name, packageDir);
         continue;
-      } catch (error) {
-        logger2.debug(
-          `Failed to use cache for ${packageSpec}, downloading fresh: ${error}`
-        );
+      } catch {
+        logger.debug(`Cache miss for ${packageSpec}, downloading fresh`);
       }
     }
     try {
@@ -980,52 +1001,87 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
       const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
       await withTimeout(
         pacote.extract(packageSpec, packageDir, {
-          // Force npm registry download, prevent workspace resolution
-          registry: "https://registry.npmjs.org",
-          // Force online fetching from registry (don't use cached workspace packages)
-          preferOnline: true,
-          // Cache for performance
-          cache: cacheDir,
-          // Don't resolve relative to workspace context
-          where: void 0
+          ...PACOTE_OPTS,
+          cache: cacheDir
         }),
         PACKAGE_DOWNLOAD_TIMEOUT_MS,
         `Package download timed out after ${PACKAGE_DOWNLOAD_TIMEOUT_MS / 1e3}s: ${packageSpec}`
       );
-      if (userSpecifiedPackages.has(pkg.name)) {
-        const pkgStats = await fs6.stat(path7.join(packageDir, "package.json"));
-        const pkgJsonSize = pkgStats.size;
-        const sizeKB = (pkgJsonSize / 1024).toFixed(1);
-        logger2.debug(`Downloading ${packageSpec} (${sizeKB} KB)`);
+      if (userSpecifiedPackages.has(name)) {
+        logger.debug(`Downloading ${packageSpec}`);
       }
       if (useCache) {
         try {
           await fs6.ensureDir(path7.dirname(cachedPath));
           await fs6.copy(packageDir, cachedPath);
-        } catch (cacheError) {
-        }
-      }
-      packagePaths.set(pkg.name, packageDir);
-      const deps = await resolveDependencies(pkg, packageDir, logger2);
-      for (const dep of deps) {
-        const depKey = `${dep.name}@${dep.version}`;
-        if (!processed.has(depKey)) {
-          downloadQueue.push(dep);
+        } catch {
         }
       }
+      packagePaths.set(name, packageDir);
     } catch (error) {
       throw new Error(`Failed to download ${packageSpec}: ${error}`);
     }
   }
   return packagePaths;
 }
+async function getCachedPackagePath(pkg, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "packages");
+  const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
+  return path7.join(cacheDir, cacheKey);
+}
+async function isPackageCached(pkg, tmpDir) {
+  const cachedPath = await getCachedPackagePath(pkg, tmpDir);
+  return fs6.pathExists(cachedPath);
+}
+function validateNoDuplicatePackages(packages) {
+  const packageMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (!packageMap.has(pkg.name)) packageMap.set(pkg.name, []);
+    packageMap.get(pkg.name).push(pkg.version);
+  }
+  const conflicts = [];
+  for (const [name, versions] of packageMap.entries()) {
+    const uniqueVersions = [...new Set(versions)];
+    if (uniqueVersions.length > 1) {
+      conflicts.push(`${name}: [${uniqueVersions.join(", ")}]`);
+    }
+  }
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Version conflicts detected:
+${conflicts.map((c2) => `  - ${c2}`).join("\n")}
+
+Each package must use the same version across all declarations. Please update your configuration to use consistent versions.`
+    );
+  }
+}
+var PACKAGE_DOWNLOAD_TIMEOUT_MS, PACOTE_OPTS, SOURCE_PRIORITY;
+var init_package_manager = __esm({
+  "src/commands/bundle/package-manager.ts"() {
+    "use strict";
+    init_core();
+    init_cache_utils();
+    init_tmp();
+    PACKAGE_DOWNLOAD_TIMEOUT_MS = 6e4;
+    PACOTE_OPTS = {
+      registry: "https://registry.npmjs.org",
+      preferOnline: true,
+      where: void 0
+    };
+    SOURCE_PRIORITY = {
+      direct: 0,
+      dependency: 1,
+      peerDependency: 2
+    };
+  }
+});
 
 // src/core/build-cache.ts
 import fs7 from "fs-extra";
 import path8 from "path";
 async function getBuildCachePath(configContent, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "builds");
-  const cacheKey = await getFlowConfigCacheKey(configContent);
+  const cacheKey = await getFlowSettingsCacheKey(configContent);
   return path8.join(cacheDir, `${cacheKey}.js`);
 }
 async function isBuildCached(configContent, tmpDir) {
@@ -1044,8 +1100,20 @@ async function getCachedBuild(configContent, tmpDir) {
   }
   return null;
 }
+var init_build_cache = __esm({
+  "src/core/build-cache.ts"() {
+    "use strict";
+    init_cache_utils();
+    init_tmp();
+  }
+});
 
 // src/commands/bundle/bundler.ts
+import crypto2 from "crypto";
+import esbuild from "esbuild";
+import path9 from "path";
+import fs8 from "fs-extra";
+import { packageNameToVariable, ENV_MARKER_PREFIX } from "@walkeros/core";
 function isInlineCode(code) {
   return code !== null && typeof code === "object" && !Array.isArray(code) && "push" in code;
 }
@@ -1091,22 +1159,29 @@ function generateInlineCode(inline, config, env, chain, chainPropertyName, isDes
       ${chainLine.slice(0, -1)}` : ""}
     }`;
 }
-async function copyIncludes(includes, sourceDir, outputDir, logger2) {
+async function copyIncludes(includes, sourceDir, outputDir, logger) {
   for (const include of includes) {
     const sourcePath = path9.resolve(sourceDir, include);
     const folderName = path9.basename(include);
     const destPath = path9.join(outputDir, folderName);
+    const resolvedOutput = path9.resolve(outputDir);
+    const resolvedSource = path9.resolve(sourcePath);
+    if (resolvedSource === resolvedOutput || resolvedOutput.startsWith(resolvedSource + path9.sep) || resolvedSource.startsWith(resolvedOutput + path9.sep)) {
+      throw new Error(
+        `Circular include detected: "${include}" resolves to "${resolvedSource}" which overlaps with output directory "${resolvedOutput}"`
+      );
+    }
     if (await fs8.pathExists(sourcePath)) {
       await fs8.copy(sourcePath, destPath);
-      logger2.debug(`Copied ${include} to output`);
+      logger.debug(`Copied ${include} to output`);
     } else {
-      logger2.debug(`Include folder not found: ${include}`);
+      logger.warn(`Include folder not found: ${include}`);
     }
   }
 }
-function generateCacheKeyContent(flowConfig, buildOptions) {
+function generateCacheKeyContent(flowSettings, buildOptions) {
   const configForCache = {
-    flow: flowConfig,
+    flow: flowSettings,
     build: {
       ...buildOptions,
       // Exclude non-deterministic fields from cache key
@@ -1116,62 +1191,64 @@ function generateCacheKeyContent(flowConfig, buildOptions) {
   };
   return JSON.stringify(configForCache);
 }
-function validateFlowConfig(flowConfig, logger2) {
+function validateFlowConfig2(flowSettings, logger) {
   let hasDeprecatedCodeTrue = false;
-  const sources = flowConfig.sources || {};
+  const sources = flowSettings.sources || {};
   for (const [sourceId, source] of Object.entries(sources)) {
     if (source && typeof source === "object" && source.code === true) {
-      logger2.warn(
+      logger.warn(
         `DEPRECATED: Source "${sourceId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a source package instead.`
       );
       hasDeprecatedCodeTrue = true;
     }
   }
-  const destinations = flowConfig.destinations || {};
+  const destinations = flowSettings.destinations || {};
   for (const [destId, dest] of Object.entries(destinations)) {
     if (dest && typeof dest === "object" && dest.code === true) {
-      logger2.warn(
+      logger.warn(
         `DEPRECATED: Destination "${destId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a destination package instead.`
       );
       hasDeprecatedCodeTrue = true;
     }
   }
-  const transformers = flowConfig.transformers || {};
+  const transformers = flowSettings.transformers || {};
   for (const [transformerId, transformer] of Object.entries(transformers)) {
     if (transformer && typeof transformer === "object" && transformer.code === true) {
-      logger2.warn(
+      logger.warn(
         `DEPRECATED: Transformer "${transformerId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a transformer package instead.`
       );
       hasDeprecatedCodeTrue = true;
     }
   }
   if (hasDeprecatedCodeTrue) {
-    logger2.warn(
+    logger.warn(
       `See https://www.elbwalker.com/docs/walkeros/getting-started/flow for migration guide.`
     );
   }
   return hasDeprecatedCodeTrue;
 }
-async function bundleCore(flowConfig, buildOptions, logger2, showStats = false) {
+async function bundleCore(flowSettings, buildOptions, logger, showStats = false) {
   const bundleStartTime = Date.now();
-  const hasDeprecatedFeatures = validateFlowConfig(flowConfig, logger2);
+  const hasDeprecatedFeatures = validateFlowConfig2(flowSettings, logger);
   if (hasDeprecatedFeatures) {
-    logger2.warn("Skipping deprecated code: true entries from bundle.");
+    logger.warn("Skipping deprecated code: true entries from bundle.");
   }
-  const TEMP_DIR = buildOptions.tempDir || getTmpPath();
+  const buildId = crypto2.randomUUID();
+  const TEMP_DIR = buildOptions.tempDir || getTmpPath(void 0, `walkeros-build-${buildId}`);
+  const CACHE_DIR = buildOptions.tempDir || getTmpPath();
   if (buildOptions.cache !== false) {
-    const configContent = generateCacheKeyContent(flowConfig, buildOptions);
-    const cached = await isBuildCached(configContent, TEMP_DIR);
+    const configContent = generateCacheKeyContent(flowSettings, buildOptions);
+    const cached = await isBuildCached(configContent, CACHE_DIR);
     if (cached) {
-      const cachedBuild = await getCachedBuild(configContent, TEMP_DIR);
+      const cachedBuild = await getCachedBuild(configContent, CACHE_DIR);
       if (cachedBuild) {
-        logger2.debug("Using cached build");
+        logger.debug("Using cached build");
         const outputPath = path9.resolve(buildOptions.output);
         await fs8.ensureDir(path9.dirname(outputPath));
         await fs8.writeFile(outputPath, cachedBuild);
         const stats = await fs8.stat(outputPath);
         const sizeKB = (stats.size / 1024).toFixed(1);
-        logger2.info(`Output: ${outputPath} (${sizeKB} KB, cached)`);
+        logger.info(`Output: ${outputPath} (${sizeKB} KB, cached)`);
         if (showStats) {
           const stats2 = await fs8.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
@@ -1198,14 +1275,14 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
   try {
     await fs8.ensureDir(TEMP_DIR);
     const hasSourcesOrDests = Object.keys(
-      flowConfig.sources || {}
+      flowSettings.sources || {}
     ).length > 0 || Object.keys(
-      flowConfig.destinations || {}
+      flowSettings.destinations || {}
     ).length > 0;
     if (hasSourcesOrDests && !buildOptions.packages["@walkeros/collector"]) {
       buildOptions.packages["@walkeros/collector"] = {};
     }
-    logger2.debug("Downloading packages");
+    logger.debug("Downloading packages");
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
         name,
@@ -1217,11 +1294,11 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     const packagePaths = await downloadPackages(
       packagesArray,
       TEMP_DIR,
-      logger2,
+      logger,
       buildOptions.cache,
       buildOptions.configDir,
       // For resolving relative local paths
-      TEMP_DIR
+      CACHE_DIR
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
@@ -1243,15 +1320,15 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
-    logger2.debug("Creating entry point");
+    logger.debug("Creating entry point");
     const entryContent = await createEntryPoint(
-      flowConfig,
+      flowSettings,
       buildOptions,
       packagePaths
     );
     const entryPath = path9.join(TEMP_DIR, "entry.js");
     await fs8.writeFile(entryPath, entryContent);
-    logger2.debug(
+    logger.debug(
       `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
     );
     const outputPath = path9.resolve(buildOptions.output);
@@ -1262,7 +1339,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       outputPath,
       TEMP_DIR,
       packagePaths,
-      logger2
+      logger
     );
     try {
       await esbuild.build(esbuildOptions);
@@ -1277,12 +1354,12 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     const outputStats = await fs8.stat(outputPath);
     const sizeKB = (outputStats.size / 1024).toFixed(1);
     const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
-    logger2.info(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
+    logger.info(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
     if (buildOptions.cache !== false) {
-      const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+      const configContent = generateCacheKeyContent(flowSettings, buildOptions);
       const buildOutput = await fs8.readFile(outputPath, "utf-8");
-      await cacheBuild(configContent, buildOutput, TEMP_DIR);
-      logger2.debug("Build cached for future use");
+      await cacheBuild(configContent, buildOutput, CACHE_DIR);
+      logger.debug("Build cached for future use");
     }
     let stats;
     if (showStats) {
@@ -1299,12 +1376,17 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
         buildOptions.include,
         buildOptions.configDir || process.cwd(),
         outputDir,
-        logger2
+        logger
       );
     }
     return stats;
   } catch (error) {
     throw error;
+  } finally {
+    if (!buildOptions.tempDir) {
+      fs8.remove(TEMP_DIR).catch(() => {
+      });
+    }
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
@@ -1334,7 +1416,7 @@ async function collectBundleStats(outputPath, packages, startTime, entryContent)
     treeshakingEffective
   };
 }
-function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger2) {
+function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger) {
   const alias = {};
   const baseOptions = {
     entryPoints: [entryPath],
@@ -1402,9 +1484,9 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
   }
   return baseOptions;
 }
-function detectDestinationPackages(flowConfig) {
+function detectDestinationPackages(flowSettings) {
   const destinationPackages = /* @__PURE__ */ new Set();
-  const destinations = flowConfig.destinations;
+  const destinations = flowSettings.destinations;
   if (destinations) {
     for (const [destKey, destConfig] of Object.entries(destinations)) {
       if (typeof destConfig === "object" && destConfig !== null && "code" in destConfig && destConfig.code === true) {
@@ -1417,9 +1499,9 @@ function detectDestinationPackages(flowConfig) {
   }
   return destinationPackages;
 }
-function detectSourcePackages(flowConfig) {
+function detectSourcePackages(flowSettings) {
   const sourcePackages = /* @__PURE__ */ new Set();
-  const sources = flowConfig.sources;
+  const sources = flowSettings.sources;
   if (sources) {
     for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
       if (typeof sourceConfig === "object" && sourceConfig !== null && "code" in sourceConfig && sourceConfig.code === true) {
@@ -1432,9 +1514,9 @@ function detectSourcePackages(flowConfig) {
   }
   return sourcePackages;
 }
-function detectTransformerPackages(flowConfig) {
+function detectTransformerPackages(flowSettings) {
   const transformerPackages = /* @__PURE__ */ new Set();
-  const transformers = flowConfig.transformers;
+  const transformers = flowSettings.transformers;
   if (transformers) {
     for (const [transformerKey, transformerConfig] of Object.entries(
       transformers
@@ -1449,9 +1531,21 @@ function detectTransformerPackages(flowConfig) {
   }
   return transformerPackages;
 }
-function detectExplicitCodeImports(flowConfig) {
+function detectStorePackages(flowSettings) {
+  const storePackages = /* @__PURE__ */ new Set();
+  const stores = flowSettings.stores;
+  if (stores) {
+    for (const [, storeConfig] of Object.entries(stores)) {
+      if (typeof storeConfig === "object" && storeConfig !== null && "package" in storeConfig && typeof storeConfig.package === "string") {
+        storePackages.add(storeConfig.package);
+      }
+    }
+  }
+  return storePackages;
+}
+function detectExplicitCodeImports(flowSettings) {
   const explicitCodeImports = /* @__PURE__ */ new Map();
-  const destinations = flowConfig.destinations;
+  const destinations = flowSettings.destinations;
   if (destinations) {
     for (const [destKey, destConfig] of Object.entries(destinations)) {
       if (typeof destConfig === "object" && destConfig !== null && "code" in destConfig && destConfig.code === true) {
@@ -1468,7 +1562,7 @@ function detectExplicitCodeImports(flowConfig) {
       }
     }
   }
-  const sources = flowConfig.sources;
+  const sources = flowSettings.sources;
   if (sources) {
     for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
       if (typeof sourceConfig === "object" && sourceConfig !== null && "code" in sourceConfig && sourceConfig.code === true) {
@@ -1485,7 +1579,7 @@ function detectExplicitCodeImports(flowConfig) {
       }
     }
   }
-  const transformers = flowConfig.transformers;
+  const transformers = flowSettings.transformers;
   if (transformers) {
     for (const [transformerKey, transformerConfig] of Object.entries(
       transformers
@@ -1504,15 +1598,30 @@ function detectExplicitCodeImports(flowConfig) {
       }
     }
   }
+  const stores = flowSettings.stores;
+  if (stores) {
+    for (const [, storeConfig] of Object.entries(stores)) {
+      if (typeof storeConfig === "object" && storeConfig !== null && "package" in storeConfig && typeof storeConfig.package === "string" && "code" in storeConfig && typeof storeConfig.code === "string") {
+        const isAutoGenerated = storeConfig.code.startsWith("_");
+        if (!isAutoGenerated) {
+          if (!explicitCodeImports.has(storeConfig.package)) {
+            explicitCodeImports.set(storeConfig.package, /* @__PURE__ */ new Set());
+          }
+          explicitCodeImports.get(storeConfig.package).add(storeConfig.code);
+        }
+      }
+    }
+  }
   return explicitCodeImports;
 }
-function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, explicitCodeImports) {
+function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, storePackages, explicitCodeImports) {
   const importStatements = [];
   const examplesMappings = [];
   const usedPackages = /* @__PURE__ */ new Set([
     ...destinationPackages,
     ...sourcePackages,
-    ...transformerPackages
+    ...transformerPackages,
+    ...storePackages
   ]);
   for (const [packageName, packageConfig] of Object.entries(packages)) {
     const isUsedByDestOrSource = usedPackages.has(packageName);
@@ -1568,22 +1677,79 @@ function generateImportStatements(packages, destinationPackages, sourcePackages,
   }
   return { importStatements, examplesMappings };
 }
-async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
-  const destinationPackages = detectDestinationPackages(flowConfig);
-  const sourcePackages = detectSourcePackages(flowConfig);
-  const transformerPackages = detectTransformerPackages(flowConfig);
-  const explicitCodeImports = detectExplicitCodeImports(flowConfig);
+function validateComponentNames(components, section) {
+  for (const name of Object.keys(components)) {
+    if (!VALID_JS_IDENTIFIER.test(name)) {
+      throw new Error(
+        `Invalid ${section} name "${name}": must be a valid JavaScript identifier (use camelCase, e.g., "${name.replace(/-([a-z])/g, (_2, c2) => c2.toUpperCase())}")`
+      );
+    }
+  }
+}
+function validateStoreReferences(flowSettings, storeIds) {
+  const refs = [];
+  function collectRefs(obj, path15) {
+    if (typeof obj === "string" && obj.startsWith("$store:")) {
+      refs.push({ ref: obj.slice(7), location: path15 });
+    } else if (obj && typeof obj === "object") {
+      for (const [key, val] of Object.entries(obj)) {
+        collectRefs(val, `${path15}.${key}`);
+      }
+    }
+  }
+  for (const [section, components] of Object.entries({
+    sources: flowSettings.sources || {},
+    destinations: flowSettings.destinations || {},
+    transformers: flowSettings.transformers || {}
+  })) {
+    for (const [id, component] of Object.entries(
+      components
+    )) {
+      collectRefs(component, `${section}.${id}`);
+    }
+  }
+  for (const { ref, location } of refs) {
+    if (!storeIds.has(ref)) {
+      const available = storeIds.size > 0 ? `Available stores: ${Array.from(storeIds).join(", ")}` : "No stores defined";
+      throw new Error(
+        `Store reference "$store:${ref}" in ${location} \u2014 store "${ref}" not found. ${available}`
+      );
+    }
+  }
+}
+async function createEntryPoint(flowSettings, buildOptions, packagePaths) {
+  const destinationPackages = detectDestinationPackages(flowSettings);
+  const sourcePackages = detectSourcePackages(flowSettings);
+  const transformerPackages = detectTransformerPackages(flowSettings);
+  const storePackages = detectStorePackages(flowSettings);
+  const explicitCodeImports = detectExplicitCodeImports(flowSettings);
+  const storeIds = new Set(
+    Object.keys(
+      flowSettings.stores || {}
+    )
+  );
+  validateStoreReferences(flowSettings, storeIds);
+  const flowWithSections = flowSettings;
+  if (flowWithSections.sources)
+    validateComponentNames(flowWithSections.sources, "sources");
+  if (flowWithSections.destinations)
+    validateComponentNames(flowWithSections.destinations, "destinations");
+  if (flowWithSections.transformers)
+    validateComponentNames(flowWithSections.transformers, "transformers");
+  if (flowWithSections.stores)
+    validateComponentNames(flowWithSections.stores, "stores");
   const { importStatements } = generateImportStatements(
     buildOptions.packages,
     destinationPackages,
     sourcePackages,
     transformerPackages,
+    storePackages,
     explicitCodeImports
   );
   const importsCode = importStatements.join("\n");
-  const hasFlow = Object.values(flowConfig.sources || {}).some(
+  const hasFlow = Object.values(flowSettings.sources || {}).some(
     (s2) => s2.package || isInlineCode(s2.code)
-  ) || Object.values(flowConfig.destinations || {}).some(
+  ) || Object.values(flowSettings.destinations || {}).some(
     (d2) => d2.package || isInlineCode(d2.code)
   );
   if (!hasFlow) {
@@ -1592,8 +1758,12 @@ async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
 
 ${userCode}` : userCode;
   }
-  const configObject = buildConfigObject(flowConfig, explicitCodeImports);
+  const { storesDeclaration, configObject } = buildConfigObject(
+    flowSettings,
+    explicitCodeImports
+  );
   const wrappedCode = generatePlatformWrapper(
+    storesDeclaration,
     configObject,
     buildOptions.code || "",
     buildOptions
@@ -1625,11 +1795,12 @@ ${firstError.text}`
 ` + (location ? `  at ${location.file}:${location.line}:${location.column}` : "")
   );
 }
-function buildConfigObject(flowConfig, explicitCodeImports) {
-  const flowWithProps = flowConfig;
+function buildConfigObject(flowSettings, explicitCodeImports) {
+  const flowWithProps = flowSettings;
   const sources = flowWithProps.sources || {};
   const destinations = flowWithProps.destinations || {};
   const transformers = flowWithProps.transformers || {};
+  const stores = flowWithProps.stores || {};
   Object.entries(sources).forEach(([name, source]) => {
     if (source.code !== true) {
       validateReference("Source", name, source);
@@ -1711,20 +1882,48 @@ function buildConfigObject(flowConfig, explicitCodeImports) {
       config: ${configStr}${envStr}${nextStr}
     }`;
   });
+  Object.entries(stores).forEach(([name, store]) => {
+    if (store.package || isInlineCode(store.code)) {
+      validateReference("Store", name, store);
+    }
+  });
+  const storesEntries = Object.entries(stores).filter(([, store]) => store.package || isInlineCode(store.code)).map(([key, store]) => {
+    if (isInlineCode(store.code)) {
+      return `    ${key}: ${generateInlineCode(store.code, store.config || {}, store.env)}`;
+    }
+    let codeVar;
+    if (store.code && typeof store.code === "string" && explicitCodeImports.has(store.package)) {
+      codeVar = store.code;
+    } else {
+      codeVar = packageNameToVariable(store.package);
+    }
+    const configStr = store.config ? processConfigValue(store.config) : "{}";
+    const envStr = store.env ? `,
+      env: ${processConfigValue(store.env)}` : "";
+    return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}
+    }`;
+  });
+  const storesDeclaration = storesEntries.length > 0 ? `const stores = {
+${storesEntries.join(",\n")}
+};` : "const stores = {};";
   const collectorStr = flowWithProps.collector ? `,
   ...${processConfigValue(flowWithProps.collector)}` : "";
   const transformersStr = transformersEntries.length > 0 ? `,
   transformers: {
 ${transformersEntries.join(",\n")}
   }` : "";
-  return `{
+  const configObject = `{
   sources: {
 ${sourcesEntries.join(",\n")}
   },
   destinations: {
 ${destinationsEntries.join(",\n")}
-  }${transformersStr}${collectorStr}
+  }${transformersStr},
+  stores${collectorStr}
 }`;
+  return { storesDeclaration, configObject };
 }
 function processConfigValue(value) {
   return serializeWithCode(value, 0);
@@ -1733,6 +1932,10 @@ function serializeWithCode(value, indent) {
   const spaces = "  ".repeat(indent);
   const nextSpaces = "  ".repeat(indent + 1);
   if (typeof value === "string") {
+    if (value.startsWith("$store:")) {
+      const storeId = value.slice(7);
+      return `stores.${storeId}`;
+    }
     if (value.startsWith("$code:")) {
       return value.slice(6);
     }
@@ -1789,7 +1992,7 @@ ${spaces}}`;
   }
   return JSON.stringify(value);
 }
-function generatePlatformWrapper(configObject, userCode, buildOptions) {
+function generatePlatformWrapper(storesDeclaration, configObject, userCode, buildOptions) {
   if (buildOptions.platform === "browser") {
     const windowAssignments = [];
     if (buildOptions.windowCollector) {
@@ -1804,6 +2007,8 @@ function generatePlatformWrapper(configObject, userCode, buildOptions) {
     }
     const assignments = windowAssignments.length > 0 ? "\n" + windowAssignments.join("\n") : "";
     return `(async () => {
+  ${storesDeclaration}
+
   const config = ${configObject};
 
   ${userCode}
@@ -1815,6 +2020,8 @@ function generatePlatformWrapper(configObject, userCode, buildOptions) {
   ${userCode}
 ` : "";
     return `export default async function(context = {}) {
+  ${storesDeclaration}
+
   const config = ${configObject};${codeSection}
   // Apply context overrides (e.g., logger config from CLI)
   if (context.logger) {
@@ -1841,6 +2048,16 @@ function generatePlatformWrapper(configObject, userCode, buildOptions) {
 }`;
   }
 }
+var VALID_JS_IDENTIFIER;
+var init_bundler = __esm({
+  "src/commands/bundle/bundler.ts"() {
+    "use strict";
+    init_package_manager();
+    init_tmp();
+    init_build_cache();
+    VALID_JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+  }
+});
 
 // src/commands/bundle/upload.ts
 import fs9 from "fs-extra";
@@ -1870,32 +2087,42 @@ async function uploadBundleToUrl(filePath, url, timeoutMs = 3e4) {
   };
   await doUpload(1);
 }
+var init_upload = __esm({
+  "src/commands/bundle/upload.ts"() {
+    "use strict";
+  }
+});
 
 // src/commands/bundle/stats.ts
-function displayStats(stats, logger2) {
-  logger2.info("\n\u{1F4CA} Bundle Statistics");
-  logger2.info("\u2500".repeat(50));
+function displayStats(stats, logger) {
+  logger.info("\n\u{1F4CA} Bundle Statistics");
+  logger.info("\u2500".repeat(50));
   const sizeKB = formatBytes(stats.totalSize);
-  logger2.info(`Total Size: ${sizeKB} KB`);
+  logger.info(`Total Size: ${sizeKB} KB`);
   const timeSeconds = (stats.buildTime / 1e3).toFixed(2);
-  logger2.info(`Build Time: ${timeSeconds}s`);
+  logger.info(`Build Time: ${timeSeconds}s`);
   const treeshakingStatus = stats.treeshakingEffective ? "\u2705 Effective" : "\u26A0\uFE0F  Not optimal (consider using named imports)";
-  logger2.info(`Tree-shaking: ${treeshakingStatus}`);
+  logger.info(`Tree-shaking: ${treeshakingStatus}`);
   if (stats.packages.length > 0) {
-    logger2.info(`
+    logger.info(`
 Package Breakdown:`);
     stats.packages.forEach((pkg) => {
       if (pkg.size > 0) {
         const pkgSizeKB = formatBytes(pkg.size);
-        logger2.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
+        logger.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
       }
     });
   }
-  logger2.info("\u2500".repeat(50));
+  logger.info("\u2500".repeat(50));
 }
+var init_stats = __esm({
+  "src/commands/bundle/stats.ts"() {
+    "use strict";
+    init_core();
+  }
+});
 
 // src/core/api-client.ts
-init_auth();
 import createClient from "openapi-fetch";
 function createApiClient() {
   const token = getToken();
@@ -1908,14 +2135,58 @@ function createApiClient() {
     }
   });
 }
+var init_api_client = __esm({
+  "src/core/api-client.ts"() {
+    "use strict";
+    init_auth();
+  }
+});
+
+// src/commands/bundle/dockerfile.ts
+import path10 from "path";
+import fs10 from "fs-extra";
+function buildDockerfileContent(platform, includedFolders) {
+  const bundleFile = platform === "web" ? "walker.js" : "bundle.mjs";
+  const lines = [
+    "# Generated by walkeros CLI",
+    "FROM walkeros/flow:latest",
+    "",
+    `COPY ${bundleFile} /app/flow/${bundleFile}`
+  ];
+  for (const folder of includedFolders) {
+    const name = path10.basename(folder);
+    lines.push(`COPY ${name}/ /app/flow/${name}/`);
+  }
+  lines.push("", `ENV BUNDLE=/app/flow/${bundleFile}`, "", "EXPOSE 8080", "");
+  return lines.join("\n");
+}
+async function generateDockerfile(outputDir, platform, logger, customFile, includedFolders) {
+  const destPath = path10.join(outputDir, "Dockerfile");
+  if (customFile && await fs10.pathExists(customFile)) {
+    await fs10.copy(customFile, destPath);
+    logger.info(`Dockerfile: ${destPath} (copied from ${customFile})`);
+    return;
+  }
+  const dockerfile = buildDockerfileContent(platform, includedFolders || []);
+  await fs10.writeFile(destPath, dockerfile);
+  logger.info(`Dockerfile: ${destPath}`);
+}
+var init_dockerfile = __esm({
+  "src/commands/bundle/dockerfile.ts"() {
+    "use strict";
+  }
+});
 
 // src/commands/bundle/index.ts
+import path11 from "path";
+import fs11 from "fs-extra";
+import { getPlatform as getPlatform2 } from "@walkeros/core";
 function resolveOutputPath(output, buildOptions) {
-  const resolved = path10.resolve(output);
-  const ext = path10.extname(resolved);
-  if (output.endsWith("/") || output.endsWith(path10.sep) || !ext) {
+  const resolved = path11.resolve(output);
+  const ext = path11.extname(resolved);
+  if (output.endsWith("/") || output.endsWith(path11.sep) || !ext) {
     const filename = buildOptions.platform === "browser" ? "walker.js" : "bundle.mjs";
-    return path10.join(resolved, filename);
+    return path11.join(resolved, filename);
   }
   return resolved;
 }
@@ -1923,7 +2194,7 @@ async function bundleCommand(options) {
   const timer = createTimer();
   timer.start();
   const writingToStdout = !options.output;
-  const logger2 = createCLILogger({
+  const logger = createCLILogger({
     ...options,
     stderr: writingToStdout
   });
@@ -1945,22 +2216,22 @@ async function bundleCommand(options) {
       } catch {
         throw new Error("Invalid JSON received on stdin");
       }
-      configPath = path10.resolve(process.cwd(), "stdin.config.json");
+      configPath = path11.resolve(process.cwd(), "stdin.config.json");
     } else {
       const file = options.config || "bundle.config.json";
       configPath = resolveAsset(file, "config");
       rawConfig = await loadJsonConfig(configPath);
     }
-    const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger: logger2 }) : [
+    const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger }) : [
       loadBundleConfig(rawConfig, {
         configPath,
         flowName: options.flow,
-        logger: logger2
+        logger
       })
     ];
     const results = [];
     for (const {
-      flowConfig,
+      flowSettings,
       buildOptions,
       flowName,
       isMultiFlow
@@ -1984,36 +2255,42 @@ async function bundleCommand(options) {
           buildOptions.output = getTmpPath(void 0, "stdout-bundle" + ext);
         }
         if (isMultiFlow || options.all) {
-          logger2.info(`Bundling flow: ${flowName}...`);
+          logger.info(`Bundling flow: ${flowName}...`);
         } else {
-          logger2.info("Bundling...");
+          logger.info("Bundling...");
         }
         const shouldCollectStats = options.stats || options.json;
         const stats = await bundleCore(
-          flowConfig,
+          flowSettings,
           buildOptions,
-          logger2,
+          logger,
           shouldCollectStats
         );
         results.push({ flowName, success: true, stats });
         if (uploadUrl) {
           await uploadBundleToUrl(buildOptions.output, uploadUrl);
-          logger2.info(`Uploaded to: ${sanitizeUrl(uploadUrl)}`);
-          await fs10.remove(buildOptions.output);
+          logger.info(`Uploaded to: ${sanitizeUrl(uploadUrl)}`);
+          await fs11.remove(buildOptions.output);
         }
         if (!options.json && !options.all && options.stats && stats) {
-          displayStats(stats, logger2);
+          displayStats(stats, logger);
         }
         if (writingToStdout && !options.json) {
-          const bundleContent = await fs10.readFile(buildOptions.output);
+          const bundleContent = await fs11.readFile(buildOptions.output);
           await writeResult(bundleContent, {});
         }
         if (options.dockerfile && options.output) {
-          const platform = getPlatform2(flowConfig);
+          const platform = getPlatform2(flowSettings);
           if (platform) {
-            const outputDir = path10.dirname(buildOptions.output);
+            const outputDir = path11.dirname(buildOptions.output);
             const customFile = typeof options.dockerfile === "string" ? options.dockerfile : void 0;
-            await generateDockerfile(outputDir, platform, logger2, customFile);
+            await generateDockerfile(
+              outputDir,
+              platform,
+              logger,
+              customFile,
+              buildOptions.include
+            );
           }
         }
       } catch (error) {
@@ -2047,12 +2324,12 @@ async function bundleCommand(options) {
       });
     } else {
       if (options.all) {
-        logger2.info(
+        logger.info(
           `
 Build Summary: ${successCount}/${results.length} succeeded`
         );
         if (failureCount > 0) {
-          logger2.error(`Failed: ${failureCount}`);
+          logger.error(`Failed: ${failureCount}`);
         }
       }
       if (failureCount > 0) {
@@ -2069,21 +2346,21 @@ Build Summary: ${successCount}/${results.length} succeeded`
         output: options.output
       });
     } else {
-      logger2.error(`Error: ${errorMessage}`);
+      logger.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
   }
 }
 async function bundle(configOrPath, options = {}) {
   let rawConfig;
-  let configPath = path10.resolve(process.cwd(), "walkeros.config.json");
+  let configPath = path11.resolve(process.cwd(), "walkeros.config.json");
   if (typeof configOrPath === "string") {
     configPath = resolveAsset(configOrPath, "config");
     rawConfig = await loadJsonConfig(configPath);
   } else {
     rawConfig = configOrPath;
   }
-  const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+  const { flowSettings, buildOptions } = loadBundleConfig(rawConfig, {
     configPath,
     flowName: options.flowName,
     buildOverrides: options.buildOverrides
@@ -2091,35 +2368,14 @@ async function bundle(configOrPath, options = {}) {
   if (options.cache !== void 0) {
     buildOptions.cache = options.cache;
   }
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   return await bundleCore(
-    flowConfig,
+    flowSettings,
     buildOptions,
-    logger2,
+    logger,
     options.stats ?? false
   );
 }
-async function generateDockerfile(outputDir, platform, logger2, customFile) {
-  const destPath = path10.join(outputDir, "Dockerfile");
-  if (customFile && await fs10.pathExists(customFile)) {
-    await fs10.copy(customFile, destPath);
-    logger2.info(`Dockerfile: ${destPath} (copied from ${customFile})`);
-    return;
-  }
-  const isWeb = platform === "web";
-  const bundleFile = isWeb ? "walker.js" : "bundle.mjs";
-  const dockerfile = `# Generated by walkeros CLI
-FROM walkeros/flow:latest
-
-COPY ${bundleFile} /app/flow/${bundleFile}
-
-ENV BUNDLE=/app/flow/${bundleFile}
-
-EXPOSE 8080
-`;
-  await fs10.writeFile(destPath, dockerfile);
-  logger2.info(`Dockerfile: ${destPath}`);
-}
 async function bundleRemote(options) {
   const client = createApiClient();
   const body = { flow: options.content };
@@ -2138,19 +2394,122 @@ async function bundleRemote(options) {
     stats: statsHeader ? JSON.parse(statsHeader) : void 0
   };
 }
+var init_bundle = __esm({
+  "src/commands/bundle/index.ts"() {
+    "use strict";
+    init_cli_logger();
+    init_core();
+    init_config();
+    init_utils();
+    init_bundler();
+    init_upload();
+    init_stats();
+    init_api_client();
+    init_dockerfile();
+  }
+});
+
+// src/runtime/cache.ts
+var cache_exports = {};
+__export(cache_exports, {
+  readCache: () => readCache,
+  readCacheConfig: () => readCacheConfig,
+  writeCache: () => writeCache
+});
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  copyFileSync,
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync2
+} from "fs";
+import { join as join2 } from "path";
+function writeCache(cacheDir, bundlePath, configContent, version) {
+  mkdirSync2(cacheDir, { recursive: true });
+  copyFileSync(bundlePath, join2(cacheDir, "bundle.mjs"));
+  writeFileSync3(join2(cacheDir, "config.json"), configContent, "utf-8");
+  const meta = { version, timestamp: Date.now() };
+  writeFileSync3(join2(cacheDir, "meta.json"), JSON.stringify(meta), "utf-8");
+}
+function readCache(cacheDir) {
+  try {
+    const metaPath = join2(cacheDir, "meta.json");
+    const bundlePath = join2(cacheDir, "bundle.mjs");
+    if (!existsSync4(metaPath) || !existsSync4(bundlePath)) return null;
+    const meta = JSON.parse(readFileSync2(metaPath, "utf-8"));
+    return { bundlePath, version: meta.version };
+  } catch {
+    return null;
+  }
+}
+function readCacheConfig(cacheDir) {
+  try {
+    const configPath = join2(cacheDir, "config.json");
+    if (!existsSync4(configPath)) return null;
+    return readFileSync2(configPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var init_cache = __esm({
+  "src/runtime/cache.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/run/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  isPreBuiltConfig: () => isPreBuiltConfig,
+  prepareBundleForRun: () => prepareBundleForRun
+});
+import path13 from "path";
+import fs14 from "fs-extra";
+async function prepareBundleForRun(configPath, options) {
+  const tempDir = getTmpPath(
+    void 0,
+    `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  );
+  await fs14.ensureDir(tempDir);
+  const tempPath = path13.join(tempDir, "bundle.mjs");
+  await bundle(configPath, {
+    cache: true,
+    verbose: options.verbose,
+    silent: options.silent,
+    flowName: options.flowName,
+    buildOverrides: {
+      output: tempPath,
+      format: "esm",
+      platform: "node"
+    }
+  });
+  return tempPath;
+}
+function isPreBuiltConfig(configPath) {
+  return configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
+}
+var init_utils3 = __esm({
+  "src/commands/run/utils.ts"() {
+    "use strict";
+    init_bundle();
+    init_core();
+  }
+});
+
+// src/index.ts
+init_bundle();
 
 // src/commands/simulate/simulator.ts
-import fs11 from "fs-extra";
-import { Level as Level2 } from "@walkeros/core";
+import fs12 from "fs-extra";
 
 // ../collector/dist/index.mjs
 import { assign as o } from "@walkeros/core";
-import { assign as i, createLogger as r } from "@walkeros/core";
-import { assign as a, clone as c, debounce as u, getId as f, getGrantedConsent as l, isDefined as d, isFunction as g, isObject as m, processEventMapping as p, tryCatchAsync as h, useHooks as w } from "@walkeros/core";
+import { assign as r, createLogger as i } from "@walkeros/core";
+import { assign as a, clone as c, debounce as u, getId as f, getGrantedConsent as l, isDefined as g, isFunction as d, isObject as m, processEventMapping as p, tryCatchAsync as h, useHooks as w } from "@walkeros/core";
 import { isArray as y } from "@walkeros/core";
 import { tryCatch as b, tryCatchAsync as v } from "@walkeros/core";
 import { getMappingValue as k, tryCatchAsync as C } from "@walkeros/core";
-import { isObject as O, tryCatchAsync as q, useHooks as j } from "@walkeros/core";
+import { isObject as O, tryCatchAsync as j, useHooks as q } from "@walkeros/core";
 import { assign as M, getId as Q, isFunction as V, isString as _ } from "@walkeros/core";
 import { isObject as K } from "@walkeros/core";
 import { getGrantedConsent as en, processEventMapping as tn, tryCatchAsync as on, useHooks as sn } from "@walkeros/core";
@@ -2190,58 +2549,58 @@ function E(n, e2 = {}) {
   }
   return t2;
 }
-async function P(n, e2, t2) {
+async function x(n, e2, t2) {
   if (e2.init && !e2.config.init) {
-    const o2 = e2.type || "unknown", s2 = n.logger.scope(`transformer:${o2}`), i2 = { collector: n, logger: s2, id: t2, config: e2.config, env: $(e2.config.env) };
+    const o2 = e2.type || "unknown", s2 = n.logger.scope(`transformer:${o2}`), r2 = { collector: n, logger: s2, id: t2, config: e2.config, env: $(e2.config.env) };
     s2.debug("init");
-    const r2 = await j(e2.init, "TransformerInit", n.hooks)(i2);
-    if (false === r2) return false;
-    e2.config = { ...r2 || e2.config, init: true }, s2.debug("init done");
+    const i2 = await q(e2.init, "TransformerInit", n.hooks)(r2);
+    if (false === i2) return false;
+    e2.config = { ...i2 || e2.config, init: true }, s2.debug("init done");
   }
   return true;
 }
-async function x(n, e2, t2, o2, s2, i2) {
-  const r2 = e2.type || "unknown", a2 = n.logger.scope(`transformer:${r2}`), c2 = { collector: n, logger: a2, id: t2, ingest: s2, config: e2.config, env: { ...$(e2.config.env), ...i2 ? { respond: i2 } : {} } };
+async function P(n, e2, t2, o2, s2, r2) {
+  const i2 = e2.type || "unknown", a2 = n.logger.scope(`transformer:${i2}`), c2 = { collector: n, logger: a2, id: t2, ingest: s2, config: e2.config, env: { ...$(e2.config.env), ...r2 ? { respond: r2 } : {} } };
   a2.debug("push", { event: o2.name });
-  const u2 = await j(e2.push, "TransformerPush", n.hooks)(o2, c2);
+  const u2 = await q(e2.push, "TransformerPush", n.hooks)(o2, c2);
   return a2.debug("push done"), u2;
 }
-async function S(n, e2, t2, o2, s2, i2) {
-  let r2 = o2, a2 = i2;
+async function S(n, e2, t2, o2, s2, r2) {
+  let i2 = o2, a2 = r2;
   for (const o3 of t2) {
     const t3 = e2[o3];
     if (!t3) {
       n.logger.warn(`Transformer not found: ${o3}`);
       continue;
     }
-    if (!await q(P)(n, t3, o3)) return n.logger.error(`Transformer init failed: ${o3}`), null;
-    const i3 = await q(x, (e3) => (n.logger.scope(`transformer:${t3.type || "unknown"}`).error("Push failed", { error: e3 }), false))(n, t3, o3, r2, s2, a2);
-    if (false === i3) return null;
-    if (i3 && "object" == typeof i3) {
-      const { event: t4, respond: o4, next: c2 } = i3;
+    if (!await j(x)(n, t3, o3)) return n.logger.error(`Transformer init failed: ${o3}`), null;
+    const r3 = await j(P, (e3) => (n.logger.scope(`transformer:${t3.type || "unknown"}`).error("Push failed", { error: e3 }), false))(n, t3, o3, i2, s2, a2);
+    if (false === r3) return null;
+    if (r3 && "object" == typeof r3) {
+      const { event: t4, respond: o4, next: c2 } = r3;
       if (o4 && (a2 = o4), c2) {
         const o5 = E(c2, D(e2));
-        return o5.length > 0 ? S(n, e2, o5, t4 || r2, s2, a2) : (n.logger.warn(`Branch target not found: ${JSON.stringify(c2)}`), null);
+        return o5.length > 0 ? S(n, e2, o5, t4 || i2, s2, a2) : (n.logger.warn(`Branch target not found: ${JSON.stringify(c2)}`), null);
       }
-      t4 && (r2 = t4);
+      t4 && (i2 = t4);
     }
   }
-  return r2;
+  return i2;
 }
 function $(n) {
   return n && O(n) ? n : {};
 }
 async function R(n, e2, t2) {
-  const { code: o2, config: s2 = {}, env: i2 = {}, primary: r2, next: a2 } = t2;
+  const { code: o2, config: s2 = {}, env: r2 = {}, primary: i2, next: a2 } = t2;
   let c2, u2;
-  const f2 = E(a2, D(n.transformers)), l2 = n.logger.scope("source").scope(e2), d2 = { push: (t3, o3 = {}) => n.push(t3, { ...o3, id: e2, ingest: c2, respond: u2, mapping: s2, preChain: f2 }), command: n.command, sources: n.sources, elb: n.sources.elb.push, logger: l2, ...i2 }, g2 = { collector: n, logger: l2, id: e2, config: s2, env: d2, setIngest: async (e3) => {
+  const f2 = E(a2, D(n.transformers)), l2 = n.logger.scope("source").scope(e2), g2 = { push: (t3, o3 = {}) => n.push(t3, { ...o3, id: e2, ingest: c2, respond: u2, mapping: s2, preChain: f2 }), command: n.command, sources: n.sources, elb: n.sources.elb.push, logger: l2, ...r2 }, d2 = { collector: n, logger: l2, id: e2, config: s2, env: g2, setIngest: async (e3) => {
     c2 = s2.ingest ? await k(e3, s2.ingest, { collector: n }) : void 0;
   }, setRespond: (n2) => {
     u2 = n2;
-  } }, m2 = await C(o2)(g2);
+  } }, m2 = await C(o2)(d2);
   if (!m2) return;
   const p2 = m2.type || "unknown", h2 = n.logger.scope(p2).scope(e2);
-  return d2.logger = h2, r2 && (m2.config = { ...m2.config, primary: r2 }), m2;
+  return g2.logger = h2, i2 && (m2.config = { ...m2.config, primary: i2 }), m2;
 }
 async function T(n, e2 = {}) {
   const t2 = {};
@@ -2251,81 +2610,81 @@ async function T(n, e2 = {}) {
       n.pending.sources[o2] = s2;
       continue;
     }
-    const i2 = await R(n, o2, s2);
-    i2 && (t2[o2] = i2);
+    const r2 = await R(n, o2, s2);
+    r2 && (t2[o2] = r2);
   }
   return t2;
 }
 async function I(n, e2, t2) {
-  const o2 = n.on, s2 = o2[e2] || [], i2 = y(t2) ? t2 : [t2];
-  i2.forEach((n2) => {
+  const o2 = n.on, s2 = o2[e2] || [], r2 = y(t2) ? t2 : [t2];
+  r2.forEach((n2) => {
     s2.push(n2);
-  }), o2[e2] = s2, await G(n, e2, i2);
+  }), o2[e2] = s2, await G(n, e2, r2);
 }
 function B(n, e2, t2, o2, s2) {
   if (!e2.on) return;
-  const i2 = e2.type || "unknown", r2 = n.logger.scope(i2).scope("on").scope(o2), a2 = { collector: n, logger: r2, id: t2, config: e2.config, data: s2, env: L(e2.env, e2.config.env) };
+  const r2 = e2.type || "unknown", i2 = n.logger.scope(r2).scope("on").scope(o2), a2 = { collector: n, logger: i2, id: t2, config: e2.config, data: s2, env: L(e2.env, e2.config.env) };
   b(e2.on)(o2, a2);
 }
 async function G(n, e2, o2, s2) {
-  let i2, r2 = o2 || [];
-  switch (o2 || (r2 = n.on[e2] || []), e2) {
+  let r2, i2 = o2 || [];
+  switch (o2 || (i2 = n.on[e2] || []), e2) {
     case t.Commands.Consent:
-      i2 = s2 || n.consent;
+      r2 = s2 || n.consent;
       break;
     case t.Commands.Session:
-      i2 = n.session;
+      r2 = n.session;
       break;
     case t.Commands.User:
-      i2 = s2 || n.user;
+      r2 = s2 || n.user;
       break;
     case t.Commands.Custom:
-      i2 = s2 || n.custom;
+      r2 = s2 || n.custom;
       break;
     case t.Commands.Globals:
-      i2 = s2 || n.globals;
+      r2 = s2 || n.globals;
       break;
     case t.Commands.Config:
-      i2 = s2 || n.config;
+      r2 = s2 || n.config;
       break;
     case t.Commands.Ready:
     case t.Commands.Run:
     default:
-      i2 = void 0;
+      r2 = void 0;
   }
   let a2 = false;
   for (const t2 of Object.values(n.sources)) if (t2.on) {
-    false === await v(t2.on)(e2, i2) && (a2 = true);
+    false === await v(t2.on)(e2, r2) && (a2 = true);
   }
   if (Object.entries(n.destinations).forEach(([t2, o3]) => {
     if (o3.on) {
-      if (!o3.config.init) return o3.queueOn = o3.queueOn || [], void o3.queueOn.push({ type: e2, data: i2 });
-      B(n, o3, t2, e2, i2);
+      if (!o3.config.init) return o3.queueOn = o3.queueOn || [], void o3.queueOn.push({ type: e2, data: r2 });
+      B(n, o3, t2, e2, r2);
     }
   }), (Object.keys(n.pending.sources).length > 0 || Object.keys(n.pending.destinations).length > 0) && await (async function(n2, e3) {
     for (const [t2, o3] of Object.entries(n2.pending.sources)) {
       if (!n2.pending.sources[t2] || n2.sources[t2]) continue;
       const s3 = o3.config?.require;
       if (!s3) continue;
-      const i3 = s3.indexOf(e3);
-      if (-1 === i3) continue;
-      if (s3.splice(i3, 1), s3.length > 0) continue;
+      const r3 = s3.indexOf(e3);
+      if (-1 === r3) continue;
+      if (s3.splice(r3, 1), s3.length > 0) continue;
       delete n2.pending.sources[t2];
-      const r3 = await R(n2, t2, o3);
-      r3 && (n2.sources[t2] = r3);
+      const i3 = await R(n2, t2, o3);
+      i3 && (n2.sources[t2] = i3);
     }
     for (const [t2, o3] of Object.entries(n2.pending.destinations)) {
       if (!n2.pending.destinations[t2] || n2.destinations[t2]) continue;
       const s3 = o3.config?.require;
       if (!s3) continue;
-      const i3 = s3.indexOf(e3);
-      if (-1 === i3) continue;
-      if (s3.splice(i3, 1), s3.length > 0) continue;
+      const r3 = s3.indexOf(e3);
+      if (-1 === r3) continue;
+      if (s3.splice(r3, 1), s3.length > 0) continue;
       delete n2.pending.destinations[t2];
-      const r3 = W(o3);
-      false !== r3.config.queue && (r3.queuePush = [...n2.queue]), n2.destinations[t2] = r3;
+      const i3 = W(o3);
+      false !== i3.config.queue && (i3.queuePush = [...n2.queue]), n2.destinations[t2] = i3;
     }
-  })(n, e2), !r2.length) return !a2;
+  })(n, e2), !i2.length) return !a2;
   switch (e2) {
     case t.Commands.Consent:
       !(function(n2, e3, t2) {
@@ -2335,7 +2694,7 @@ async function G(n, e2, o2, s2) {
             b(e4[t3])(n2, o3);
           });
         });
-      })(n, r2, s2);
+      })(n, i2, s2);
       break;
     case t.Commands.Ready:
     case t.Commands.Run:
@@ -2343,7 +2702,7 @@ async function G(n, e2, o2, s2) {
         n2.allowed && e3.forEach((e4) => {
           b(e4)(n2);
         });
-      })(n, r2);
+      })(n, i2);
       break;
     case t.Commands.Session:
       !(function(n2, e3) {
@@ -2351,19 +2710,19 @@ async function G(n, e2, o2, s2) {
         e3.forEach((e4) => {
           b(e4)(n2, n2.session);
         });
-      })(n, r2);
+      })(n, i2);
       break;
     default:
-      r2.forEach((e3) => {
-        "function" == typeof e3 && b(e3)(n, i2);
+      i2.forEach((e3) => {
+        "function" == typeof e3 && b(e3)(n, r2);
       });
   }
   return !a2;
 }
 async function H(n, e2, t2) {
-  const { code: o2, config: s2 = {}, env: i2 = {}, before: r2 } = e2;
-  if (!g(o2.push)) return N({ ok: false, failed: { invalid: { type: "invalid", error: "Destination code must have a push method" } } });
-  const a2 = t2 || s2 || { init: false }, c2 = r2 ? { ...a2, before: r2 } : a2, u2 = { ...o2, config: c2, env: L(o2.env, i2) };
+  const { code: o2, config: s2 = {}, env: r2 = {}, before: i2 } = e2;
+  if (!d(o2.push)) return N({ ok: false, failed: { invalid: { type: "invalid", error: "Destination code must have a push method" } } });
+  const a2 = t2 || s2 || { init: false }, c2 = i2 ? { ...a2, before: i2 } : a2, u2 = { ...o2, config: c2, env: L(o2.env, r2) };
   let l2 = u2.config.id;
   if (!l2) do {
     l2 = f(4);
@@ -2371,11 +2730,11 @@ async function H(n, e2, t2) {
   return n.destinations[l2] = u2, false !== u2.config.queue && (u2.queuePush = [...n.queue]), U(n, void 0, {}, { [l2]: u2 });
 }
 async function U(n, e2, t2 = {}, o2) {
-  const { allowed: s2, consent: i2, globals: r2, user: u2 } = n;
+  const { allowed: s2, consent: r2, globals: i2, user: u2 } = n;
   if (!s2) return N({ ok: false });
   e2 && (n.queue.push(e2), n.status.in++), o2 || (o2 = n.destinations);
   const f2 = await Promise.all(Object.entries(o2 || {}).map(async ([o3, s3]) => {
-    let f3 = (s3.queuePush || []).map((n2) => ({ ...n2, consent: i2 }));
+    let f3 = (s3.queuePush || []).map((n2) => ({ ...n2, consent: r2 }));
     if (s3.queuePush = [], e2) {
       const n2 = c(e2);
       f3.push(n2);
@@ -2385,11 +2744,11 @@ async function U(n, e2, t2 = {}, o2) {
       const e3 = await h(F)(n, s3, o3);
       return { id: o3, destination: s3, skipped: !e3 };
     }
-    const d3 = [], g3 = f3.filter((n2) => {
-      const e3 = l(s3.config.consent, i2, n2.consent);
-      return !e3 || (n2.consent = e3, d3.push(n2), false);
+    const g3 = [], d3 = f3.filter((n2) => {
+      const e3 = l(s3.config.consent, r2, n2.consent);
+      return !e3 || (n2.consent = e3, g3.push(n2), false);
     });
-    if (s3.queuePush.push(...g3), !d3.length) return { id: o3, destination: s3, queue: f3 };
+    if (s3.queuePush.push(...d3), !g3.length) return { id: o3, destination: s3, queue: f3 };
     if (!await h(F)(n, s3, o3)) return { id: o3, destination: s3, queue: f3 };
     let m3, p2;
     s3.dlq || (s3.dlq = []);
@@ -2398,50 +2757,50 @@ async function U(n, e2, t2 = {}, o2) {
       return t3 ? E(t3, D(e3)) : [];
     })(s3, n.transformers);
     let y2 = 0;
-    return await Promise.all(d3.map(async (e3) => {
-      e3.globals = a(r2, e3.globals), e3.user = a(u2, e3.user);
-      let i3 = e3;
+    return await Promise.all(g3.map(async (e3) => {
+      e3.globals = a(i2, e3.globals), e3.user = a(u2, e3.user);
+      let r3 = e3;
       if (w2.length > 0 && n.transformers && Object.keys(n.transformers).length > 0) {
         const o4 = await S(n, n.transformers, w2, e3, t2.ingest, t2.respond);
         if (null === o4) return e3;
-        i3 = o4;
+        r3 = o4;
       }
       const c2 = Date.now(), f4 = await h(J, (e4) => {
         const t3 = s3.type || "unknown";
-        n.logger.scope(t3).error("Push failed", { error: e4, event: i3.name }), m3 = e4, s3.dlq.push([i3, e4]);
-      })(n, s3, o3, i3, t2.ingest, t2.respond);
+        n.logger.scope(t3).error("Push failed", { error: e4, event: r3.name }), m3 = e4, s3.dlq.push([r3, e4]);
+      })(n, s3, o3, r3, t2.ingest, t2.respond);
       return y2 += Date.now() - c2, void 0 !== f4 && (p2 = f4), e3;
     })), { id: o3, destination: s3, error: m3, response: p2, totalDuration: y2 };
-  })), d2 = {}, g2 = {}, m2 = {};
+  })), g2 = {}, d2 = {}, m2 = {};
   for (const e3 of f2) {
     if (e3.skipped) continue;
-    const t3 = e3.destination, o3 = { type: t3.type || "unknown", data: e3.response };
+    const t3 = { type: e3.destination.type || "unknown", data: e3.response };
     n.status.destinations[e3.id] || (n.status.destinations[e3.id] = { count: 0, failed: 0, duration: 0 });
-    const s3 = n.status.destinations[e3.id], i3 = Date.now();
-    e3.error ? (o3.error = e3.error, m2[e3.id] = o3, s3.failed++, s3.lastAt = i3, s3.duration += e3.totalDuration || 0, n.status.failed++) : e3.queue && e3.queue.length ? (t3.queuePush = (t3.queuePush || []).concat(e3.queue), g2[e3.id] = o3) : (d2[e3.id] = o3, s3.count++, s3.lastAt = i3, s3.duration += e3.totalDuration || 0, n.status.out++);
+    const o3 = n.status.destinations[e3.id], s3 = Date.now();
+    e3.error ? (t3.error = e3.error, m2[e3.id] = t3, o3.failed++, o3.lastAt = s3, o3.duration += e3.totalDuration || 0, n.status.failed++) : e3.queue && e3.queue.length ? d2[e3.id] = t3 : (g2[e3.id] = t3, o3.count++, o3.lastAt = s3, o3.duration += e3.totalDuration || 0, n.status.out++);
   }
-  return N({ event: e2, ...Object.keys(d2).length && { done: d2 }, ...Object.keys(g2).length && { queued: g2 }, ...Object.keys(m2).length && { failed: m2 } });
+  return N({ event: e2, ...Object.keys(g2).length && { done: g2 }, ...Object.keys(d2).length && { queued: d2 }, ...Object.keys(m2).length && { failed: m2 } });
 }
 async function F(n, e2, t2) {
   if (e2.init && !e2.config.init) {
-    const o2 = e2.type || "unknown", s2 = n.logger.scope(o2), i2 = { collector: n, logger: s2, id: t2, config: e2.config, env: L(e2.env, e2.config.env) };
+    const o2 = e2.type || "unknown", s2 = n.logger.scope(o2), r2 = { collector: n, logger: s2, id: t2, config: e2.config, env: L(e2.env, e2.config.env) };
     s2.debug("init");
-    const r2 = await w(e2.init, "DestinationInit", n.hooks)(i2);
-    if (false === r2) return r2;
-    if (e2.config = { ...r2 || e2.config, init: true }, e2.queueOn?.length) {
+    const i2 = await w(e2.init, "DestinationInit", n.hooks)(r2);
+    if (false === i2) return i2;
+    if (e2.config = { ...i2 || e2.config, init: true }, e2.queueOn?.length) {
       const o3 = e2.queueOn;
       e2.queueOn = [];
-      for (const { type: s3, data: i3 } of o3) B(n, e2, t2, s3, i3);
+      for (const { type: s3, data: r3 } of o3) B(n, e2, t2, s3, r3);
     }
     s2.debug("init done");
   }
   return true;
 }
-async function J(n, e2, t2, o2, s2, i2) {
-  const { config: r2 } = e2, a2 = await p(o2, r2, n);
+async function J(n, e2, t2, o2, s2, r2) {
+  const { config: i2 } = e2, a2 = await p(o2, i2, n);
   if (a2.ignore) return false;
-  const c2 = e2.type || "unknown", f2 = n.logger.scope(c2), l2 = { collector: n, logger: f2, id: t2, config: r2, data: a2.data, rule: a2.mapping, ingest: s2, env: { ...L(e2.env, r2.env), ...i2 ? { respond: i2 } : {} } }, g2 = a2.mapping, m2 = a2.mappingKey || "* *";
-  if (!g2?.batch || !e2.pushBatch) {
+  const c2 = e2.type || "unknown", f2 = n.logger.scope(c2), l2 = { collector: n, logger: f2, id: t2, config: i2, data: a2.data, rule: a2.mapping, ingest: s2, env: { ...L(e2.env, i2.env), ...r2 ? { respond: r2 } : {} } }, d2 = a2.mapping, m2 = a2.mappingKey || "* *";
+  if (!d2?.batch || !e2.pushBatch) {
     f2.debug("push", { event: a2.event.name });
     const t3 = await w(e2.push, "DestinationPush", n.hooks)(a2.event, l2);
     return f2.debug("push done"), t3;
@@ -2450,12 +2809,12 @@ async function J(n, e2, t2, o2, s2, i2) {
     if (e2.batches = e2.batches || {}, !e2.batches[m2]) {
       const o4 = { key: m2, events: [], data: [] };
       e2.batches[m2] = { batched: o4, batchFn: u(() => {
-        const o5 = e2.batches[m2].batched, a3 = { collector: n, logger: f2, id: t2, config: r2, data: void 0, rule: g2, ingest: s2, env: { ...L(e2.env, r2.env), ...i2 ? { respond: i2 } : {} } };
+        const o5 = e2.batches[m2].batched, a3 = { collector: n, logger: f2, id: t2, config: i2, data: void 0, rule: d2, ingest: s2, env: { ...L(e2.env, i2.env), ...r2 ? { respond: r2 } : {} } };
         f2.debug("push batch", { events: o5.events.length }), w(e2.pushBatch, "DestinationPushBatch", n.hooks)(o5, a3), f2.debug("push batch done"), o5.events = [], o5.data = [];
-      }, g2.batch) };
+      }, d2.batch) };
     }
     const o3 = e2.batches[m2];
-    o3.batched.events.push(a2.event), d(a2.data) && o3.batched.data.push(a2.data), o3.batchFn();
+    o3.batched.events.push(a2.event), g(a2.data) && o3.batched.data.push(a2.data), o3.batchFn();
   }
   return true;
 }
@@ -2463,8 +2822,8 @@ function N(n) {
   return { ok: !n?.failed, ...n };
 }
 function W(n) {
-  const { code: e2, config: t2 = {}, env: o2 = {} } = n, { config: s2 } = A(n, "before"), i2 = { ...e2.config, ...t2, ...s2 }, r2 = L(e2.env, o2);
-  return { ...e2, config: i2, env: r2 };
+  const { code: e2, config: t2 = {}, env: o2 = {} } = n, { config: s2 } = A(n, "before"), r2 = { ...e2.config, ...t2, ...s2 }, i2 = L(e2.env, o2);
+  return { ...e2, config: r2, env: i2 };
 }
 async function z(n, e2 = {}) {
   const t2 = {};
@@ -2478,17 +2837,17 @@ async function X(n, e2, t2) {
   const o2 = Object.entries(n).map(async ([n2, o3]) => {
     const s2 = o3.destroy;
     if (!s2) return;
-    const i2 = o3.type || "unknown", r2 = t2.scope(i2), a2 = { id: n2, config: o3.config, env: o3.env ?? {}, logger: r2 };
+    const r2 = o3.type || "unknown", i2 = t2.scope(r2), a2 = { id: n2, config: o3.config, env: o3.env ?? {}, logger: i2 };
     try {
       await Promise.race([s2(a2), new Promise((t3, o4) => setTimeout(() => o4(new Error(`${e2} '${n2}' destroy timed out`)), 5e3))]);
     } catch (t3) {
-      r2.error(`${e2} '${n2}' destroy failed: ${t3}`);
+      i2.error(`${e2} '${n2}' destroy failed: ${t3}`);
     }
   });
   await Promise.allSettled(o2);
 }
-async function Y(n, e2, o2, i2) {
-  let r2, a2, c2 = false, u2 = false;
+async function Y(n, e2, o2, r2) {
+  let i2, a2, c2 = false, u2 = false;
   switch (e2) {
     case t.Commands.Config:
       K(o2) && (M(n.config, o2, { shallow: false }), a2 = o2, c2 = true);
@@ -2503,19 +2862,19 @@ async function Y(n, e2, o2, i2) {
       K(o2) && (n.custom = M(n.custom, o2), a2 = o2, c2 = true);
       break;
     case t.Commands.Destination:
-      K(o2) && ("code" in o2 && K(o2.code) ? r2 = await H(n, o2, i2) : V(o2.push) && (r2 = await H(n, { code: o2 }, i2)));
+      K(o2) && ("code" in o2 && K(o2.code) ? i2 = await H(n, o2, r2) : V(o2.push) && (i2 = await H(n, { code: o2 }, r2)));
       break;
     case t.Commands.Globals:
       K(o2) && (n.globals = M(n.globals, o2), a2 = o2, c2 = true);
       break;
     case t.Commands.On:
-      _(o2) && await I(n, o2, i2);
+      _(o2) && await I(n, o2, r2);
       break;
     case t.Commands.Ready:
       c2 = true;
       break;
     case t.Commands.Run:
-      r2 = await nn(n, o2), c2 = true;
+      i2 = await nn(n, o2), c2 = true;
       break;
     case t.Commands.Session:
       c2 = true;
@@ -2523,21 +2882,21 @@ async function Y(n, e2, o2, i2) {
     case t.Commands.Shutdown:
       await (async function(n2) {
         const e3 = n2.logger;
-        await X(n2.sources, "source", e3), await X(n2.destinations, "destination", e3), await X(n2.transformers, "transformer", e3);
+        await X(n2.sources, "source", e3), await X(n2.destinations, "destination", e3), await X(n2.transformers, "transformer", e3), await X(n2.stores, "store", e3);
       })(n);
       break;
     case t.Commands.User:
       K(o2) && (M(n.user, o2, { shallow: false }), a2 = o2, c2 = true);
   }
-  return c2 && await G(n, e2, void 0, a2), u2 && (r2 = await U(n)), r2 || N({ ok: true });
+  return c2 && await G(n, e2, void 0, a2), u2 && (i2 = await U(n)), i2 || N({ ok: true });
 }
 function Z(n, e2) {
   if (!e2.name) throw new Error("Event name is required");
   const [t2, o2] = e2.name.split(" ");
   if (!t2 || !o2) throw new Error("Event name is invalid");
   ++n.count;
-  const { timestamp: s2 = Date.now(), group: i2 = n.group, count: r2 = n.count } = e2, { name: a2 = `${t2} ${o2}`, data: c2 = {}, context: u2 = {}, globals: f2 = n.globals, custom: l2 = {}, user: d2 = n.user, nested: g2 = [], consent: m2 = n.consent, id: p2 = `${s2}-${i2}-${r2}`, trigger: h2 = "", entity: w2 = t2, action: y2 = o2, timing: b2 = 0, version: v2 = { source: n.version, tagging: n.config.tagging || 0 }, source: k2 = { type: "collector", id: "", previous_id: "" } } = e2;
-  return { name: a2, data: c2, context: u2, globals: f2, custom: l2, user: d2, nested: g2, consent: m2, id: p2, trigger: h2, entity: w2, action: y2, timestamp: s2, timing: b2, group: i2, count: r2, version: v2, source: k2 };
+  const { timestamp: s2 = Date.now(), group: r2 = n.group, count: i2 = n.count } = e2, { name: a2 = `${t2} ${o2}`, data: c2 = {}, context: u2 = {}, globals: f2 = n.globals, custom: l2 = {}, user: g2 = n.user, nested: d2 = [], consent: m2 = n.consent, id: p2 = `${s2}-${r2}-${i2}`, trigger: h2 = "", entity: w2 = t2, action: y2 = o2, timing: b2 = 0, version: v2 = { source: n.version, tagging: n.config.tagging || 0 }, source: k2 = { type: "collector", id: "", previous_id: "" } } = e2;
+  return { name: a2, data: c2, context: u2, globals: f2, custom: l2, user: g2, nested: d2, consent: m2, id: p2, trigger: h2, entity: w2, action: y2, timestamp: s2, timing: b2, group: r2, count: i2, version: v2, source: k2 };
 }
 async function nn(n, e2) {
   n.allowed = true, n.count = 0, n.group = Q(), n.timing = Date.now(), e2 && (e2.consent && (n.consent = M(n.consent, e2.consent)), e2.user && (n.user = M(n.user, e2.user)), e2.globals && (n.globals = M(n.config.globalsStatic || {}, e2.globals)), e2.custom && (n.custom = M(n.custom, e2.custom))), Object.values(n.destinations).forEach((n2) => {
@@ -2547,9 +2906,9 @@ async function nn(n, e2) {
 }
 function rn(n, e2) {
   return sn(async (t2, o2 = {}) => await on(async () => {
-    const s2 = Date.now(), { id: i2, ingest: r2, respond: a2, mapping: c2, preChain: u2 } = o2;
+    const s2 = Date.now(), { id: r2, ingest: i2, respond: a2, mapping: c2, preChain: u2 } = o2;
     let f2 = t2;
-    const l2 = r2 ? Object.freeze(r2) : void 0;
+    const l2 = i2 ? Object.freeze(i2) : void 0;
     if (c2) {
       const e3 = await tn(f2, c2, n);
       if (e3.ignore) return N({ ok: true });
@@ -2563,23 +2922,30 @@ function rn(n, e2) {
       if (null === e3) return N({ ok: true });
       f2 = e3;
     }
-    const d2 = e2(f2), g2 = Z(n, d2), m2 = await U(n, g2, { id: i2, ingest: l2, respond: a2 });
-    if (i2) {
-      n.status.sources[i2] || (n.status.sources[i2] = { count: 0, duration: 0 });
-      const e3 = n.status.sources[i2];
+    const g2 = e2(f2), d2 = Z(n, g2), m2 = await U(n, d2, { id: r2, ingest: l2, respond: a2 });
+    if (r2) {
+      n.status.sources[r2] || (n.status.sources[r2] = { count: 0, duration: 0 });
+      const e3 = n.status.sources[r2];
       e3.count++, e3.lastAt = Date.now(), e3.duration += Date.now() - s2;
     }
     return m2;
   }, () => N({ ok: false }))(), "Push", n.hooks);
 }
 async function un(n) {
-  const e2 = i({ globalsStatic: {}, sessionStatic: {}, tagging: 0, run: true }, n, { merge: false, extend: false }), t2 = { level: n.logger?.level, handler: n.logger?.handler }, o2 = r(t2), s2 = { ...e2.globalsStatic, ...n.globals }, a2 = { allowed: false, config: e2, consent: n.consent || {}, count: 0, custom: n.custom || {}, destinations: {}, transformers: {}, globals: s2, group: "", hooks: {}, logger: o2, on: {}, queue: [], round: 0, session: void 0, status: { startedAt: Date.now(), in: 0, out: 0, failed: 0, sources: {}, destinations: {} }, timing: Date.now(), user: n.user || {}, version: "2.1.0", sources: {}, pending: { sources: {}, destinations: {} }, push: void 0, command: void 0 };
+  const e2 = r({ globalsStatic: {}, sessionStatic: {}, tagging: 0, run: true }, n, { merge: false, extend: false }), t2 = { level: n.logger?.level, handler: n.logger?.handler }, o2 = i(t2), s2 = { ...e2.globalsStatic, ...n.globals }, a2 = { allowed: false, config: e2, consent: n.consent || {}, count: 0, custom: n.custom || {}, destinations: {}, transformers: {}, stores: {}, globals: s2, group: "", hooks: {}, logger: o2, on: {}, queue: [], round: 0, session: void 0, status: { startedAt: Date.now(), in: 0, out: 0, failed: 0, sources: {}, destinations: {} }, timing: Date.now(), user: n.user || {}, version: "2.1.1", sources: {}, pending: { sources: {}, destinations: {} }, push: void 0, command: void 0 };
   return a2.push = rn(a2, (n2) => ({ timing: Math.round((Date.now() - a2.timing) / 10) / 100, source: { type: "collector", id: "", previous_id: "" }, ...n2 })), a2.command = (function(n2, e3) {
     return an(async (t3, o3, s3) => await cn(async () => await e3(n2, t3, o3, s3), () => N({ ok: false }))(), "Command", n2.hooks);
-  })(a2, Y), a2.destinations = await z(a2, n.destinations || {}), a2.transformers = await (async function(n2, e3 = {}) {
+  })(a2, Y), a2.stores = await (async function(n2, e3 = {}) {
+    const t3 = {};
+    for (const [o3, s3] of Object.entries(e3)) {
+      const { code: e4, config: r2 = {}, env: i2 = {} } = s3, a3 = n2.logger.scope("store").scope(o3), c2 = { collector: n2, logger: a3, id: o3, config: r2, env: i2 }, u2 = await e4(c2);
+      t3[o3] = u2;
+    }
+    return t3;
+  })(a2, n.stores || {}), a2.destinations = await z(a2, n.destinations || {}), a2.transformers = await (async function(n2, e3 = {}) {
     const t3 = {};
     for (const [o3, s3] of Object.entries(e3)) {
-      const { code: e4, env: i2 = {} } = s3, { config: r2 } = A(s3, "next"), a3 = n2.logger.scope("transformer").scope(o3), c2 = { collector: n2, logger: a3, id: o3, config: r2, env: i2 }, u2 = await e4(c2);
+      const { code: e4, env: r2 = {} } = s3, { config: i2 } = A(s3, "next"), a3 = n2.logger.scope("transformer").scope(o3), c2 = { collector: n2, logger: a3, id: o3, config: i2, env: r2 }, u2 = await e4(c2);
       t3[o3] = u2;
     }
     return t3;
@@ -2587,7 +2953,7 @@ async function un(n) {
 }
 async function fn(n) {
   n = n || {};
-  const e2 = await un(n), t2 = (o2 = e2, { type: "elb", config: {}, push: async (n2, e3, t3, s3, i3, r3) => {
+  const e2 = await un(n), t2 = (o2 = e2, { type: "elb", config: {}, push: async (n2, e3, t3, s3, r3, i3) => {
     if ("string" == typeof n2 && n2.startsWith("walker ")) {
       const s4 = n2.replace("walker ", "");
       return o2.command(s4, e3, t3);
@@ -2598,14 +2964,14 @@ async function fn(n) {
       if (!n2 || "object" != typeof n2) return N({ ok: false });
       a3 = n2, e3 && "object" == typeof e3 && !Array.isArray(e3) && (a3.data = { ...a3.data || {}, ...e3 });
     }
-    return s3 && "object" == typeof s3 && (a3.context = s3), i3 && Array.isArray(i3) && (a3.nested = i3), r3 && "object" == typeof r3 && (a3.custom = r3), o2.push(a3);
+    return s3 && "object" == typeof s3 && (a3.context = s3), r3 && Array.isArray(r3) && (a3.nested = r3), i3 && "object" == typeof i3 && (a3.custom = i3), o2.push(a3);
   } });
   var o2;
   e2.sources.elb = t2;
   const s2 = await T(e2, n.sources || {});
   Object.assign(e2.sources, s2);
-  const { consent: i2, user: r2, globals: a2, custom: c2 } = n;
-  i2 && await e2.command("consent", i2), r2 && await e2.command("user", r2), a2 && Object.assign(e2.globals, a2), c2 && Object.assign(e2.custom, c2), e2.config.run && await e2.command("run");
+  const { consent: r2, user: i2, globals: a2, custom: c2 } = n;
+  r2 && await e2.command("consent", r2), i2 && await e2.command("user", i2), a2 && Object.assign(e2.globals, a2), c2 && Object.assign(e2.custom, c2), e2.config.run && await e2.command("run");
   let u2 = t2.push;
   const f2 = Object.values(e2.sources).filter((n2) => "elb" !== n2.type), l2 = f2.find((n2) => n2.config.primary);
   return l2 ? u2 = l2.push : f2.length > 0 && (u2 = f2[0].push), { collector: e2, elb: u2 };
@@ -2617,58 +2983,58 @@ function ln(n) {
   for (const [t2, o2] of Object.entries(n)) e2[t2] = "function" == typeof o2 ? o2 : ln(o2);
   return e2;
 }
-function dn(n) {
+function gn(n) {
   const e2 = [], { simulation: t2, ...o2 } = n, s2 = ln(o2);
   for (const n2 of t2) {
     const t3 = n2.startsWith("call:") ? n2.slice(5) : n2, o3 = t3.split(".");
-    let i2 = s2;
-    for (let n3 = 0; n3 < o3.length - 1 && null != i2[o3[n3]]; n3++) i2 = i2[o3[n3]];
-    const r2 = o3[o3.length - 1];
-    if (null == i2 || !(r2 in i2)) continue;
-    const a2 = i2[r2];
-    "function" == typeof a2 && (i2[r2] = function(...n3) {
+    let r2 = s2;
+    for (let n3 = 0; n3 < o3.length - 1 && null != r2[o3[n3]]; n3++) r2 = r2[o3[n3]];
+    const i2 = o3[o3.length - 1];
+    if (null == r2 || !(i2 in r2)) continue;
+    const a2 = r2[i2];
+    "function" == typeof a2 && (r2[i2] = function(...n3) {
       return e2.push({ fn: t3, args: n3, ts: Date.now() }), a2.apply(this, n3);
     });
   }
   return { wrappedEnv: s2, calls: e2 };
 }
-async function gn(n) {
+async function dn(n) {
   const e2 = Date.now();
   try {
     switch (n.step) {
       case "transformer":
         return await (async function(n2, e3) {
-          const { code: t2, config: o2 = {}, event: s2 } = n2, { collector: i2 } = await fn({ transformers: { sim: { code: t2, config: o2 } } }), r2 = i2.transformers?.sim;
-          if (!r2) throw new Error("Transformer failed to initialize");
-          const a2 = await r2.push(s2, { collector: i2, logger: i2.logger.scope("transformer").scope("sim"), id: "sim", config: r2.config, env: r2.config?.env || {} });
+          const { code: t2, config: o2 = {}, event: s2 } = n2, { collector: r2 } = await fn({ transformers: { sim: { code: t2, config: o2 } } }), i2 = r2.transformers?.sim;
+          if (!i2) throw new Error("Transformer failed to initialize");
+          const a2 = await i2.push(s2, { collector: r2, logger: r2.logger.scope("transformer").scope("sim"), id: "sim", config: i2.config, env: i2.config?.env || {} });
           let c2;
           c2 = false === a2 ? [] : null == a2 ? [s2] : [a2.event || s2];
           return { step: "transformer", name: n2.name, events: c2, calls: [], duration: Date.now() - e3 };
         })(n, e2);
       case "source":
         return await (async function(n2, e3) {
-          const { code: t2, config: o2 = {}, setup: s2, input: i2, env: r2, consent: a2 } = n2, c2 = { functional: true, marketing: true, analytics: true };
+          const { code: t2, config: o2 = {}, setup: s2, input: r2, env: i2, consent: a2 } = n2, c2 = { functional: true, marketing: true, analytics: true };
           let u2;
           if (s2) {
-            const n3 = s2(i2, r2);
+            const n3 = s2(r2, i2);
             "function" == typeof n3 && (u2 = n3);
           }
-          const f2 = [], { collector: l2 } = await fn({ consent: a2 || c2, sources: { sim: { code: t2, config: o2, env: r2, next: "spy" } }, transformers: { spy: { code: () => ({ type: "spy", config: {}, push: (n3) => (f2.push(JSON.parse(JSON.stringify(n3))), { event: n3 }) }) } } });
+          const f2 = [], { collector: l2 } = await fn({ consent: a2 || c2, sources: { sim: { code: t2, config: o2, env: i2, next: "spy" } }, transformers: { spy: { code: () => ({ type: "spy", config: {}, push: (n3) => (f2.push(JSON.parse(JSON.stringify(n3))), { event: n3 }) }) } } });
           u2 && u2();
           return { step: "source", name: n2.name, events: f2, calls: [], duration: Date.now() - e3 };
         })(n, e2);
       case "destination":
         return await (async function(n2, e3) {
-          const { code: t2, config: o2 = {}, event: s2, consent: i2, env: r2, track: a2 } = n2, c2 = { functional: true, marketing: true, analytics: true };
-          let u2 = [], f2 = r2;
-          if (r2 && a2 && a2.length > 0) {
-            const n3 = dn({ ...r2, simulation: a2 });
+          const { code: t2, config: o2 = {}, event: s2, consent: r2, env: i2, track: a2 } = n2, c2 = { functional: true, marketing: true, analytics: true };
+          let u2 = [], f2 = i2;
+          if (i2 && a2 && a2.length > 0) {
+            const n3 = gn({ ...i2, simulation: a2 });
             f2 = n3.wrappedEnv, u2 = n3.calls;
           }
           const l2 = { ...o2 };
           f2 && (l2.env = f2);
-          const { collector: d2 } = await fn({ consent: i2 || c2, destinations: { sim: { code: t2, config: l2 } } });
-          return await d2.push(s2), { step: "destination", name: n2.name, events: [], calls: u2, duration: Date.now() - e3 };
+          const { collector: g2 } = await fn({ consent: r2 || c2, destinations: { sim: { code: t2, config: l2 } } });
+          return await g2.push(s2), { step: "destination", name: n2.name, events: [], calls: u2, duration: Date.now() - e3 };
         })(n, e2);
     }
   } catch (t2) {
@@ -2678,6 +3044,9 @@ async function gn(n) {
 
 // src/commands/simulate/simulator.ts
 init_cli_logger();
+init_core();
+init_config();
+init_tmp();
 
 // src/commands/simulate/env-loader.ts
 async function loadDestinationEnvs(destinations) {
@@ -2708,21 +3077,6 @@ async function loadDestinationEnvs(destinations) {
 }
 
 // src/commands/simulate/simulator.ts
-function createCollectorLoggerConfigInline(logger2, verbose) {
-  return {
-    level: verbose ? Level2.DEBUG : Level2.ERROR,
-    handler: (level, message, context, scope) => {
-      const scopePath = scope.length > 0 ? `[${scope.join(":")}] ` : "";
-      const hasContext = Object.keys(context).length > 0;
-      const contextStr = hasContext ? ` ${JSON.stringify(context)}` : "";
-      if (level === Level2.ERROR) {
-        logger2.error(`${scopePath}${message}${contextStr}`);
-      } else {
-        logger2.debug(`${scopePath}${message}${contextStr}`);
-      }
-    }
-  };
-}
 function callsToUsage(destName, calls) {
   if (!calls.length) return {};
   return {
@@ -2735,17 +3089,16 @@ function callsToUsage(destName, calls) {
   };
 }
 async function simulateCore(inputPath, event, options = {}) {
-  const logger2 = createCLILogger({
+  const logger = createCLILogger({
     verbose: options.verbose || false,
     silent: options.silent || false,
     json: options.json || false
   });
   try {
-    logger2.debug(`Simulating event: ${JSON.stringify(event)}`);
+    logger.debug(`Simulating event: ${JSON.stringify(event)}`);
     const result = await executeSimulation(event, inputPath, options.platform, {
       flow: options.flow,
       step: options.step,
-      logger: logger2,
       verbose: options.verbose
     });
     return result;
@@ -2800,9 +3153,8 @@ function formatSimulationResult(result, options = {}) {
 async function executeSimulation(event, inputPath, platformOverride, options = {}) {
   const startTime = Date.now();
   const tempDir = getTmpPath();
-  const collectorLoggerConfig = options.logger ? createCollectorLoggerConfigInline(options.logger, options.verbose) : void 0;
   try {
-    await fs11.ensureDir(tempDir);
+    await fs12.ensureDir(tempDir);
     const detected = await detectInput(inputPath, platformOverride);
     if (!isObject(event) || !("name" in event) || typeof event.name !== "string") {
       throw new Error(
@@ -2812,7 +3164,7 @@ async function executeSimulation(event, inputPath, platformOverride, options = {
     const typedEvent = event;
     if (detected.type !== "config") {
       throw new Error(
-        `Input "${inputPath}" is not valid JSON config. simulate only accepts Flow.Setup config files.`
+        `Input "${inputPath}" is not valid JSON config. simulate only accepts Flow.Config config files.`
       );
     }
     return await executeConfigSimulation(
@@ -2821,7 +3173,6 @@ async function executeSimulation(event, inputPath, platformOverride, options = {
       typedEvent,
       tempDir,
       startTime,
-      collectorLoggerConfig,
       options.flow,
       options.step
     );
@@ -2834,7 +3185,7 @@ async function executeSimulation(event, inputPath, platformOverride, options = {
     };
   } finally {
     if (tempDir) {
-      await fs11.remove(tempDir).catch(() => {
+      await fs12.remove(tempDir).catch(() => {
       });
     }
   }
@@ -2863,13 +3214,13 @@ function parseStepTarget(stepTarget, flowConfig) {
   }
   throw new Error("No destination found in flow config");
 }
-async function executeConfigSimulation(_content, configPath, typedEvent, tempDir, startTime, loggerConfig2, flowName, stepTarget) {
-  const { flowConfig } = await loadFlowConfig(configPath, {
+async function executeConfigSimulation(_content, configPath, typedEvent, tempDir, startTime, flowName, stepTarget) {
+  const { flowSettings } = await loadFlowConfig(configPath, {
     flowName
   });
   const step = parseStepTarget(
     stepTarget,
-    flowConfig
+    flowSettings
   );
   if (step.type === "destination") {
     const packageName = step.config.package;
@@ -2878,10 +3229,10 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
     }
     const destModule = await import(packageName);
     const code = destModule.default || Object.values(destModule)[0];
-    const destinations = flowConfig.destinations;
+    const destinations = flowSettings.destinations;
     const envs = await loadDestinationEnvs(destinations || {});
     const destEnv = envs[step.name];
-    const result = await gn({
+    const result = await dn({
       step: "destination",
       name: step.name,
       code,
@@ -2906,7 +3257,7 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
     }
     const mod = await import(packageName);
     const code = mod.default || Object.values(mod)[0];
-    const result = await gn({
+    const result = await dn({
       step: "transformer",
       name: step.name,
       code,
@@ -2928,6 +3279,7 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
 
 // src/commands/simulate/source-simulator.ts
 import { JSDOM, VirtualConsole } from "jsdom";
+init_core();
 async function loadSourcePackage(packageName) {
   const mainModule = await import(packageName);
   const code = mainModule.default || Object.values(mainModule)[0];
@@ -2978,7 +3330,7 @@ async function simulateSourceCLI(flowConfig, setupInput, options) {
       document: dom.window.document,
       localStorage: dom.window.localStorage
     };
-    const result = await gn({
+    const result = await dn({
       step: "source",
       name: options.sourceStep,
       code,
@@ -3005,6 +3357,9 @@ async function simulateSourceCLI(flowConfig, setupInput, options) {
 
 // src/commands/simulate/index.ts
 init_cli_logger();
+init_core();
+init_config();
+init_validators();
 
 // src/commands/simulate/example-loader.ts
 function findExample(config, exampleName, stepTarget) {
@@ -3110,135 +3465,39 @@ ${actualStr}`
 
 // src/commands/simulate/index.ts
 async function simulateCommand(options) {
-  const logger2 = createCLILogger({ ...options, stderr: true });
+  const logger = createCLILogger({ ...options, stderr: true });
   const startTime = Date.now();
   try {
     let config;
     if (isStdinPiped() && !options.config) {
       const stdinContent = await readStdin();
-      const fs14 = await import("fs-extra");
-      const path14 = await import("path");
+      const fs15 = await import("fs-extra");
+      const path15 = await import("path");
       const tmpPath = getTmpPath(void 0, "stdin-simulate.json");
-      await fs14.default.ensureDir(path14.default.dirname(tmpPath));
-      await fs14.default.writeFile(tmpPath, stdinContent, "utf-8");
+      await fs15.default.ensureDir(path15.default.dirname(tmpPath));
+      await fs15.default.writeFile(tmpPath, stdinContent, "utf-8");
       config = tmpPath;
     } else {
       config = options.config || "bundle.config.json";
     }
-    let event;
-    let exampleContext;
-    if (options.example) {
-      const rawConfig = await loadJsonConfig(config);
-      const setup = validateFlowSetup(rawConfig);
-      const flowNames = Object.keys(setup.flows);
-      let flowName = options.flow;
-      if (!flowName) {
-        if (flowNames.length === 1) {
-          flowName = flowNames[0];
-        } else {
-          throw new Error(
-            `Multiple flows found. Use --flow to specify which flow contains the example.
-Available flows: ${flowNames.join(", ")}`
-          );
-        }
-      }
-      const flowConfig = setup.flows[flowName];
-      if (!flowConfig) {
-        throw new Error(
-          `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
-        );
-      }
-      const found = findExample(flowConfig, options.example, options.step);
-      if (found.example.in === void 0) {
-        throw new Error(
-          `Example "${options.example}" in ${found.stepType}.${found.stepName} has no "in" value`
-        );
-      }
-      event = found.example.in;
-      exampleContext = {
-        stepType: found.stepType,
-        stepName: found.stepName,
-        expected: found.example.out
-      };
-    } else {
-      event = await loadJsonFromSource(options.event, {
-        name: "event"
-      });
-    }
-    const isSourceSimulation = exampleContext?.stepType === "source" || options.step?.startsWith("source.");
-    let result;
-    if (isSourceSimulation) {
-      const rawConfig = await loadJsonConfig(config);
-      const setup = validateFlowSetup(rawConfig);
-      const flowNames = Object.keys(setup.flows);
-      const flowName = options.flow || (flowNames.length === 1 ? flowNames[0] : void 0);
-      if (!flowName) {
-        throw new Error(
-          `Multiple flows found. Use --flow to specify which flow.
-Available: ${flowNames.join(", ")}`
-        );
-      }
-      const flowConfig = setup.flows[flowName];
-      if (!flowConfig) {
-        throw new Error(
-          `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
-        );
-      }
-      const sourceStep = exampleContext?.stepName || options.step.substring("source.".length);
-      result = await simulateSourceCLI(
-        flowConfig,
-        event,
-        {
-          flow: options.flow,
-          sourceStep,
-          json: options.json,
-          verbose: options.verbose,
-          silent: options.silent
-        }
-      );
-    } else {
-      const stepTarget = exampleContext ? `${exampleContext.stepType}.${exampleContext.stepName}` : options.step;
-      result = await simulateCore(config, event, {
-        flow: options.flow,
-        json: options.json,
-        verbose: options.verbose,
-        silent: options.silent,
-        step: stepTarget
-      });
-    }
-    let exampleMatch;
-    if (exampleContext && result.success) {
-      const stepKey = `${exampleContext.stepType}.${exampleContext.stepName}`;
-      if (exampleContext.expected === false) {
-        const calls = result.usage?.[exampleContext.stepName];
-        const wasFiltered = !calls || calls.length === 0;
-        exampleMatch = {
-          name: options.example,
-          step: stepKey,
-          expected: false,
-          actual: wasFiltered ? false : calls,
-          match: wasFiltered,
-          diff: wasFiltered ? void 0 : `Expected event to be filtered, but ${calls.length} API call(s) were made`
-        };
-      } else if (exampleContext.expected !== void 0) {
-        const actual = result.usage?.[exampleContext.stepName] ?? [];
-        exampleMatch = {
-          name: options.example,
-          step: stepKey,
-          ...compareOutput(exampleContext.expected, actual)
-        };
-      }
-    }
+    const result = await simulate(config, options.event, {
+      flow: options.flow,
+      json: options.json,
+      verbose: options.verbose,
+      silent: options.silent,
+      platform: options.platform,
+      example: options.example,
+      step: options.step
+    });
     const resultWithDuration = {
       ...result,
-      duration: (Date.now() - startTime) / 1e3,
-      ...exampleMatch ? { exampleMatch } : {}
+      duration: (Date.now() - startTime) / 1e3
     };
     const formatted = formatSimulationResult(resultWithDuration, {
       json: options.json
     });
     await writeResult(formatted + "\n", { output: options.output });
-    const exitCode = !result.success || exampleMatch && !exampleMatch.match ? 1 : 0;
+    const exitCode = !result.success || result.exampleMatch && !result.exampleMatch.match ? 1 : 0;
     process.exit(exitCode);
   } catch (error) {
     const errorMessage = getErrorMessage(error);
@@ -3254,7 +3513,7 @@ Available: ${flowNames.join(", ")}`
       );
       await writeResult(errorOutput + "\n", { output: options.output });
     } else {
-      logger2.error(`Error: ${errorMessage}`);
+      logger.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
   }
@@ -3266,10 +3525,13 @@ async function simulate(configOrPath, event, options = {}) {
     );
   }
   let resolvedEvent = event;
+  if (typeof event === "string") {
+    resolvedEvent = await loadJsonFromSource(event, { name: "event" });
+  }
   let exampleContext;
   if (options.example) {
     const rawConfig = await loadJsonConfig(configOrPath);
-    const setup = validateFlowSetup(rawConfig);
+    const setup = validateFlowConfig(rawConfig);
     const flowNames = Object.keys(setup.flows);
     let flowName = options.flow;
     if (!flowName) {
@@ -3282,13 +3544,13 @@ Available flows: ${flowNames.join(", ")}`
         );
       }
     }
-    const flowConfig = setup.flows[flowName];
-    if (!flowConfig) {
+    const flowSettings = setup.flows[flowName];
+    if (!flowSettings) {
       throw new Error(
         `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
       );
     }
-    const found = findExample(flowConfig, options.example, options.step);
+    const found = findExample(flowSettings, options.example, options.step);
     if (found.example.in === void 0) {
       throw new Error(
         `Example "${options.example}" in ${found.stepType}.${found.stepName} has no "in" value`
@@ -3301,12 +3563,48 @@ Available flows: ${flowNames.join(", ")}`
       expected: found.example.out
     };
   }
-  const result = await simulateCore(configOrPath, resolvedEvent, {
-    json: options.json ?? false,
-    verbose: options.verbose ?? false,
-    flow: options.flow,
-    platform: options.platform
-  });
+  const isSourceSimulation = exampleContext?.stepType === "source" || options.step?.startsWith("source.");
+  let result;
+  if (isSourceSimulation) {
+    const rawConfig = await loadJsonConfig(configOrPath);
+    const setup = validateFlowConfig(rawConfig);
+    const flowNames = Object.keys(setup.flows);
+    const flowName = options.flow || (flowNames.length === 1 ? flowNames[0] : void 0);
+    if (!flowName) {
+      throw new Error(
+        `Multiple flows found. Use --flow to specify which flow.
+Available: ${flowNames.join(", ")}`
+      );
+    }
+    const flowSettings = setup.flows[flowName];
+    if (!flowSettings) {
+      throw new Error(
+        `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
+      );
+    }
+    const sourceStep = exampleContext?.stepName || options.step.substring("source.".length);
+    result = await simulateSourceCLI(
+      flowSettings,
+      resolvedEvent,
+      {
+        flow: options.flow,
+        sourceStep,
+        json: options.json,
+        verbose: options.verbose,
+        silent: options.silent
+      }
+    );
+  } else {
+    const stepTarget = exampleContext ? `${exampleContext.stepType}.${exampleContext.stepName}` : options.step;
+    result = await simulateCore(configOrPath, resolvedEvent, {
+      json: options.json ?? false,
+      verbose: options.verbose ?? false,
+      silent: options.silent ?? false,
+      flow: options.flow,
+      platform: options.platform,
+      step: stepTarget
+    });
+  }
   if (exampleContext && result.success) {
     const stepKey = `${exampleContext.stepType}.${exampleContext.stepName}`;
     if (exampleContext.expected === false) {
@@ -3334,40 +3632,25 @@ Available flows: ${flowNames.join(", ")}`
 
 // src/commands/push/index.ts
 init_cli_logger();
-import path11 from "path";
+init_core();
+init_tmp();
+init_config();
+init_bundler();
+import path12 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 import { getPlatform as getPlatform3 } from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
-import { Level as Level3 } from "@walkeros/core";
-function createCollectorLoggerConfig(logger2, verbose) {
-  return {
-    level: verbose ? Level3.DEBUG : Level3.ERROR,
-    handler: (level, message, context, scope) => {
-      const scopePath = scope.length > 0 ? `[${scope.join(":")}] ` : "";
-      const hasContext = Object.keys(context).length > 0;
-      const contextStr = hasContext ? ` ${JSON.stringify(context)}` : "";
-      if (level === Level3.ERROR) {
-        logger2.error(`${scopePath}${message}${contextStr}`);
-      } else {
-        logger2.debug(`${scopePath}${message}${contextStr}`);
-      }
-    }
-  };
-}
+import { Level as Level2 } from "@walkeros/core";
 async function pushCore(inputPath, event, options = {}) {
-  const logger2 = createCLILogger({
+  const logger = createCLILogger({
     silent: options.silent,
     verbose: options.verbose
   });
   const startTime = Date.now();
   let tempDir;
   try {
-    let loadedEvent = event;
-    if (typeof event === "string") {
-      loadedEvent = await loadJsonFromSource(event, { name: "event" });
-    }
-    const eventResult = schemas2.PartialEventSchema.safeParse(loadedEvent);
+    const eventResult = schemas2.PartialEventSchema.safeParse(event);
     if (!eventResult.success) {
       const errors = eventResult.error.issues.map((issue) => `${String(issue.path.join("."))}: ${issue.message}`).join(", ");
       throw new Error(`Invalid event: ${errors}`);
@@ -3381,11 +3664,11 @@ async function pushCore(inputPath, event, options = {}) {
       data: parsedEvent.data || {}
     };
     if (!validatedEvent.name.includes(" ")) {
-      logger2.info(
+      logger.info(
         `Warning: Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
       );
     }
-    logger2.debug("Detecting input type");
+    logger.debug("Detecting input type");
     const detected = await detectInput(
       inputPath,
       options.platform
@@ -3399,7 +3682,7 @@ async function pushCore(inputPath, event, options = {}) {
           verbose: options.verbose
         },
         validatedEvent,
-        logger2,
+        logger,
         (dir) => {
           tempDir = dir;
         }
@@ -3409,11 +3692,11 @@ async function pushCore(inputPath, event, options = {}) {
         detected.content,
         detected.platform,
         validatedEvent,
-        logger2,
+        logger,
         (dir) => {
           tempDir = dir;
         },
-        { logger: createCollectorLoggerConfig(logger2, options.verbose) }
+        { logger: { level: options.verbose ? Level2.DEBUG : Level2.ERROR } }
       );
     }
     return result;
@@ -3425,27 +3708,26 @@ async function pushCore(inputPath, event, options = {}) {
     };
   } finally {
     if (tempDir) {
-      await fs12.remove(tempDir).catch(() => {
+      await fs13.remove(tempDir).catch(() => {
       });
     }
   }
 }
 async function pushCommand(options) {
-  const logger2 = createCLILogger({ ...options, stderr: true });
+  const logger = createCLILogger({ ...options, stderr: true });
   const startTime = Date.now();
   try {
     let config;
     if (isStdinPiped() && !options.config) {
       const stdinContent = await readStdin();
       const tmpPath = getTmpPath(void 0, "stdin-push.json");
-      await fs12.ensureDir(path11.dirname(tmpPath));
-      await fs12.writeFile(tmpPath, stdinContent, "utf-8");
+      await fs13.ensureDir(path12.dirname(tmpPath));
+      await fs13.writeFile(tmpPath, stdinContent, "utf-8");
       config = tmpPath;
     } else {
       config = options.config || "bundle.config.json";
     }
-    const event = await loadJsonFromSource(options.event, { name: "event" });
-    const result = await pushCore(config, event, {
+    const result = await push(config, options.event, {
       flow: options.flow,
       json: options.json,
       verbose: options.verbose,
@@ -3496,7 +3778,7 @@ async function pushCommand(options) {
       );
       await writeResult(errorOutput + "\n", { output: options.output });
     } else {
-      logger2.error(`Error: ${errorMessage}`);
+      logger.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
   }
@@ -3507,29 +3789,34 @@ async function push(configOrPath, event, options = {}) {
       "push() currently only supports config file paths. Config object support will be added in a future version. Please provide a path to a configuration file."
     );
   }
-  return await pushCore(configOrPath, event, {
+  let resolvedEvent = event;
+  if (typeof event === "string") {
+    resolvedEvent = await loadJsonFromSource(event, { name: "event" });
+  }
+  return await pushCore(configOrPath, resolvedEvent, {
     json: options.json ?? false,
     verbose: options.verbose ?? false,
+    silent: options.silent ?? false,
     flow: options.flow,
     platform: options.platform
   });
 }
-async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
-  logger2.debug("Loading flow configuration");
-  const { flowConfig, buildOptions } = await loadFlowConfig(options.config, {
+async function executeConfigPush(options, validatedEvent, logger, setTempDir) {
+  logger.debug("Loading flow configuration");
+  const { flowSettings, buildOptions } = await loadFlowConfig(options.config, {
     flowName: options.flow,
-    logger: logger2
+    logger
   });
-  const platform = getPlatform3(flowConfig);
-  logger2.debug("Bundling flow configuration");
+  const platform = getPlatform3(flowSettings);
+  logger.debug("Bundling flow configuration");
   const configDir = buildOptions.configDir || process.cwd();
   const tempDir = getTmpPath(
     void 0,
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
-  await fs12.ensureDir(tempDir);
-  const tempPath = path11.join(
+  await fs13.ensureDir(tempDir);
+  const tempPath = path12.join(
     tempDir,
     `bundle.${platform === "web" ? "js" : "mjs"}`
   );
@@ -3543,42 +3830,42 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
       windowElb: "elb"
     }
   };
-  await bundleCore(flowConfig, pushBuildOptions, logger2, false);
-  logger2.debug(`Bundle created: ${tempPath}`);
+  await bundleCore(flowSettings, pushBuildOptions, logger, false);
+  logger.debug(`Bundle created: ${tempPath}`);
   if (platform === "web") {
-    logger2.debug("Executing in web environment (JSDOM)");
-    return executeWebPush(tempPath, validatedEvent, logger2);
+    logger.debug("Executing in web environment (JSDOM)");
+    return executeWebPush(tempPath, validatedEvent, logger);
   } else if (platform === "server") {
-    logger2.debug("Executing in server environment (Node.js)");
-    return executeServerPush(tempPath, validatedEvent, logger2, 6e4, {
-      logger: createCollectorLoggerConfig(logger2, options.verbose)
+    logger.debug("Executing in server environment (Node.js)");
+    return executeServerPush(tempPath, validatedEvent, logger, 6e4, {
+      logger: { level: options.verbose ? Level2.DEBUG : Level2.ERROR }
     });
   } else {
     throw new Error(`Unsupported platform: ${platform}`);
   }
 }
-async function executeBundlePush(bundleContent, platform, validatedEvent, logger2, setTempDir, context = {}) {
+async function executeBundlePush(bundleContent, platform, validatedEvent, logger, setTempDir, context = {}) {
   const tempDir = getTmpPath(
     void 0,
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
-  await fs12.ensureDir(tempDir);
-  const tempPath = path11.join(
+  await fs13.ensureDir(tempDir);
+  const tempPath = path12.join(
     tempDir,
     `bundle.${platform === "server" ? "mjs" : "js"}`
   );
-  await fs12.writeFile(tempPath, bundleContent, "utf8");
-  logger2.debug(`Bundle written to: ${tempPath}`);
+  await fs13.writeFile(tempPath, bundleContent, "utf8");
+  logger.debug(`Bundle written to: ${tempPath}`);
   if (platform === "web") {
-    logger2.debug("Executing in web environment (JSDOM)");
-    return executeWebPush(tempPath, validatedEvent, logger2);
+    logger.debug("Executing in web environment (JSDOM)");
+    return executeWebPush(tempPath, validatedEvent, logger);
   } else {
-    logger2.debug("Executing in server environment (Node.js)");
-    return executeServerPush(tempPath, validatedEvent, logger2, 6e4, context);
+    logger.debug("Executing in server environment (Node.js)");
+    return executeServerPush(tempPath, validatedEvent, logger, 6e4, context);
   }
 }
-async function executeWebPush(bundlePath, event, logger2) {
+async function executeWebPush(bundlePath, event, logger) {
   const startTime = Date.now();
   try {
     const virtualConsole = new VirtualConsole2();
@@ -3589,10 +3876,10 @@ async function executeWebPush(bundlePath, event, logger2) {
       virtualConsole
     });
     const { window } = dom;
-    logger2.debug("Loading bundle...");
-    const bundleCode = await fs12.readFile(bundlePath, "utf8");
+    logger.debug("Loading bundle...");
+    const bundleCode = await fs13.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
-    logger2.debug("Waiting for collector...");
+    logger.debug("Waiting for collector...");
     await waitForWindowProperty(
       window,
       "collector",
@@ -3600,7 +3887,7 @@ async function executeWebPush(bundlePath, event, logger2) {
     );
     const windowObj = window;
     const collector = windowObj.collector;
-    logger2.info(`Pushing event: ${event.name}`);
+    logger.info(`Pushing event: ${event.name}`);
     const elbResult = await collector.push({
       name: event.name,
       data: event.data
@@ -3618,7 +3905,7 @@ async function executeWebPush(bundlePath, event, logger2) {
     };
   }
 }
-async function executeServerPush(bundlePath, event, logger2, timeout = 6e4, context = {}) {
+async function executeServerPush(bundlePath, event, logger, timeout = 6e4, context = {}) {
   const startTime = Date.now();
   let timer;
   try {
@@ -3629,12 +3916,12 @@ async function executeServerPush(bundlePath, event, logger2, timeout = 6e4, cont
       );
     });
     const executePromise = (async () => {
-      logger2.debug("Importing bundle...");
+      logger.debug("Importing bundle...");
       const flowModule = await import(bundlePath);
       if (!flowModule.default || typeof flowModule.default !== "function") {
         throw new Error("Bundle does not export default factory function");
       }
-      logger2.debug("Calling factory function...");
+      logger.debug("Calling factory function...");
       const result = await flowModule.default(context);
       if (!result || !result.collector || typeof result.collector.push !== "function") {
         throw new Error(
@@ -3642,7 +3929,7 @@ async function executeServerPush(bundlePath, event, logger2, timeout = 6e4, cont
         );
       }
       const { collector } = result;
-      logger2.info(`Pushing event: ${event.name}`);
+      logger.info(`Pushing event: ${event.name}`);
       const elbResult = await collector.push({
         name: event.name,
         data: event.data
@@ -3685,106 +3972,110 @@ function waitForWindowProperty(window, prop, timeout = 5e3) {
 }
 
 // src/commands/run/index.ts
-init_cli_logger();
-import path13 from "path";
+init_cli_logger();
+init_core();
+init_config_file();
+init_auth();
+import path14 from "path";
+import { createRequire } from "module";
+import { writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+
+// src/runtime/resolve-bundle.ts
+init_stdin();
+import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "fs";
+var TEMP_BUNDLE_PATH = "/tmp/walkeros-bundle.mjs";
+function isUrl2(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+async function fetchBundle(url) {
+  const response = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch bundle from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const content = await response.text();
+  if (!content.trim()) {
+    throw new Error(`Bundle fetched from ${url} is empty`);
+  }
+  writeFileSync2(TEMP_BUNDLE_PATH, content, "utf-8");
+  return TEMP_BUNDLE_PATH;
+}
+async function readBundleFromStdin() {
+  const content = await readStdin();
+  writeFileSync2(TEMP_BUNDLE_PATH, content, "utf-8");
+  return TEMP_BUNDLE_PATH;
+}
+async function resolveBundle(bundleEnv) {
+  if (!isUrl2(bundleEnv) && existsSync3(bundleEnv)) {
+    return { path: bundleEnv, source: "file" };
+  }
+  if (isStdinPiped()) {
+    const path15 = await readBundleFromStdin();
+    return { path: path15, source: "stdin" };
+  }
+  if (isUrl2(bundleEnv)) {
+    const path15 = await fetchBundle(bundleEnv);
+    return { path: path15, source: "url" };
+  }
+  return { path: bundleEnv, source: "file" };
+}
+
+// src/runtime/config-fetcher.ts
+async function fetchConfig(options) {
+  const url = `${options.appUrl}/api/projects/${options.projectId}/flows/${options.flowId}`;
+  const headers = {
+    Authorization: `Bearer ${options.token}`
+  };
+  if (options.lastEtag) {
+    headers["If-None-Match"] = options.lastEtag;
+  }
+  const response = await fetch(url, {
+    headers,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (response.status === 304) {
+    return { changed: false };
+  }
+  if (!response.ok) {
+    if (response.status === 401 || response.status === 403) {
+      throw new Error(
+        `Config fetch failed (${response.status}): token may have expired \u2014 redeploy to rotate`
+      );
+    }
+    throw new Error(
+      `Config fetch failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const etag = response.headers.get("etag") || "";
+  const version = etag.replace(/"/g, "");
+  return {
+    content: data.config,
+    version,
+    etag,
+    changed: true
+  };
+}
+
+// src/commands/run/index.ts
+init_cache();
 
 // src/commands/run/validators.ts
-import { existsSync as existsSync3 } from "fs";
+init_asset_resolver();
+import { existsSync as existsSync5 } from "fs";
 
 // src/schemas/primitives.ts
 import { z as z2 } from "@walkeros/core/dev";
 var PortSchema = z2.number().int("Port must be an integer").min(1, "Port must be at least 1").max(65535, "Port must be at most 65535").describe("HTTP server port number");
 var FilePathSchema = z2.string().min(1, "File path cannot be empty").describe("Path to configuration file");
 
-// src/schemas/run.ts
-import { z as z3 } from "@walkeros/core/dev";
-var RunOptionsSchema = z3.object({
-  flow: FilePathSchema,
-  port: PortSchema.default(8080),
-  flowName: z3.string().optional().describe("Specific flow name to run")
-});
-
-// src/schemas/validate.ts
-import { z as z4 } from "@walkeros/core/dev";
-var ValidationTypeSchema = z4.enum(["contract", "event", "flow", "mapping"]).describe('Validation type: "event", "flow", "mapping", or "contract"');
-var ValidateOptionsSchema = z4.object({
-  flow: z4.string().optional().describe("Flow name for multi-flow configs"),
-  path: z4.string().optional().describe(
-    'Entry path for package schema validation (e.g., "destinations.snowplow", "sources.browser")'
-  )
-});
-var ValidateInputShape = {
-  type: ValidationTypeSchema,
-  input: z4.string().min(1).describe("JSON string, file path, or URL to validate"),
-  flow: z4.string().optional().describe("Flow name for multi-flow configs"),
-  path: z4.string().optional().describe(
-    'Entry path for package schema validation (e.g., "destinations.snowplow"). When provided, validates the entry against its package JSON Schema instead of using --type.'
-  )
-};
-var ValidateInputSchema = z4.object(ValidateInputShape);
-
-// src/schemas/bundle.ts
-import { z as z5 } from "@walkeros/core/dev";
-var BundleOptionsSchema = z5.object({
-  silent: z5.boolean().optional().describe("Suppress all output"),
-  verbose: z5.boolean().optional().describe("Enable verbose logging"),
-  stats: z5.boolean().optional().default(true).describe("Return bundle statistics"),
-  cache: z5.boolean().optional().default(true).describe("Enable package caching"),
-  flowName: z5.string().optional().describe("Flow name for multi-flow configs")
-});
-var BundleInputShape = {
-  configPath: FilePathSchema.describe(
-    "Path to flow configuration file (JSON or JavaScript)"
-  ),
-  flow: z5.string().optional().describe("Flow name for multi-flow configs"),
-  stats: z5.boolean().optional().default(true).describe("Return bundle statistics"),
-  output: z5.string().optional().describe("Output file path (defaults to config-defined)")
-};
-var BundleInputSchema = z5.object(BundleInputShape);
-
-// src/schemas/simulate.ts
-import { z as z6 } from "@walkeros/core/dev";
-var PlatformSchema = z6.enum(["web", "server"]).describe("Platform type for event processing");
-var SimulateOptionsSchema = z6.object({
-  silent: z6.boolean().optional().describe("Suppress all output"),
-  verbose: z6.boolean().optional().describe("Enable verbose logging"),
-  json: z6.boolean().optional().describe("Format output as JSON")
-});
-var SimulateInputShape = {
-  configPath: FilePathSchema.describe("Path to flow configuration file"),
-  event: z6.string().min(1).optional().describe(
-    "Event as JSON string, file path, or URL. Optional when example is provided."
-  ),
-  flow: z6.string().optional().describe("Flow name for multi-flow configs"),
-  platform: PlatformSchema.optional().describe("Override platform detection"),
-  example: z6.string().optional().describe(
-    'Name of a step example to use as event input (uses its "in" value)'
-  ),
-  step: z6.string().optional().describe(
-    'Step target in type.name format (e.g. "destination.gtag") to narrow example lookup'
-  )
-};
-var SimulateInputSchema = z6.object(SimulateInputShape);
-
-// src/schemas/push.ts
-import { z as z7 } from "@walkeros/core/dev";
-var PushOptionsSchema = z7.object({
-  silent: z7.boolean().optional().describe("Suppress all output"),
-  verbose: z7.boolean().optional().describe("Enable verbose logging"),
-  json: z7.boolean().optional().describe("Format output as JSON")
-});
-var PushInputShape = {
-  configPath: FilePathSchema.describe("Path to flow configuration file"),
-  event: z7.string().min(1).describe("Event as JSON string, file path, or URL"),
-  flow: z7.string().optional().describe("Flow name for multi-flow configs"),
-  platform: PlatformSchema.optional().describe("Override platform detection")
-};
-var PushInputSchema = z7.object(PushInputShape);
-
 // src/commands/run/validators.ts
 function validateFlowFile(filePath) {
   const absolutePath = resolveAsset(filePath, "bundle");
-  if (!existsSync3(absolutePath)) {
+  if (!existsSync5(absolutePath)) {
     throw new Error(
       `Flow file not found: ${filePath}
    Resolved path: ${absolutePath}
@@ -3804,40 +4095,60 @@ function validatePort(port) {
   }
 }
 
-// src/commands/run/utils.ts
-import path12 from "path";
-import fs13 from "fs-extra";
-async function prepareBundleForRun(configPath, options) {
-  const tempDir = getTmpPath(
-    void 0,
-    `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
-  );
-  await fs13.ensureDir(tempDir);
-  const tempPath = path12.join(tempDir, "bundle.mjs");
-  await bundle(configPath, {
-    cache: true,
-    verbose: options.verbose,
-    silent: options.silent,
-    flowName: options.flowName,
-    buildOverrides: {
-      output: tempPath,
-      format: "esm",
-      platform: "node"
-    }
+// src/commands/run/index.ts
+init_utils3();
+
+// src/commands/run/pipeline.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+
+// src/runtime/health-server.ts
+import http from "http";
+function createHealthServer(port, logger) {
+  return new Promise((resolve2, reject) => {
+    let flowHandler = null;
+    const server = http.createServer((req, res) => {
+      if (req.url === "/health" && req.method === "GET") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+        return;
+      }
+      if (req.url === "/ready" && req.method === "GET") {
+        const code = flowHandler ? 200 : 503;
+        res.writeHead(code, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({ status: flowHandler ? "ready" : "not_ready" })
+        );
+        return;
+      }
+      if (flowHandler) {
+        flowHandler(req, res);
+        return;
+      }
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "No flow loaded" }));
+    });
+    server.keepAliveTimeout = 5e3;
+    server.headersTimeout = 1e4;
+    server.listen(port, "0.0.0.0", () => {
+      logger.info(`Health server listening on port ${port}`);
+      resolve2({
+        server,
+        setFlowHandler(handler) {
+          flowHandler = handler;
+        },
+        close: () => new Promise((res, rej) => {
+          server.close((err) => err ? rej(err) : res());
+        })
+      });
+    });
+    server.on("error", reject);
   });
-  return tempPath;
-}
-function isPreBuiltConfig(configPath) {
-  return configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
 }
 
-// src/commands/run/execution.ts
-import { createLogger as createLogger2, Level as Level4 } from "@walkeros/core";
-
 // src/runtime/runner.ts
 import { pathToFileURL } from "url";
 import { resolve, dirname } from "path";
-async function loadFlow(file, config, logger2, loggerConfig2, healthServer) {
+async function loadFlow(file, config, logger, loggerConfig, healthServer) {
   const absolutePath = resolve(file);
   const flowDir = dirname(absolutePath);
   process.chdir(flowDir);
@@ -3850,7 +4161,7 @@ async function loadFlow(file, config, logger2, loggerConfig2, healthServer) {
   }
   const flowContext = {
     ...config,
-    ...loggerConfig2 ? { logger: loggerConfig2 } : {},
+    ...loggerConfig ? { logger: loggerConfig } : {},
     ...healthServer ? { externalServer: true } : {}
   };
   const result = await module.default(flowContext);
@@ -3869,81 +4180,398 @@ async function loadFlow(file, config, logger2, loggerConfig2, healthServer) {
     httpHandler: result.httpHandler
   };
 }
-async function runFlow(file, config, logger2, loggerConfig2) {
-  logger2.info(`Loading flow from ${file}`);
+async function swapFlow(currentHandle, newFile, config, logger, loggerConfig, healthServer) {
+  logger.info("Shutting down current flow for hot-swap...");
+  if (healthServer) {
+    healthServer.setFlowHandler(null);
+  }
   try {
-    const handle = await loadFlow(file, config, logger2, loggerConfig2);
-    logger2.info("Flow running");
-    if (config?.port) {
-      logger2.info(`Port: ${config.port}`);
-    }
-    const shutdown = async (signal) => {
-      logger2.info(`Received ${signal}, shutting down gracefully...`);
-      const forceTimer = setTimeout(() => {
-        logger2.error("Shutdown timed out, forcing exit");
-        process.exit(1);
-      }, 15e3);
-      try {
-        if (handle.collector.command) {
-          await handle.collector.command("shutdown");
-        }
-        logger2.info("Shutdown complete");
-        clearTimeout(forceTimer);
-        process.exit(0);
-      } catch (error) {
-        clearTimeout(forceTimer);
-        const message = error instanceof Error ? error.message : String(error);
-        logger2.error(`Error during shutdown: ${message}`);
-        process.exit(1);
-      }
-    };
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
-    process.on("SIGINT", () => shutdown("SIGINT"));
-    await new Promise(() => {
-    });
+    if (currentHandle.collector.command) {
+      await currentHandle.collector.command("shutdown");
+    }
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger2.error(`Failed to run flow: ${message}`);
-    if (error instanceof Error && error.stack) {
-      logger2.debug("Stack trace:", { stack: error.stack });
+    logger.debug(`Shutdown warning: ${error}`);
+  }
+  const newHandle = await loadFlow(
+    newFile,
+    config,
+    logger,
+    loggerConfig,
+    healthServer
+  );
+  logger.info("Flow swapped successfully");
+  return newHandle;
+}
+
+// src/runtime/heartbeat.ts
+import { randomBytes } from "crypto";
+
+// src/version.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join3 } from "path";
+var versionFilename = fileURLToPath2(import.meta.url);
+var versionDirname = dirname2(versionFilename);
+function findPackageJson() {
+  const paths = [
+    join3(versionDirname, "../package.json"),
+    // dist/ or src/
+    join3(versionDirname, "../../package.json")
+    // src/core/ (not used, but safe)
+  ];
+  for (const p2 of paths) {
+    try {
+      return readFileSync3(p2, "utf-8");
+    } catch {
     }
-    throw error;
   }
+  return JSON.stringify({ version: "0.0.0" });
 }
+var VERSION = JSON.parse(findPackageJson()).version;
 
 // src/runtime/heartbeat.ts
-init_version();
-import { randomBytes } from "crypto";
+function computeCounterDelta(current, last) {
+  const destinations = {};
+  for (const [name, dest] of Object.entries(current.destinations)) {
+    const prev = last.destinations[name] || {
+      count: 0,
+      failed: 0,
+      duration: 0
+    };
+    destinations[name] = {
+      count: dest.count - prev.count,
+      failed: dest.failed - prev.failed,
+      duration: dest.duration - prev.duration
+    };
+  }
+  return {
+    eventsIn: current.in - last.in,
+    eventsOut: current.out - last.out,
+    eventsFailed: current.failed - last.failed,
+    destinations
+  };
+}
 var instanceId = randomBytes(8).toString("hex");
+function getInstanceId() {
+  return instanceId;
+}
+function createHeartbeat(config, logger) {
+  let timer = null;
+  const startTime = Date.now();
+  let configVersion = config.configVersion;
+  let lastReported = {
+    in: 0,
+    out: 0,
+    failed: 0,
+    destinations: {}
+  };
+  async function sendOnce() {
+    try {
+      let counters;
+      const status = config.getCounters?.();
+      if (status) {
+        const current = {
+          in: status.in,
+          out: status.out,
+          failed: status.failed,
+          destinations: { ...status.destinations }
+        };
+        counters = computeCounterDelta(current, lastReported);
+      }
+      const response = await fetch(
+        `${config.appUrl}/api/projects/${config.projectId}/runners/heartbeat`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${config.token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            instanceId,
+            flowId: config.flowId,
+            ...config.deploymentId && {
+              deploymentId: config.deploymentId
+            },
+            configVersion,
+            cliVersion: VERSION,
+            uptime: Math.floor((Date.now() - startTime) / 1e3),
+            ...counters && { counters }
+          }),
+          signal: AbortSignal.timeout(1e4)
+        }
+      );
+      if (response.ok && status) {
+        lastReported = {
+          in: status.in,
+          out: status.out,
+          failed: status.failed,
+          destinations: { ...status.destinations }
+        };
+      }
+      if (response.status === 401 || response.status === 403) {
+        logger.error(
+          `Heartbeat auth failed (${response.status}). Token may have expired \u2014 redeploy to rotate.`
+        );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn(`Heartbeat failed: ${message}`);
+    }
+  }
+  function start() {
+    sendOnce();
+    const jitter = config.intervalMs * 0.1 * (Math.random() * 2 - 1);
+    timer = setInterval(() => sendOnce(), config.intervalMs + jitter);
+  }
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  function updateConfigVersion(version) {
+    configVersion = version;
+  }
+  return { start, stop, sendOnce, updateConfigVersion };
+}
+
+// src/runtime/poller.ts
+function createPoller(config, logger) {
+  let timer = null;
+  let lastEtag;
+  async function pollOnce() {
+    try {
+      const result = await fetchConfig({
+        ...config.fetchOptions,
+        lastEtag
+      });
+      if (!result.changed) {
+        logger.debug("Config unchanged");
+        return;
+      }
+      logger.info(`New config version: ${result.version}`);
+      lastEtag = result.etag;
+      await config.onUpdate(result.content, result.version);
+      logger.info("Config updated successfully");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`Poll error: ${message}`);
+    }
+  }
+  function start() {
+    lastEtag = void 0;
+    const jitter = config.intervalMs * 0.15 * (Math.random() * 2 - 1);
+    timer = setInterval(() => pollOnce(), config.intervalMs + jitter);
+    logger.info(
+      `Polling every ${Math.round((config.intervalMs + jitter) / 1e3)}s`
+    );
+  }
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  return { start, stop, pollOnce };
+}
+
+// src/runtime/secrets-fetcher.ts
+var SecretsHttpError = class extends Error {
+  constructor(status, statusText) {
+    super(`Failed to fetch secrets: ${status} ${statusText}`);
+    this.status = status;
+    this.name = "SecretsHttpError";
+  }
+};
+async function fetchSecrets(options) {
+  const { appUrl, token, projectId, flowId } = options;
+  const url = `${appUrl}/api/projects/${encodeURIComponent(projectId)}/flows/${encodeURIComponent(flowId)}/secrets/values`;
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!res.ok) {
+    throw new SecretsHttpError(res.status, res.statusText);
+  }
+  const json = await res.json();
+  return json.values;
+}
 
-// src/commands/run/execution.ts
-var logLevel = process.env.VERBOSE === "true" ? Level4.DEBUG : Level4.INFO;
-var loggerConfig = { level: logLevel };
-var logger = createLogger2(loggerConfig);
-async function executeRunLocal(flowPath, options) {
-  const config = {
-    port: options.port,
-    host: options.host
+// src/commands/run/pipeline.ts
+init_cache();
+async function runPipeline(options) {
+  const { bundlePath, port, logger, loggerConfig, api } = options;
+  let configVersion;
+  if (api) {
+    await injectSecrets(api, logger);
+  }
+  logger.info(`walkeros/flow v${VERSION}`);
+  logger.info(`Instance: ${getInstanceId()}`);
+  const healthServer = await createHealthServer(port, logger);
+  const runtimeConfig = { port };
+  let handle;
+  try {
+    handle = await loadFlow(
+      bundlePath,
+      runtimeConfig,
+      logger,
+      loggerConfig,
+      healthServer
+    );
+  } catch (error) {
+    await healthServer.close();
+    throw error;
+  }
+  logger.info("Flow running");
+  logger.info(`Port: ${port}`);
+  let heartbeat = null;
+  let poller = null;
+  if (api) {
+    heartbeat = createHeartbeat(
+      {
+        appUrl: api.appUrl,
+        token: api.token,
+        projectId: api.projectId,
+        flowId: api.flowId,
+        configVersion,
+        intervalMs: api.heartbeatIntervalMs,
+        getCounters: () => handle.collector.status
+      },
+      logger
+    );
+    heartbeat.start();
+    logger.info(`Heartbeat: active (every ${api.heartbeatIntervalMs / 1e3}s)`);
+    poller = createPoller(
+      {
+        fetchOptions: {
+          appUrl: api.appUrl,
+          token: api.token,
+          projectId: api.projectId,
+          flowId: api.flowId
+        },
+        intervalMs: api.pollIntervalMs,
+        onUpdate: async (content, version) => {
+          try {
+            await injectSecrets(api, logger);
+          } catch (error) {
+            logger.error(
+              `Failed to refresh secrets during poll, skipping hot-swap: ${error instanceof Error ? error.message : error}`
+            );
+            return;
+          }
+          const tmpConfigPath = `/tmp/walkeros-flow-${Date.now()}.json`;
+          writeFileSync4(
+            tmpConfigPath,
+            JSON.stringify(content, null, 2),
+            "utf-8"
+          );
+          const newBundle = await api.prepareBundleForRun(tmpConfigPath, {
+            verbose: false,
+            silent: true,
+            flowName: api.flowName
+          });
+          handle = await swapFlow(
+            handle,
+            newBundle,
+            runtimeConfig,
+            logger,
+            loggerConfig,
+            healthServer
+          );
+          writeCache(api.cacheDir, newBundle, JSON.stringify(content), version);
+          configVersion = version;
+          if (heartbeat) heartbeat.updateConfigVersion(version);
+          logger.info(`Hot-swapped to version ${version}`);
+        }
+      },
+      logger
+    );
+    poller.start();
+    logger.info(`Polling: active (every ${api.pollIntervalMs / 1e3}s)`);
+  }
+  const shutdown = async (signal) => {
+    logger.info(`Received ${signal}, shutting down...`);
+    const forceTimer = setTimeout(() => {
+      logger.error("Shutdown timed out, forcing exit");
+      process.exit(1);
+    }, 15e3);
+    try {
+      if (poller) poller.stop();
+      if (heartbeat) heartbeat.stop();
+      if (handle.collector.command) {
+        await handle.collector.command("shutdown");
+      }
+      await healthServer.close();
+      logger.info("Shutdown complete");
+      clearTimeout(forceTimer);
+      process.exit(0);
+    } catch (error) {
+      clearTimeout(forceTimer);
+      logger.error(
+        `Error during shutdown: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
   };
-  await runFlow(flowPath, config, logger.scope("runner"), loggerConfig);
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  await new Promise(() => {
+  });
+}
+async function injectSecrets(api, logger) {
+  try {
+    const secrets = await fetchSecrets({
+      appUrl: api.appUrl,
+      token: api.token,
+      projectId: api.projectId,
+      flowId: api.flowId
+    });
+    const count = Object.keys(secrets).length;
+    if (count > 0) {
+      for (const [name, value] of Object.entries(secrets)) {
+        process.env[name] = value;
+      }
+      logger.info(`Injected ${count} secret(s) into environment`);
+    }
+  } catch (error) {
+    if (error instanceof SecretsHttpError && (error.status === 401 || error.status === 403)) {
+      throw error;
+    }
+    logger.warn(
+      `Could not fetch secrets: ${error instanceof Error ? error.message : error}`
+    );
+    logger.info("Continuing without secrets (flow may not require them)");
+  }
 }
 
 // src/commands/run/index.ts
+var esmRequire = createRequire(import.meta.url);
+function defaultCacheDir() {
+  const xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || join4(homedir2(), ".cache");
+  return join4(base, "walkeros");
+}
+async function lazyPrepareBundleForRun(configPath, options) {
+  const { prepareBundleForRun: prepareBundleForRun2 } = await Promise.resolve().then(() => (init_utils3(), utils_exports));
+  return prepareBundleForRun2(configPath, options);
+}
 async function runCommand(options) {
   const timer = createTimer();
   timer.start();
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   try {
-    const configPath = validateFlowFile(options.config);
+    const port = options.port ?? 8080;
     if (options.port !== void 0) {
       validatePort(options.port);
     }
     const runtimeDeps = ["express", "cors"];
     for (const dep of runtimeDeps) {
       try {
-        __require.resolve(dep);
+        esmRequire.resolve(dep);
       } catch {
-        logger2.error(
+        logger.error(
           `Missing runtime dependency "${dep}"
 Server flows require express and cors when running outside Docker.
 Run: npm install express cors`
@@ -3951,84 +4579,167 @@ Run: npm install express cors`
         process.exit(1);
       }
     }
-    const isPreBuilt = isPreBuiltConfig(configPath);
-    let flowPath;
-    if (isPreBuilt) {
-      flowPath = path13.resolve(configPath);
-      logger2.debug(`Using pre-built flow: ${path13.basename(flowPath)}`);
-    } else {
-      logger2.debug("Building flow bundle");
-      flowPath = await prepareBundleForRun(configPath, {
-        verbose: options.verbose,
-        silent: options.json || options.silent
-      });
-      logger2.debug("Bundle ready");
-    }
-    if (options.deployment) {
-      const { startHeartbeat: startHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
-      await startHeartbeat2({
-        deployment: options.deployment,
-        projectId: options.project,
-        url: options.url || `http://localhost:${options.port || 8080}`,
-        healthEndpoint: options.healthEndpoint,
-        heartbeatInterval: options.heartbeatInterval
-      });
+    const flowId = options.flowId;
+    const projectId = options.project;
+    const token = resolveRunToken();
+    const appUrl = resolveAppUrl();
+    const flowName = options.flow;
+    let apiConfig;
+    if (flowId) {
+      if (!token) {
+        logger.error(
+          `Remote flow requires authentication.
+
+  No token found. Authenticate first:
+    $ walkeros auth login
+
+  Or set WALKEROS_TOKEN:
+    $ export WALKEROS_TOKEN=<your-token>`
+        );
+        process.exit(1);
+      }
+      if (!projectId) {
+        logger.error(
+          `--flow-id requires --project or WALKEROS_PROJECT_ID.
+
+  Set the project:
+    $ walkeros run --flow-id ${flowId} --project <your-project-id>
+    $ export WALKEROS_PROJECT_ID=<your-project-id>`
+        );
+        process.exit(1);
+      }
+      apiConfig = {
+        appUrl,
+        token,
+        projectId,
+        flowId,
+        heartbeatIntervalMs: parseInt(
+          process.env.WALKEROS_HEARTBEAT_INTERVAL ?? process.env.HEARTBEAT_INTERVAL ?? "60",
+          10
+        ) * 1e3,
+        pollIntervalMs: parseInt(
+          process.env.WALKEROS_POLL_INTERVAL ?? process.env.POLL_INTERVAL ?? "30",
+          10
+        ) * 1e3,
+        cacheDir: process.env.WALKEROS_CACHE_DIR ?? process.env.CACHE_DIR ?? defaultCacheDir(),
+        flowName,
+        prepareBundleForRun: lazyPrepareBundleForRun
+      };
     }
-    logger2.info("Starting flow...");
-    await executeRunLocal(flowPath, {
-      port: options.port,
-      host: options.host
+    const bundlePath = await resolveBundlePath(
+      options.config,
+      apiConfig,
+      logger
+    );
+    logger.info("Starting flow...");
+    await runPipeline({
+      bundlePath,
+      port,
+      logger: logger.scope("runner"),
+      loggerConfig: options.verbose ? { level: 0 } : void 0,
+      api: apiConfig
     });
   } catch (error) {
     const duration = timer.getElapsed() / 1e3;
     const errorMessage = getErrorMessage(error);
     if (options.json) {
-      logger2.json({
+      logger.json({
         success: false,
         error: errorMessage,
         duration
       });
     } else {
-      logger2.error(`Error: ${errorMessage}`);
+      logger.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
   }
 }
-async function run(options) {
-  const startTime = Date.now();
-  try {
-    let flowFile;
-    if (typeof options.config === "string") {
-      flowFile = validateFlowFile(options.config);
+async function resolveBundlePath(configInput, apiConfig, logger) {
+  if (configInput) {
+    const resolved = await resolveBundle(configInput);
+    if (resolved.source === "stdin") {
+      logger.info("Bundle: received via stdin");
+    } else if (resolved.source === "url") {
+      logger.info("Bundle: fetched from URL");
     } else {
-      throw new Error("Programmatic run() requires config file path");
+      logger.info(`Bundle: ${resolved.path}`);
     }
-    if (options.port !== void 0) {
-      validatePort(options.port);
+    if (isPreBuiltConfig(resolved.path)) {
+      return path14.resolve(resolved.path);
     }
-    const runtimeDeps = ["express", "cors"];
-    for (const dep of runtimeDeps) {
-      try {
-        __require.resolve(dep);
-      } catch {
-        throw new Error(
-          `Missing runtime dependency "${dep}". Server flows require express and cors when running outside Docker. Run: npm install express cors`
+    const flowFile = validateFlowFile(resolved.path);
+    logger.debug("Building flow bundle");
+    return lazyPrepareBundleForRun(flowFile, {
+      verbose: false,
+      silent: true,
+      flowName: apiConfig?.flowName
+    });
+  }
+  if (apiConfig) {
+    logger.info("Fetching config from API...");
+    try {
+      const result = await fetchConfig({
+        appUrl: apiConfig.appUrl,
+        token: apiConfig.token,
+        projectId: apiConfig.projectId,
+        flowId: apiConfig.flowId
+      });
+      if (result.changed) {
+        const tmpConfigPath = `/tmp/walkeros-flow-${Date.now()}.json`;
+        writeFileSync5(
+          tmpConfigPath,
+          JSON.stringify(result.content, null, 2),
+          "utf-8"
         );
+        logger.info(`Config version: ${result.version}`);
+        logger.info("Building flow...");
+        const bundlePath = await lazyPrepareBundleForRun(tmpConfigPath, {
+          verbose: false,
+          silent: true,
+          flowName: apiConfig.flowName
+        });
+        try {
+          const { writeCache: writeCache2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
+          writeCache2(
+            apiConfig.cacheDir,
+            bundlePath,
+            JSON.stringify(result.content),
+            result.version
+          );
+        } catch {
+          logger.debug("Cache write failed (non-critical)");
+        }
+        return bundlePath;
       }
+    } catch (error) {
+      logger.error(
+        `API fetch failed: ${error instanceof Error ? error.message : error}`
+      );
+      const cached = readCache(apiConfig.cacheDir);
+      if (cached) {
+        logger.info(`Using cached bundle (version: ${cached.version})`);
+        return cached.bundlePath;
+      }
+      throw new Error(
+        "No config available. API fetch failed and no cached bundle."
+      );
     }
-    const isPreBuilt = isPreBuiltConfig(flowFile);
-    let flowPath;
-    if (isPreBuilt) {
-      flowPath = path13.resolve(flowFile);
-    } else {
-      flowPath = await prepareBundleForRun(flowFile, {
-        verbose: options.verbose,
-        silent: true
-      });
-    }
-    await executeRunLocal(flowPath, {
+  }
+  const defaultFile = "server-collect.mjs";
+  logger.debug(`No config specified, using default: ${defaultFile}`);
+  return path14.resolve(defaultFile);
+}
+async function run(options) {
+  const startTime = Date.now();
+  try {
+    await runCommand({
+      config: options.config,
       port: options.port,
-      host: options.host
+      flow: options.flow,
+      flowId: options.flowId,
+      project: options.project,
+      verbose: options.verbose,
+      silent: options.silent ?? true
     });
     return {
       success: true,
@@ -4047,6 +4758,8 @@ async function run(options) {
 
 // src/commands/validate/index.ts
 init_cli_logger();
+init_core();
+init_config();
 import chalk2 from "chalk";
 
 // src/commands/validate/validators/contract.ts
@@ -4174,10 +4887,10 @@ function validateEvent(input) {
   const zodResult = PartialEventSchema.safeParse(input);
   if (!zodResult.success) {
     for (const issue of zodResult.error.issues) {
-      const path14 = issue.path.join(".");
-      if (path14 === "name") continue;
+      const path15 = issue.path.join(".");
+      if (path15 === "name") continue;
       errors.push({
-        path: path14 || "root",
+        path: path15 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -4204,7 +4917,7 @@ function validateEvent(input) {
 
 // src/commands/validate/validators/flow.ts
 import { schemas as schemas4 } from "@walkeros/core/dev";
-var { validateFlowSetup: validateFlowSetup2 } = schemas4;
+var { validateFlowConfig: validateFlowConfig3 } = schemas4;
 function validateFlow(input, options = {}) {
   const errors = [];
   const warnings = [];
@@ -4220,7 +4933,7 @@ function validateFlow(input, options = {}) {
     });
     return { valid: false, type: "flow", errors, warnings, details };
   }
-  const coreResult = validateFlowSetup2(json);
+  const coreResult = validateFlowConfig3(json);
   for (const issue of coreResult.errors) {
     errors.push({
       path: issue.path || "root",
@@ -4280,20 +4993,20 @@ function validateFlow(input, options = {}) {
     const flowsToCheck = options.flow ? [options.flow] : flowNames;
     let totalConnections = 0;
     for (const name of flowsToCheck) {
-      const flowConfig = flows[name];
-      if (!flowConfig) continue;
-      checkExampleCoverage(flowConfig, warnings);
-      const connections = buildConnectionGraph(flowConfig);
+      const flowSettings = flows[name];
+      if (!flowSettings) continue;
+      checkExampleCoverage(flowSettings, warnings);
+      const connections = buildConnectionGraph(flowSettings);
       for (const conn of connections) {
         checkCompatibility(conn, errors, warnings);
       }
       totalConnections += connections.length;
       const setupContract = config.contract;
-      if (setupContract || flowConfig.contract) {
+      if (setupContract || flowSettings.contract) {
         checkContractCompliance(
-          flowConfig,
+          flowSettings,
           setupContract,
-          flowConfig.contract,
+          flowSettings.contract,
           warnings
         );
       }
@@ -4390,10 +5103,10 @@ function buildConnectionGraph(config) {
 function checkCompatibility(conn, errors, warnings) {
   const fromOuts = Object.entries(conn.from.examples).filter(([, ex]) => ex.out !== void 0 && ex.out !== false).map(([name, ex]) => ({ name, value: ex.out }));
   const toIns = Object.entries(conn.to.examples).filter(([, ex]) => ex.in !== void 0).map(([name, ex]) => ({ name, value: ex.in }));
-  const path14 = `${conn.from.type}.${conn.from.name} \u2192 ${conn.to.type}.${conn.to.name}`;
+  const path15 = `${conn.from.type}.${conn.from.name} \u2192 ${conn.to.type}.${conn.to.name}`;
   if (fromOuts.length === 0 || toIns.length === 0) {
     warnings.push({
-      path: path14,
+      path: path15,
       message: "Cannot check compatibility: missing out or in examples",
       suggestion: "Add out examples to the source step or in examples to the target step"
     });
@@ -4411,7 +5124,7 @@ function checkCompatibility(conn, errors, warnings) {
   }
   if (!hasMatch) {
     errors.push({
-      path: path14,
+      path: path15,
       message: "No compatible out/in pair found between connected steps",
       code: "INCOMPATIBLE_EXAMPLES"
     });
@@ -4507,13 +5220,13 @@ function validateMapping(input) {
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
 var SECTIONS = ["destinations", "sources", "transformers"];
-function resolveEntry(path14, flowConfig) {
+function resolveEntry(path15, flowConfig) {
   const flows = flowConfig.flows;
   if (!flows || typeof flows !== "object") return "No flows found in config";
   const flowName = Object.keys(flows)[0];
   const flow = flows[flowName];
   if (!flow) return `Flow "${flowName}" is empty`;
-  const parts = path14.split(".");
+  const parts = path15.split(".");
   if (parts.length === 2) {
     const [section, key] = parts;
     if (!SECTIONS.includes(section)) {
@@ -4550,15 +5263,15 @@ function resolveEntry(path14, flowConfig) {
     }
     return { section: matches[0].section, key, entry: matches[0].entry };
   }
-  return `Invalid path "${path14}". Use "section.key" or just "key"`;
+  return `Invalid path "${path15}". Use "section.key" or just "key"`;
 }
-async function validateEntry(path14, flowConfig) {
-  const resolved = resolveEntry(path14, flowConfig);
+async function validateEntry(path15, flowConfig) {
+  const resolved = resolveEntry(path15, flowConfig);
   if (typeof resolved === "string") {
     return {
       valid: false,
       type: "entry",
-      errors: [{ path: path14, message: resolved, code: "ENTRY_VALIDATION" }],
+      errors: [{ path: path15, message: resolved, code: "ENTRY_VALIDATION" }],
       warnings: [],
       details: {}
     };
@@ -4589,7 +5302,7 @@ async function validateEntry(path14, flowConfig) {
       type: "entry",
       errors: [
         {
-          path: path14,
+          path: path15,
           message: error instanceof Error ? error.message : "Unknown error",
           code: "ENTRY_VALIDATION"
         }
@@ -4638,18 +5351,25 @@ async function validateEntry(path14, flowConfig) {
 
 // src/commands/validate/index.ts
 async function validate(type, input, options = {}) {
+  let resolved = input;
+  if (typeof input === "string") {
+    resolved = await loadJsonFromSource(input, {
+      name: type,
+      required: true
+    });
+  }
   if (options.path) {
-    return validateEntry(options.path, input);
+    return validateEntry(options.path, resolved);
   }
   switch (type) {
     case "contract":
-      return validateContract(input);
+      return validateContract(resolved);
     case "event":
-      return validateEvent(input);
+      return validateEvent(resolved);
     case "flow":
-      return validateFlow(input, { flow: options.flow });
+      return validateFlow(resolved, { flow: options.flow });
     case "mapping":
-      return validateMapping(input);
+      return validateMapping(resolved);
     default:
       throw new Error(`Unknown validation type: ${type}`);
   }
@@ -4689,7 +5409,7 @@ function formatResult(result, options) {
   return lines.join("\n");
 }
 async function validateCommand(options) {
-  const logger2 = createCLILogger({ ...options, stderr: true });
+  const logger = createCLILogger({ ...options, stderr: true });
   try {
     let input;
     if (isStdinPiped() && !options.input) {
@@ -4700,10 +5420,7 @@ async function validateCommand(options) {
         throw new Error("Invalid JSON received on stdin");
       }
     } else {
-      input = await loadJsonFromSource(options.input, {
-        name: options.type,
-        required: true
-      });
+      input = options.input;
     }
     const result = await validate(options.type, input, {
       flow: options.flow,
@@ -4739,7 +5456,7 @@ async function validateCommand(options) {
       );
       await writeResult(errorOutput + "\n", { output: options.output });
     } else {
-      logger2.error(`Error: ${errorMessage}`);
+      logger.error(`Error: ${errorMessage}`);
     }
     process.exit(3);
   }
@@ -4755,22 +5472,22 @@ async function openInBrowser(url) {
   await open(url);
 }
 async function loginCommand(options) {
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   try {
     const result = await login({ url: options.url });
     if (options.json) {
-      logger2.json(result);
+      logger.json(result);
     } else if (result.success) {
-      logger2.info(`Logged in as ${result.email}`);
-      logger2.info(`Token stored in ${result.configPath}`);
+      logger.info(`Logged in as ${result.email}`);
+      logger.info(`Token stored in ${result.configPath}`);
     }
     process.exit(result.success ? 0 : 1);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (options.json) {
-      logger2.json({ success: false, error: message });
+      logger.json({ success: false, error: message });
     } else {
-      logger2.error(message);
+      logger.error(message);
     }
     process.exit(1);
   }
@@ -4842,21 +5559,23 @@ async function login(options = {}) {
 init_cli_logger();
 init_config_file();
 async function logoutCommand(options) {
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   const deleted = deleteConfig();
   const configPath = getConfigPath();
   if (options.json) {
-    logger2.json({ success: true, deleted });
+    logger.json({ success: true, deleted });
   } else if (deleted) {
-    logger2.info(`Logged out. Token removed from ${configPath}`);
+    logger.info(`Logged out. Token removed from ${configPath}`);
   } else {
-    logger2.info("No stored credentials found.");
+    logger.info("No stored credentials found.");
   }
   process.exit(0);
 }
 
 // src/commands/auth/index.ts
+init_api_client();
 init_cli_logger();
+init_output();
 async function whoami() {
   const client = createApiClient();
   const { data, error } = await client.GET("/api/auth/whoami");
@@ -4864,26 +5583,28 @@ async function whoami() {
   return data;
 }
 async function whoamiCommand(options) {
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   try {
     const result = await whoami();
     if (options.json) {
       await writeResult(JSON.stringify(result, null, 2), options);
     } else {
       const data = result;
-      if (data.email) logger2.info(`${data.email}`);
-      if (data.userId) logger2.info(`User: ${data.userId}`);
-      if (data.projectId) logger2.info(`Project: ${data.projectId}`);
+      if (data.email) logger.info(`${data.email}`);
+      if (data.userId) logger.info(`User: ${data.userId}`);
+      if (data.projectId) logger.info(`Project: ${data.projectId}`);
     }
   } catch (error) {
-    logger2.error(error instanceof Error ? error.message : String(error));
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }
 
 // src/commands/projects/index.ts
+init_api_client();
 init_auth();
 init_cli_logger();
+init_output();
 async function listProjects() {
   const client = createApiClient();
   const { data, error } = await client.GET("/api/projects");
@@ -4930,12 +5651,12 @@ async function deleteProject(options = {}) {
   return data ?? { success: true };
 }
 async function handleResult(fn2, options) {
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   try {
     const result = await fn2();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
-    logger2.error(error instanceof Error ? error.message : String(error));
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }
@@ -4972,8 +5693,11 @@ async function deleteProjectCommand(projectId, options) {
 }
 
 // src/commands/flows/index.ts
+init_api_client();
 init_auth();
 init_cli_logger();
+init_output();
+init_stdin();
 async function listFlows(options = {}) {
   const id = options.projectId ?? requireProjectId();
   const client = createApiClient();
@@ -4996,7 +5720,10 @@ async function getFlow(options) {
   const { data, error } = await client.GET(
     "/api/projects/{projectId}/flows/{flowId}",
     {
-      params: { path: { projectId: id, flowId: options.flowId } }
+      params: {
+        path: { projectId: id, flowId: options.flowId },
+        query: options.fields ? { fields: options.fields.join(",") } : {}
+      }
     }
   );
   if (error) throw new Error(error.error?.message || "Failed to get flow");
@@ -5007,8 +5734,8 @@ async function createFlow(options) {
   const client = createApiClient();
   const { data, error } = await client.POST("/api/projects/{projectId}/flows", {
     params: { path: { projectId: id } },
-    // Content is user-provided JSON; server validates the full schema
-    body: { name: options.name, content: options.content }
+    // Config is user-provided JSON; server validates the full schema
+    body: { name: options.name, config: options.content }
   });
   if (error) throw new Error(error.error?.message || "Failed to create flow");
   return data;
@@ -5018,13 +5745,16 @@ async function updateFlow(options) {
   const client = createApiClient();
   const body = {};
   if (options.name !== void 0) body.name = options.name;
-  if (options.content !== void 0) body.content = options.content;
+  if (options.content !== void 0) body.config = options.content;
   const { data, error } = await client.PATCH(
     "/api/projects/{projectId}/flows/{flowId}",
     {
       params: { path: { projectId: id, flowId: options.flowId } },
       // Dynamically constructed body; server validates the full schema
-      body
+      body,
+      ...options.mergePatch && {
+        headers: { "Content-Type": "application/merge-patch+json" }
+      }
     }
   );
   if (error) throw new Error(error.error?.message || "Failed to update flow");
@@ -5057,12 +5787,12 @@ async function duplicateFlow(options) {
   return data;
 }
 async function handleResult2(fn2, options) {
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   try {
     const result = await fn2();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
-    logger2.error(error instanceof Error ? error.message : String(error));
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }
@@ -5122,21 +5852,24 @@ async function readFlowStdin() {
 }
 
 // src/commands/deploy/index.ts
+init_api_client();
 init_auth();
+init_sse();
 init_cli_logger();
-async function resolveConfigId(options) {
+init_output();
+async function resolveSettingsId(options) {
   const flow = await getFlow({
     flowId: options.flowId,
     projectId: options.projectId
   });
-  const configs = flow.configs;
-  if (!configs?.length) {
-    throw new Error("Flow has no configs.");
+  const settings = flow.settings;
+  if (!settings?.length) {
+    throw new Error("Flow has no settings.");
   }
-  const match = configs.find((c2) => c2.name === options.flowName);
+  const match = settings.find((c2) => c2.name === options.flowName);
   if (!match) {
     throw new Error(
-      `Flow "${options.flowName}" not found. Available: ${configs.map((c2) => c2.name).join(", ")}`
+      `Flow "${options.flowName}" not found. Available: ${settings.map((c2) => c2.name).join(", ")}`
     );
   }
   return match.id;
@@ -5146,8 +5879,8 @@ async function getAvailableFlowNames(options) {
     flowId: options.flowId,
     projectId: options.projectId
   });
-  const configs = flow.configs;
-  return configs?.map((c2) => c2.name) ?? [];
+  const settings = flow.settings;
+  return settings?.map((c2) => c2.name) ?? [];
 }
 async function streamDeploymentStatus(projectId, deploymentId, options) {
   const base = resolveBaseUrl();
@@ -5194,15 +5927,15 @@ async function deploy(options) {
   const projectId = options.projectId ?? requireProjectId();
   const client = createApiClient();
   if (options.flowName) {
-    const configId = await resolveConfigId({
+    const settingsId = await resolveSettingsId({
       flowId: options.flowId,
       projectId,
       flowName: options.flowName
     });
-    return deployConfig({
+    return deploySettings({
       ...options,
       projectId,
-      configId,
+      settingsId,
       timeout: options.timeout,
       signal: options.signal,
       onStatus: options.onStatus
@@ -5221,7 +5954,7 @@ async function deploy(options) {
         projectId
       });
       throw new Error(
-        `This flow has multiple configs. Use --flow <name> to specify one.
+        `This flow has multiple settings. Use --flow <name> to specify one.
 Available: ${names.join(", ")}`
       );
     }
@@ -5235,11 +5968,11 @@ Available: ${names.join(", ")}`
   });
   return { ...data, ...result };
 }
-async function deployConfig(options) {
-  const { flowId, projectId, configId } = options;
+async function deploySettings(options) {
+  const { flowId, projectId, settingsId } = options;
   const base = resolveBaseUrl();
   const response = await authenticatedFetch(
-    `${base}/api/projects/${projectId}/flows/${flowId}/configs/${configId}/deploy`,
+    `${base}/api/projects/${projectId}/flows/${flowId}/settings/${settingsId}/deploy`,
     { method: "POST" }
   );
   if (!response.ok) {
@@ -5260,14 +5993,14 @@ async function deployConfig(options) {
 async function getDeployment(options) {
   const projectId = options.projectId ?? requireProjectId();
   if (options.flowName) {
-    const configId = await resolveConfigId({
+    const settingsId = await resolveSettingsId({
       flowId: options.flowId,
       projectId,
       flowName: options.flowName
     });
     const base = resolveBaseUrl();
     const response = await authenticatedFetch(
-      `${base}/api/projects/${projectId}/flows/${options.flowId}/configs/${configId}/deploy`
+      `${base}/api/projects/${projectId}/flows/${options.flowId}/settings/${settingsId}/deploy`
     );
     if (!response.ok) {
       const body = await response.json().catch(() => ({}));
@@ -5366,6 +6099,8 @@ async function getDeploymentCommand(flowId, options) {
 // src/commands/deployments/index.ts
 init_auth();
 init_cli_logger();
+init_output();
+init_loader();
 import { getPlatform as getPlatform4 } from "@walkeros/core";
 async function listDeployments(options = {}) {
   const id = options.projectId ?? requireProjectId();
@@ -5435,12 +6170,12 @@ async function deleteDeployment(options) {
   return data ?? { success: true };
 }
 async function handleResult3(fn2, options) {
-  const logger2 = createCLILogger(options);
+  const logger = createCLILogger(options);
   try {
     const result = await fn2();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
-    logger2.error(error instanceof Error ? error.message : String(error));
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }
@@ -5500,23 +6235,23 @@ async function createDeployCommand(config, options) {
         );
       }
       const flow = await resp.json();
-      if (!flow.content) throw new Error("Flow has no content");
-      const content = flow.content;
-      const flows = content.flows;
-      if (!flows) throw new Error("Invalid flow content: missing flows");
+      if (!flow.config) throw new Error("Flow has no config");
+      const flowConfig = flow.config;
+      const flows = flowConfig.flows;
+      if (!flows) throw new Error("Invalid flow config: missing flows");
       const flowName = options.flow ?? Object.keys(flows)[0];
       if (!flowName) throw new Error("No flows found in config");
-      const flowConfig = flows[flowName];
-      if (!flowConfig || typeof flowConfig !== "object")
+      const flowSettings = flows[flowName];
+      if (!flowSettings || typeof flowSettings !== "object")
         throw new Error("Invalid flow config");
-      if ("web" in flowConfig) type = "web";
-      else if ("server" in flowConfig) type = "server";
+      if ("web" in flowSettings) type = "web";
+      else if ("server" in flowSettings) type = "server";
       else throw new Error('Flow must have "web" or "server" key');
     } else {
       const result2 = await loadFlowConfig(config, {
         flowName: options.flow
       });
-      type = getPlatform4(result2.flowConfig);
+      type = getPlatform4(result2.flowSettings);
     }
     const deployment = await createDeployment({
       type,
@@ -5556,7 +6291,11 @@ async function createDeployCommand(config, options) {
 }
 
 // src/index.ts
+init_bundle();
 init_auth();
+init_api_client();
+init_sse();
+init_utils();
 export {
   bundle,
   bundleCommand,