@walkeros/cli 3.1.0 → 3.2.0-next-1775064795590

package/dist/index.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn2, res) => function __init() {
-  return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -205,26 +205,26 @@ function mergeAuthHeaders(token, headers) {
   if (token) normalized.Authorization = `Bearer ${token}`;
   return normalized;
 }
-async function apiFetch(path15, init) {
+async function apiFetch(path19, init) {
   const baseUrl = resolveAppUrl();
   const token = resolveToken()?.token;
-  return fetch(`${baseUrl}${path15}`, {
+  return fetch(`${baseUrl}${path19}`, {
     ...init,
     headers: mergeAuthHeaders(token, init?.headers)
   });
 }
-async function publicFetch(path15, init) {
+async function publicFetch(path19, init) {
   const baseUrl = resolveAppUrl();
-  return fetch(`${baseUrl}${path15}`, init);
+  return fetch(`${baseUrl}${path19}`, init);
 }
-async function deployFetch(path15, init) {
+async function deployFetch(path19, init) {
   const baseUrl = resolveAppUrl();
   const token = resolveDeployToken() ?? resolveToken()?.token;
   if (!token)
     throw new Error(
       "No authentication token available. Set WALKEROS_DEPLOY_TOKEN or run walkeros auth login."
     );
-  return fetch(`${baseUrl}${path15}`, {
+  return fetch(`${baseUrl}${path19}`, {
     ...init,
     headers: mergeAuthHeaders(token, init?.headers)
   });
@@ -237,7 +237,6 @@ var init_http = __esm({
 });
 
 // src/config/utils.ts
-import crypto from "crypto";
 import fs2 from "fs-extra";
 import path3 from "path";
 function isUrl(str) {
@@ -248,132 +247,79 @@ function isUrl(str) {
     return false;
   }
 }
-async function downloadFromUrl(url) {
-  if (!isUrl(url)) {
-    throw new Error(`Invalid URL: ${url}`);
-  }
-  try {
-    const token = resolveToken()?.token;
-    const response = await fetch(url, {
-      headers: mergeAuthHeaders(token)
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to download ${url}: ${response.status} ${response.statusText}`
-      );
-    }
-    const content = await response.text();
-    const downloadsDir = getTmpPath(void 0, "downloads");
-    await fs2.ensureDir(downloadsDir);
-    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) {
-    if (error instanceof Error) {
-      throw new Error(`Failed to download from URL: ${error.message}`);
-    }
-    throw error;
+async function fetchContentString(url) {
+  const token = resolveToken()?.token;
+  const response = await fetch(url, {
+    headers: mergeAuthHeaders(token)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch ${url}: ${response.status} ${response.statusText}`
+    );
   }
+  return response.text();
 }
-async function loadJsonConfig(configPath) {
-  const trimmed = configPath.trim();
+async function resolveContent(input) {
+  const trimmed = input.trim();
   if (isUrl(trimmed)) {
-    const absolutePath2 = await downloadFromUrl(trimmed);
-    try {
-      const rawConfig = await fs2.readJson(absolutePath2);
-      return rawConfig;
-    } catch (error) {
-      throw new Error(
-        `Invalid JSON in config file: ${configPath}. ${error instanceof Error ? error.message : error}`
-      );
-    } finally {
-      try {
-        await fs2.remove(absolutePath2);
-      } catch {
-      }
-    }
+    return fetchContentString(trimmed);
   }
   const absolutePath = path3.resolve(trimmed);
   if (await fs2.pathExists(absolutePath)) {
-    try {
-      const rawConfig = await fs2.readJson(absolutePath);
-      return rawConfig;
-    } catch (error) {
-      throw new Error(
-        `Invalid JSON in config file: ${configPath}. ${error instanceof Error ? error.message : error}`
-      );
-    }
+    return fs2.readFile(absolutePath, "utf-8");
   }
   if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-    try {
-      return JSON.parse(trimmed);
-    } catch (jsonError) {
+    return trimmed;
+  }
+  throw new Error(`Configuration file not found: ${absolutePath}`);
+}
+async function loadConfig(input, options) {
+  const json = options?.json !== false;
+  if (!json) {
+    return resolveContent(input);
+  }
+  const trimmed = input.trim();
+  try {
+    const content = await resolveContent(trimmed);
+    return JSON.parse(content);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("not found") || errorMessage.includes("Failed to fetch")) {
+      throw error;
+    }
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
       throw new Error(
-        `Input appears to be JSON but contains errors: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`
+        `Input appears to be JSON but contains errors: ${errorMessage}`
       );
     }
+    throw new Error(`Invalid JSON in config file: ${input}. ${errorMessage}`);
   }
-  throw new Error(`Configuration file not found: ${absolutePath}`);
+}
+async function loadJsonConfig(configPath) {
+  return loadConfig(configPath, { json: true });
 }
 async function loadJsonFromSource(source, options) {
   const paramName = options?.name || "input";
   if (!source || source.trim() === "") {
-    if (options?.required) {
-      throw new Error(`${paramName} is required`);
-    }
-    if (options?.fallback !== void 0) {
-      return options.fallback;
-    }
+    if (options?.required) throw new Error(`${paramName} is required`);
+    if (options?.fallback !== void 0) return options.fallback;
     return {};
   }
-  const trimmedSource = source.trim();
-  if (isUrl(trimmedSource)) {
-    try {
-      const tempPath = await downloadFromUrl(trimmedSource);
-      try {
-        const data = await fs2.readJson(tempPath);
-        return data;
-      } finally {
-        try {
-          await fs2.remove(tempPath);
-        } catch {
-        }
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to load ${paramName} from URL ${trimmedSource}: ${getErrorMessage(error)}`
-      );
-    }
-  }
-  const resolvedPath = path3.resolve(trimmedSource);
-  if (await fs2.pathExists(resolvedPath)) {
-    try {
-      const data = await fs2.readJson(resolvedPath);
-      return data;
-    } catch (error) {
-      throw new Error(
-        `Failed to parse ${paramName} from file ${trimmedSource}: ${getErrorMessage(error)}`
-      );
-    }
-  }
   try {
-    const parsed = JSON.parse(trimmedSource);
-    return parsed;
-  } catch (jsonError) {
-    if (!trimmedSource.startsWith("{") && !trimmedSource.startsWith("[")) {
-      return { name: trimmedSource };
+    return await loadJsonConfig(source);
+  } catch (error) {
+    const trimmed = source.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return { name: trimmed };
     }
     throw new Error(
-      `Failed to parse ${paramName}. Input appears to be JSON but contains errors: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`
+      `Failed to parse ${paramName}. ${error instanceof Error ? error.message : String(error)}`
     );
   }
 }
 var init_utils = __esm({
   "src/config/utils.ts"() {
     "use strict";
-    init_core();
-    init_tmp();
     init_http();
     init_config_file();
   }
@@ -433,33 +379,82 @@ import path5 from "path";
 import fs3 from "fs-extra";
 async function resolveLocalPackage(packageName, localPath, configDir, logger) {
   const absolutePath = path5.isAbsolute(localPath) ? localPath : path5.resolve(configDir, localPath);
-  if (!await fs3.pathExists(absolutePath)) {
+  const stat = await fs3.stat(absolutePath).catch(() => null);
+  if (stat?.isFile()) {
+    return { name: packageName, absolutePath, type: "file" };
+  }
+  if (!stat) {
+    for (const ext of [".ts", ".mjs", ".js", ".json"]) {
+      const withExt = absolutePath + ext;
+      if (await fs3.pathExists(withExt)) {
+        return { name: packageName, absolutePath: withExt, type: "file" };
+      }
+    }
     throw new Error(
       `Local package path not found: ${localPath} (resolved to ${absolutePath})`
     );
   }
-  const pkgJsonPath = path5.join(absolutePath, "package.json");
-  if (!await fs3.pathExists(pkgJsonPath)) {
-    throw new Error(
-      `No package.json found at ${absolutePath}. Is this a valid package directory?`
-    );
-  }
-  const distPath = path5.join(absolutePath, "dist");
-  const hasDistFolder = await fs3.pathExists(distPath);
-  if (!hasDistFolder) {
-    logger.warn(
-      `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
+  if (stat.isDirectory()) {
+    const hasPkgJson = await fs3.pathExists(
+      path5.join(absolutePath, "package.json")
     );
+    if (hasPkgJson) {
+      const distPath = path5.join(absolutePath, "dist");
+      const hasDistFolder = await fs3.pathExists(distPath);
+      if (!hasDistFolder) {
+        logger.warn(
+          `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
+        );
+      }
+      return {
+        name: packageName,
+        absolutePath,
+        type: "package",
+        distPath: hasDistFolder ? distPath : absolutePath,
+        hasDistFolder
+      };
+    }
+    return { name: packageName, absolutePath, type: "directory" };
   }
-  return {
-    name: packageName,
-    absolutePath,
-    distPath: hasDistFolder ? distPath : absolutePath,
-    hasDistFolder
-  };
+  throw new Error(
+    `Local package path not found: ${localPath} (resolved to ${absolutePath})`
+  );
 }
 async function copyLocalPackage(localPkg, targetDir, logger) {
   const packageDir = path5.join(targetDir, "node_modules", localPkg.name);
+  if (localPkg.type === "file") {
+    await fs3.ensureDir(packageDir);
+    const ext = path5.extname(localPkg.absolutePath);
+    await fs3.copy(localPkg.absolutePath, path5.join(packageDir, `index${ext}`));
+    await fs3.writeJson(path5.join(packageDir, "package.json"), {
+      name: localPkg.name,
+      main: `./index${ext}`
+    });
+    logger.info(
+      `\u{1F4E6} Using local file: ${localPkg.name} from ${localPkg.absolutePath}`
+    );
+    return packageDir;
+  }
+  if (localPkg.type === "directory") {
+    await fs3.ensureDir(path5.dirname(packageDir));
+    const entries = await fs3.readdir(localPkg.absolutePath);
+    for (const entry of entries) {
+      if (!["node_modules", ".turbo", ".git"].includes(entry)) {
+        await fs3.copy(
+          path5.join(localPkg.absolutePath, entry),
+          path5.join(packageDir, entry)
+        );
+      }
+    }
+    await fs3.writeJson(path5.join(packageDir, "package.json"), {
+      name: localPkg.name,
+      main: "./index.ts"
+    });
+    logger.info(
+      `\u{1F4E6} Using local dir: ${localPkg.name} from ${localPkg.absolutePath}`
+    );
+    return packageDir;
+  }
   await fs3.ensureDir(path5.dirname(packageDir));
   await fs3.copy(
     path5.join(localPkg.absolutePath, "package.json"),
@@ -505,14 +500,11 @@ function detectPlatformFromPath(inputPath) {
 }
 async function loadContent(inputPath) {
   if (isUrl(inputPath)) {
-    const token = resolveToken()?.token;
-    const response = await fetch(inputPath, {
-      headers: mergeAuthHeaders(token)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch ${inputPath}: ${response.status}`);
-    }
-    return response.text();
+    return fetchContentString(inputPath);
+  }
+  const trimmed = inputPath.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return trimmed;
   }
   return fs4.readFile(inputPath, "utf8");
 }
@@ -520,12 +512,12 @@ var init_input_detector = __esm({
   "src/core/input-detector.ts"() {
     "use strict";
     init_utils();
-    init_http();
-    init_config_file();
   }
 });
 
 // src/core/stdin.ts
+import fs5 from "fs-extra";
+import path6 from "path";
 function isStdinPiped() {
   return !process.stdin.isTTY;
 }
@@ -540,9 +532,17 @@ async function readStdin() {
   }
   return content;
 }
+async function readStdinToTempFile(label) {
+  const content = await readStdin();
+  const tmpPath = getTmpPath(void 0, `stdin-${label}.json`);
+  await fs5.ensureDir(path6.dirname(tmpPath));
+  await fs5.writeFile(tmpPath, content, "utf-8");
+  return tmpPath;
+}
 var init_stdin = __esm({
   "src/core/stdin.ts"() {
     "use strict";
+    init_tmp();
   }
 });
 
@@ -599,6 +599,129 @@ var init_sse = __esm({
   }
 });
 
+// src/core/event-validation.ts
+import { schemas } from "@walkeros/core/dev";
+function validateEvent(input, level = "strict") {
+  const errors = [];
+  const warnings = [];
+  const details = {};
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    errors.push({
+      path: "root",
+      message: "Event must be an object",
+      code: "NOT_AN_OBJECT"
+    });
+    return { valid: false, errors, warnings, details };
+  }
+  const event = input;
+  if (!("name" in event) || event.name === void 0) {
+    errors.push({
+      path: "name",
+      message: "Event must have a name field",
+      code: "MISSING_EVENT_NAME"
+    });
+  } else if (typeof event.name !== "string" || event.name.trim() === "") {
+    errors.push({
+      path: "name",
+      message: "Event name cannot be empty",
+      value: event.name,
+      code: "EMPTY_EVENT_NAME"
+    });
+  } else {
+    const name = event.name;
+    if (!name.includes(" ")) {
+      if (level === "strict") {
+        errors.push({
+          path: "name",
+          message: 'Event name must be "entity action" format with space (e.g., "page view")',
+          value: name,
+          code: "INVALID_EVENT_NAME"
+        });
+        details.entity = null;
+        details.action = null;
+      } else if (level === "standard") {
+        warnings.push({
+          path: "name",
+          message: `Event name "${name}" should follow "ENTITY ACTION" format (e.g., "page view")`
+        });
+        details.entity = null;
+        details.action = null;
+      }
+    } else {
+      const parts = name.trim().split(/\s+/);
+      const action = parts.pop();
+      const entity = parts.join(" ");
+      details.entity = entity;
+      details.action = action;
+    }
+  }
+  if (level === "minimal") {
+    return { valid: errors.length === 0, errors, warnings, details };
+  }
+  const zodResult = PartialEventSchema.safeParse(input);
+  if (!zodResult.success) {
+    for (const issue of zodResult.error.issues) {
+      const issuePath = issue.path.join(".");
+      if (issuePath === "name") continue;
+      errors.push({
+        path: issuePath || "root",
+        message: issue.message,
+        code: "SCHEMA_VALIDATION"
+      });
+    }
+  }
+  if (level === "strict") {
+    if (!event.consent) {
+      warnings.push({
+        path: "consent",
+        message: "No consent object provided",
+        suggestion: "Consider adding a consent object for GDPR/privacy compliance"
+      });
+    }
+    details.hasConsent = !!event.consent;
+    details.hasData = !!event.data;
+    details.hasContext = !!event.context;
+  }
+  return { valid: errors.length === 0, errors, warnings, details };
+}
+var PartialEventSchema;
+var init_event_validation = __esm({
+  "src/core/event-validation.ts"() {
+    "use strict";
+    ({ PartialEventSchema } = schemas);
+  }
+});
+
+// src/core/package-path.ts
+import fs6 from "fs";
+import path7 from "path";
+function resolvePackageImportPath(packageName, packages, configDir, subpath) {
+  const entry = packages?.[packageName];
+  if (entry?.path) {
+    const resolved = path7.isAbsolute(entry.path) ? entry.path : path7.resolve(configDir, entry.path);
+    if (!subpath) return resolved;
+    try {
+      const pkgJson = JSON.parse(
+        fs6.readFileSync(path7.join(resolved, "package.json"), "utf8")
+      );
+      const exportKey = `.${subpath.startsWith("/") ? subpath : `/${subpath}`}`;
+      const exp = pkgJson.exports?.[exportKey];
+      if (exp) {
+        const target = typeof exp === "string" ? exp : exp.import || exp.require || exp.default;
+        if (target) return path7.join(resolved, target);
+      }
+    } catch {
+    }
+    return path7.join(resolved, subpath.replace(/^\//, ""));
+  }
+  return subpath ? `${packageName}${subpath}` : packageName;
+}
+var init_package_path = __esm({
+  "src/core/package-path.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/index.ts
 var init_core = __esm({
   "src/core/index.ts"() {
@@ -615,20 +738,19 @@ var init_core = __esm({
     init_auth();
     init_http();
     init_sse();
+    init_event_validation();
+    init_package_path();
   }
 });
 
 // src/config/validators.ts
-import { schemas } from "@walkeros/core/dev";
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
-}
+import { schemas as schemas2 } from "@walkeros/core/dev";
 function validateFlowConfig(data) {
   const result = safeParseConfig(data);
   if (!result.success) {
     const errors = result.error.issues.map((issue) => {
-      const path15 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-      return `  - ${path15}: ${issue.message}`;
+      const path19 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path19}: ${issue.message}`;
     }).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
@@ -642,7 +764,7 @@ var safeParseConfig;
 var init_validators = __esm({
   "src/config/validators.ts"() {
     "use strict";
-    ({ safeParseConfig } = schemas);
+    ({ safeParseConfig } = schemas2);
   }
 });
 
@@ -664,7 +786,7 @@ var init_build_defaults = __esm({
       minify: true,
       sourcemap: false,
       cache: true,
-      windowCollector: "collector",
+      windowCollector: "walkerOS",
       windowElb: "elb"
     };
     SERVER_BUILD_DEFAULTS = {
@@ -683,8 +805,8 @@ var init_build_defaults = __esm({
 });
 
 // src/config/loader.ts
-import path6 from "path";
-import fs5 from "fs-extra";
+import path8 from "path";
+import fs7 from "fs-extra";
 import { getFlowSettings, getPlatform } from "@walkeros/core";
 function loadBundleConfig(rawConfig, options) {
   const config = validateFlowConfig(rawConfig);
@@ -703,11 +825,11 @@ function loadBundleConfig(rawConfig, options) {
   const buildDefaults = getBuildDefaults(platform);
   const packages = flowSettings.packages || {};
   const output = options.buildOverrides?.output || getDefaultOutput(platform);
-  const configDir = isUrl(options.configPath) ? process.cwd() : path6.dirname(options.configPath);
+  const configDir = isUrl(options.configPath) ? process.cwd() : path8.dirname(options.configPath);
   let includes = config.include;
   if (!includes) {
-    const defaultIncludePath = path6.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
-    if (fs5.pathExistsSync(defaultIncludePath)) {
+    const defaultIncludePath = path8.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
+    if (fs7.pathExistsSync(defaultIncludePath)) {
       includes = [DEFAULT_INCLUDE_FOLDER];
     }
   }
@@ -792,6 +914,43 @@ var init_config = __esm({
   }
 });
 
+// src/commands/bundle/config-classifier.ts
+function containsCodeMarkers(value) {
+  if (typeof value === "string") {
+    return value.startsWith("$code:") || value.startsWith("$store:") || value.includes("__WALKEROS_ENV:");
+  }
+  if (Array.isArray(value)) {
+    return value.some(containsCodeMarkers);
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.values(value).some(
+      containsCodeMarkers
+    );
+  }
+  return false;
+}
+function classifyStepProperties(step) {
+  const codeProps = {};
+  const dataProps = {};
+  for (const [key, value] of Object.entries(step)) {
+    if (key === "code") {
+      codeProps[key] = value;
+      continue;
+    }
+    if (containsCodeMarkers(value)) {
+      codeProps[key] = value;
+    } else {
+      dataProps[key] = value;
+    }
+  }
+  return { codeProps, dataProps };
+}
+var init_config_classifier = __esm({
+  "src/commands/bundle/config-classifier.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/cache-utils.ts
 import { getHashServer } from "@walkeros/server-core";
 import semver from "semver";
@@ -832,8 +991,8 @@ var init_cache_utils = __esm({
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
-import path7 from "path";
-import fs6 from "fs-extra";
+import path9 from "path";
+import fs8 from "fs-extra";
 import semver2 from "semver";
 async function withTimeout(promise, ms, errorMessage) {
   let timer;
@@ -847,7 +1006,7 @@ async function withTimeout(promise, ms, errorMessage) {
   }
 }
 function getPackageDirectory(baseDir, packageName) {
-  return path7.join(baseDir, "node_modules", packageName);
+  return path9.join(baseDir, "node_modules", packageName);
 }
 async function collectAllSpecs(packages, logger, configDir) {
   const allSpecs = /* @__PURE__ */ new Map();
@@ -873,7 +1032,47 @@ async function collectAllSpecs(packages, logger, configDir) {
       optional: item.optional,
       localPath: item.localPath
     });
-    if (item.localPath) continue;
+    if (item.localPath) {
+      const resolvedPath = path9.isAbsolute(item.localPath) ? item.localPath : path9.resolve(configDir || process.cwd(), item.localPath);
+      const candidatePath = path9.join(resolvedPath, "package.json");
+      const hasPkgJson = await fs8.pathExists(candidatePath);
+      if (hasPkgJson) {
+        try {
+          const pkgJson = await fs8.readJson(candidatePath);
+          const deps2 = pkgJson.dependencies || {};
+          for (const [depName, depSpec] of Object.entries(deps2)) {
+            if (typeof depSpec === "string") {
+              queue.push({
+                name: depName,
+                spec: depSpec,
+                source: "dependency",
+                from: item.name,
+                optional: false
+              });
+            }
+          }
+          const peerDeps2 = pkgJson.peerDependencies || {};
+          const peerMeta2 = pkgJson.peerDependenciesMeta || {};
+          for (const [depName, depSpec] of Object.entries(peerDeps2)) {
+            if (typeof depSpec === "string") {
+              const isOptional = peerMeta2[depName]?.optional === true;
+              queue.push({
+                name: depName,
+                spec: depSpec,
+                source: "peerDependency",
+                from: item.name,
+                optional: isOptional
+              });
+            }
+          }
+        } catch (error) {
+          logger.debug(
+            `Failed to read package.json for local package ${item.name}: ${error}`
+          );
+        }
+      }
+      continue;
+    }
     let manifest;
     try {
       manifest = await withTimeout(
@@ -920,7 +1119,7 @@ async function collectAllSpecs(packages, logger, configDir) {
 function resolveVersionConflicts(allSpecs, logger) {
   const resolved = /* @__PURE__ */ new Map();
   for (const [name, specs] of allSpecs) {
-    const localSpec = specs.find((s2) => s2.localPath);
+    const localSpec = specs.find((s) => s.localPath);
     if (localSpec) {
       resolved.set(name, {
         name,
@@ -929,13 +1128,13 @@ function resolveVersionConflicts(allSpecs, logger) {
       });
       continue;
     }
-    const nonPeerSpecs = specs.filter((s2) => s2.source !== "peerDependency");
-    const peerSpecs = specs.filter((s2) => s2.source === "peerDependency");
+    const nonPeerSpecs = specs.filter((s) => s.source !== "peerDependency");
+    const peerSpecs = specs.filter((s) => s.source === "peerDependency");
     let activeSpecs;
     if (nonPeerSpecs.length > 0) {
       activeSpecs = nonPeerSpecs;
     } else {
-      const requiredPeers = peerSpecs.filter((s2) => !s2.optional);
+      const requiredPeers = peerSpecs.filter((s) => !s.optional);
       if (requiredPeers.length === 0) {
         logger.debug(`Skipping optional peer dependency: ${name}`);
         continue;
@@ -945,19 +1144,19 @@ function resolveVersionConflicts(allSpecs, logger) {
     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) => semver2.valid(s2.spec) !== null);
+    const directSpecs = activeSpecs.filter((s) => s.source === "direct");
+    const directExact = directSpecs.find((s) => semver2.valid(s.spec) !== null);
     let chosenVersion;
     if (directExact) {
       chosenVersion = directExact.spec;
     } else if (directSpecs.length > 0) {
       chosenVersion = directSpecs[0].spec;
     } else {
-      const exactVersions = activeSpecs.filter((s2) => semver2.valid(s2.spec) !== null).map((s2) => s2.spec);
+      const exactVersions = activeSpecs.filter((s) => semver2.valid(s.spec) !== null).map((s) => s.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(", ")})`
+          `Version conflict for ${name}: ${uniqueExact.join(" vs ")} (from ${activeSpecs.map((s) => `${s.spec} via ${s.from}`).join(", ")})`
         );
       } else if (uniqueExact.length === 1) {
         chosenVersion = uniqueExact[0];
@@ -1004,7 +1203,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
   logger.debug("Resolving dependencies");
   const allSpecs = await collectAllSpecs(packages, logger, configDir);
   const resolved = resolveVersionConflicts(allSpecs, logger);
-  await fs6.ensureDir(targetDir);
+  await fs8.ensureDir(targetDir);
   const localPackageMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     if (pkg.path) localPackageMap.set(pkg.name, pkg.path);
@@ -1033,8 +1232,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
         logger.debug(`Downloading ${packageSpec} (cached)`);
       }
       try {
-        await fs6.ensureDir(path7.dirname(packageDir));
-        await fs6.copy(cachedPath, packageDir);
+        await fs8.ensureDir(path9.dirname(packageDir));
+        await fs8.copy(cachedPath, packageDir);
         packagePaths.set(name, packageDir);
         continue;
       } catch {
@@ -1042,7 +1241,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       }
     }
     try {
-      await fs6.ensureDir(path7.dirname(packageDir));
+      await fs8.ensureDir(path9.dirname(packageDir));
       const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
       await withTimeout(
         pacote.extract(packageSpec, packageDir, {
@@ -1057,8 +1256,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       }
       if (useCache) {
         try {
-          await fs6.ensureDir(path7.dirname(cachedPath));
-          await fs6.copy(packageDir, cachedPath);
+          await fs8.ensureDir(path9.dirname(cachedPath));
+          await fs8.copy(packageDir, cachedPath);
         } catch {
         }
       }
@@ -1072,11 +1271,11 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
 async function getCachedPackagePath(pkg, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "packages");
   const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
-  return path7.join(cacheDir, cacheKey);
+  return path9.join(cacheDir, cacheKey);
 }
 async function isPackageCached(pkg, tmpDir) {
   const cachedPath = await getCachedPackagePath(pkg, tmpDir);
-  return fs6.pathExists(cachedPath);
+  return fs8.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -1122,29 +1321,57 @@ var init_package_manager = __esm({
 });
 
 // src/core/build-cache.ts
-import fs7 from "fs-extra";
-import path8 from "path";
+import fs9 from "fs-extra";
+import path10 from "path";
+import { getHashServer as getHashServer2 } from "@walkeros/server-core";
 async function getBuildCachePath(configContent, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "builds");
   const cacheKey = await getFlowSettingsCacheKey(configContent);
-  return path8.join(cacheDir, `${cacheKey}.js`);
+  return path10.join(cacheDir, `${cacheKey}.js`);
 }
 async function isBuildCached(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  return fs7.pathExists(cachePath);
+  return fs9.pathExists(cachePath);
 }
 async function cacheBuild(configContent, buildOutput, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  await fs7.ensureDir(path8.dirname(cachePath));
-  await fs7.writeFile(cachePath, buildOutput, "utf-8");
+  await fs9.ensureDir(path10.dirname(cachePath));
+  await fs9.writeFile(cachePath, buildOutput, "utf-8");
 }
 async function getCachedBuild(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  if (await fs7.pathExists(cachePath)) {
-    return await fs7.readFile(cachePath, "utf-8");
+  if (await fs9.pathExists(cachePath)) {
+    return await fs9.readFile(cachePath, "utf-8");
+  }
+  return null;
+}
+async function getCodeCachePath(codeContent, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "code");
+  const cacheKey = await getHashServer2(codeContent, 12);
+  return path10.join(cacheDir, `${cacheKey}.js`);
+}
+async function cacheCode(codeContent, codeOutput, tmpDir) {
+  const cachePath = await getCodeCachePath(codeContent, tmpDir);
+  await fs9.ensureDir(path10.dirname(cachePath));
+  await fs9.writeFile(cachePath, codeOutput, "utf-8");
+}
+async function getCachedCode(codeContent, tmpDir) {
+  const cachePath = await getCodeCachePath(codeContent, tmpDir);
+  if (await fs9.pathExists(cachePath)) {
+    return fs9.readFile(cachePath, "utf-8");
   }
   return null;
 }
+async function ensureCodeOnDisk(codeContent, compiledCode, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "code");
+  const cacheKey = await getHashServer2(codeContent, 12);
+  const cachePath = path10.join(cacheDir, `${cacheKey}.mjs`);
+  if (!await fs9.pathExists(cachePath)) {
+    await fs9.ensureDir(path10.dirname(cachePath));
+    await fs9.writeFile(cachePath, compiledCode, "utf-8");
+  }
+  return cachePath;
+}
 var init_build_cache = __esm({
   "src/core/build-cache.ts"() {
     "use strict";
@@ -1154,19 +1381,23 @@ var init_build_cache = __esm({
 });
 
 // src/commands/bundle/bundler.ts
-import crypto2 from "crypto";
+import crypto from "crypto";
 import esbuild from "esbuild";
 import { builtinModules } from "module";
-import path9 from "path";
-import fs8 from "fs-extra";
+import path11 from "path";
+import fs10 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;
 }
+function hasCodeReference(code) {
+  return isInlineCode(code) || typeof code === "string";
+}
 function validateReference(type, name, ref) {
   const hasPackage = !!ref.package;
-  const hasCode = isInlineCode(ref.code);
-  if (hasPackage && hasCode) {
+  const hasInlineCode = isInlineCode(ref.code);
+  const hasCode = hasCodeReference(ref.code);
+  if (hasPackage && hasInlineCode) {
     throw new Error(
       `${type} "${name}": Cannot specify both package and code. Use one or the other.`
     );
@@ -1207,18 +1438,18 @@ function generateInlineCode(inline, config, env, chain, chainPropertyName, isDes
 }
 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)) {
+    const sourcePath = path11.resolve(sourceDir, include);
+    const folderName = path11.basename(include);
+    const destPath = path11.join(outputDir, folderName);
+    const resolvedOutput = path11.resolve(outputDir);
+    const resolvedSource = path11.resolve(sourcePath);
+    if (resolvedSource === resolvedOutput || resolvedOutput.startsWith(resolvedSource + path11.sep) || resolvedSource.startsWith(resolvedOutput + path11.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);
+    if (await fs10.pathExists(sourcePath)) {
+      await fs10.copy(sourcePath, destPath);
       logger.debug(`Copied ${include} to output`);
     } else {
       logger.warn(`Include folder not found: ${include}`);
@@ -1279,7 +1510,7 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
   if (hasDeprecatedFeatures) {
     logger.warn("Skipping deprecated code: true entries from bundle.");
   }
-  const buildId = crypto2.randomUUID();
+  const buildId = crypto.randomUUID();
   const TEMP_DIR = buildOptions.tempDir || getTmpPath(void 0, `walkeros-build-${buildId}`);
   const CACHE_DIR = buildOptions.tempDir || getTmpPath();
   if (buildOptions.cache !== false) {
@@ -1289,14 +1520,14 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       const cachedBuild = await getCachedBuild(configContent, CACHE_DIR);
       if (cachedBuild) {
         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 outputPath = path11.resolve(buildOptions.output);
+        await fs10.ensureDir(path11.dirname(outputPath));
+        await fs10.writeFile(outputPath, cachedBuild);
+        const stats = await fs10.stat(outputPath);
         const sizeKB = (stats.size / 1024).toFixed(1);
         logger.info(`Output: ${outputPath} (${sizeKB} KB, cached)`);
         if (showStats) {
-          const stats2 = await fs8.stat(outputPath);
+          const stats2 = await fs10.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -1319,7 +1550,7 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
     }
   }
   try {
-    await fs8.ensureDir(TEMP_DIR);
+    await fs10.ensureDir(TEMP_DIR);
     const hasSourcesOrDests = Object.keys(
       flowSettings.sources || {}
     ).length > 0 || Object.keys(
@@ -1328,9 +1559,28 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
     if (hasSourcesOrDests && !buildOptions.packages["@walkeros/collector"]) {
       buildOptions.packages["@walkeros/collector"] = {};
     }
-    const stepPackages = collectStepPackages(flowSettings);
+    const stepPackages = collectAllStepPackages(flowSettings);
     for (const pkg of stepPackages) {
-      if (!buildOptions.packages[pkg]) {
+      const isLocalPath = pkg.startsWith(".") || pkg.startsWith("/");
+      if (isLocalPath) {
+        const varName = packageNameToVariable(pkg);
+        if (!buildOptions.packages[varName]) {
+          buildOptions.packages[varName] = {
+            path: pkg,
+            imports: [`default as ${varName}`]
+          };
+        }
+        for (const section of ["sources", "destinations", "transformers", "stores"]) {
+          const steps = flowSettings[section];
+          if (!steps) continue;
+          for (const step of Object.values(steps)) {
+            if (step.package === pkg) {
+              step.code = varName;
+              delete step.package;
+            }
+          }
+        }
+      } else if (!buildOptions.packages[pkg]) {
         buildOptions.packages[pkg] = {};
       }
     }
@@ -1354,8 +1604,8 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
-        const pkgJsonPath = path9.join(pkgPath, "package.json");
-        const pkgJson = await fs8.readJSON(pkgJsonPath);
+        const pkgJsonPath = path11.join(pkgPath, "package.json");
+        const pkgJson = await fs10.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -1363,67 +1613,135 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
               require: pkgJson.main
             }
           };
-          await fs8.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs10.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
-    const packageJsonPath = path9.join(TEMP_DIR, "package.json");
-    await fs8.writeFile(
+    const packageJsonPath = path11.join(TEMP_DIR, "package.json");
+    await fs10.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
     logger.debug("Creating entry point");
-    const entryContent = await createEntryPoint(
+    const { codeEntry, dataPayload, hasFlow } = await createEntryPoint(
       flowSettings,
       buildOptions,
       packagePaths
     );
-    const entryPath = path9.join(TEMP_DIR, "entry.js");
-    await fs8.writeFile(entryPath, entryContent);
-    logger.debug(
-      `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
-    );
-    const outputPath = path9.resolve(buildOptions.output);
-    await fs8.ensureDir(path9.dirname(outputPath));
-    const esbuildOptions = createEsbuildOptions(
-      buildOptions,
-      entryPath,
-      outputPath,
-      TEMP_DIR,
-      packagePaths,
-      logger
-    );
-    try {
-      await esbuild.build(esbuildOptions);
-    } catch (buildError) {
-      throw createBuildError(
-        buildError,
-        buildOptions.code || ""
-      );
-    } finally {
-      await esbuild.stop();
-    }
-    const outputStats = await fs8.stat(outputPath);
-    const sizeKB = (outputStats.size / 1024).toFixed(1);
-    const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
-    logger.info(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
+    const outputPath = path11.resolve(buildOptions.output);
+    await fs10.ensureDir(path11.dirname(outputPath));
+    let compiledCode = null;
     if (buildOptions.cache !== false) {
-      const configContent = generateCacheKeyContent(flowSettings, buildOptions);
-      const buildOutput = await fs8.readFile(outputPath, "utf-8");
-      await cacheBuild(configContent, buildOutput, CACHE_DIR);
-      logger.debug("Build cached for future use");
+      compiledCode = await getCachedCode(codeEntry, CACHE_DIR);
     }
-    let stats;
+    if (compiledCode) {
+      logger.debug("Using cached compiled code (config-only change)");
+    } else {
+      logger.debug(
+        `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
+      );
+      const entryPath = path11.join(TEMP_DIR, "entry.js");
+      await fs10.writeFile(entryPath, codeEntry);
+      const esbuildOptions = createEsbuildOptions(
+        { ...buildOptions, minify: false },
+        entryPath,
+        outputPath,
+        TEMP_DIR,
+        packagePaths,
+        logger
+      );
+      try {
+        await esbuild.build(esbuildOptions);
+      } catch (buildError) {
+        throw createBuildError(
+          buildError,
+          buildOptions.code || ""
+        );
+      } finally {
+        await esbuild.stop();
+      }
+      compiledCode = await fs10.readFile(outputPath, "utf-8");
+      if (buildOptions.cache !== false) {
+        await cacheCode(codeEntry, compiledCode, CACHE_DIR);
+      }
+    }
+    const stage1Path = await ensureCodeOnDisk(
+      codeEntry,
+      compiledCode,
+      CACHE_DIR
+    );
+    if (buildOptions.skipWrapper || !hasFlow) {
+      const dataDeclaration = `const __configData = ${dataPayload};
+export { __configData };`;
+      const banner = buildOptions.platform === "node" ? `import { createRequire } from 'module';const require = createRequire(import.meta.url);
+` : "";
+      const esmOutput = `${banner}${compiledCode}
+${dataDeclaration}`;
+      await fs10.writeFile(outputPath, esmOutput);
+    } else {
+      const stage2Entry = (buildOptions.platform || "node") === "browser" ? generateWebEntry(stage1Path, dataPayload, {
+        windowCollector: buildOptions.windowCollector,
+        windowElb: buildOptions.windowElb
+      }) : generateServerEntry(stage1Path, dataPayload);
+      const stage2EntryPath = path11.join(TEMP_DIR, "stage2.mjs");
+      await fs10.writeFile(stage2EntryPath, stage2Entry);
+      const stage2Options = {
+        entryPoints: [stage2EntryPath],
+        bundle: true,
+        format: "esm",
+        platform: buildOptions.platform,
+        outfile: outputPath,
+        treeShaking: true,
+        logLevel: "error",
+        minify: buildOptions.minify,
+        ...buildOptions.minify && {
+          minifyWhitespace: buildOptions.minifyOptions?.whitespace ?? true,
+          minifyIdentifiers: buildOptions.minifyOptions?.identifiers ?? true,
+          minifySyntax: buildOptions.minifyOptions?.syntax ?? true,
+          legalComments: buildOptions.minifyOptions?.legalComments ?? "none",
+          charset: "utf8"
+        }
+      };
+      if (buildOptions.platform === "browser") {
+        stage2Options.define = {
+          "process.env.NODE_ENV": '"production"',
+          global: "globalThis"
+        };
+        stage2Options.target = buildOptions.target || "es2018";
+      } else {
+        stage2Options.external = getNodeExternals();
+        stage2Options.banner = {
+          js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+        };
+        stage2Options.target = buildOptions.target || "node18";
+      }
+      try {
+        await esbuild.build(stage2Options);
+      } finally {
+        await esbuild.stop();
+      }
+    }
+    const outputStats = await fs10.stat(outputPath);
+    const sizeKB = (outputStats.size / 1024).toFixed(1);
+    const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
+    logger.info(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
+    if (buildOptions.cache !== false) {
+      const configContent = generateCacheKeyContent(flowSettings, buildOptions);
+      const buildOutput = await fs10.readFile(outputPath, "utf-8");
+      await cacheBuild(configContent, buildOutput, CACHE_DIR);
+      logger.debug("Build cached for future use");
+    }
+    let stats;
     if (showStats) {
       stats = await collectBundleStats(
         outputPath,
         buildOptions.packages,
         bundleStartTime,
-        entryContent
+        codeEntry
       );
     }
     if (buildOptions.include && buildOptions.include.length > 0) {
-      const outputDir = path9.dirname(outputPath);
+      const outputDir = path11.dirname(outputPath);
       await copyIncludes(
         buildOptions.include,
         buildOptions.configDir || process.cwd(),
@@ -1436,13 +1754,13 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
     throw error;
   } finally {
     if (!buildOptions.tempDir) {
-      fs8.remove(TEMP_DIR).catch(() => {
+      fs10.remove(TEMP_DIR).catch(() => {
       });
     }
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs8.stat(outputPath);
+  const stats = await fs10.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1473,7 +1791,8 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
   const baseOptions = {
     entryPoints: [entryPath],
     bundle: true,
-    format: buildOptions.format,
+    format: "esm",
+    // Always ESM — platform wrapper handles final format
     platform: buildOptions.platform,
     outfile: outputPath,
     absWorkingDir: tempDir,
@@ -1506,11 +1825,6 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
   } else if (buildOptions.platform === "node") {
     const nodeExternals = getNodeExternals();
     baseOptions.external = buildOptions.external ? [...nodeExternals, ...buildOptions.external] : nodeExternals;
-    if (buildOptions.format === "esm") {
-      baseOptions.banner = {
-        js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
-      };
-    }
   }
   if (buildOptions.target) {
     baseOptions.target = buildOptions.target;
@@ -1521,64 +1835,19 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
   }
   return baseOptions;
 }
-function detectDestinationPackages(flowSettings) {
-  const destinationPackages = /* @__PURE__ */ new Set();
-  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) {
-        continue;
-      }
-      if (typeof destConfig === "object" && destConfig !== null && "package" in destConfig && typeof destConfig.package === "string") {
-        destinationPackages.add(destConfig.package);
-      }
-    }
-  }
-  return destinationPackages;
-}
-function detectSourcePackages(flowSettings) {
-  const sourcePackages = /* @__PURE__ */ new Set();
-  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) {
-        continue;
-      }
-      if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string") {
-        sourcePackages.add(sourceConfig.package);
-      }
-    }
-  }
-  return sourcePackages;
-}
-function detectTransformerPackages(flowSettings) {
-  const transformerPackages = /* @__PURE__ */ new Set();
-  const transformers = flowSettings.transformers;
-  if (transformers) {
-    for (const [transformerKey, transformerConfig] of Object.entries(
-      transformers
-    )) {
-      if (typeof transformerConfig === "object" && transformerConfig !== null && "code" in transformerConfig && transformerConfig.code === true) {
-        continue;
-      }
-      if (typeof transformerConfig === "object" && transformerConfig !== null && "package" in transformerConfig && typeof transformerConfig.package === "string") {
-        transformerPackages.add(transformerConfig.package);
-      }
-    }
-  }
-  return transformerPackages;
-}
-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);
+function detectStepPackages(flowSettings, section) {
+  const packages = /* @__PURE__ */ new Set();
+  const steps = flowSettings[section];
+  if (steps) {
+    for (const [, stepConfig] of Object.entries(steps)) {
+      if (typeof stepConfig !== "object" || stepConfig === null) continue;
+      if ("code" in stepConfig && stepConfig.code === true) continue;
+      if ("package" in stepConfig && typeof stepConfig.package === "string") {
+        packages.add(stepConfig.package);
       }
     }
   }
-  return storePackages;
+  return packages;
 }
 function getNodeExternals() {
   const externals = [];
@@ -1588,27 +1857,20 @@ function getNodeExternals() {
   }
   return externals;
 }
-function collectStepPackages(flowSettings) {
+function collectAllStepPackages(flowSettings) {
   const allPackages = /* @__PURE__ */ new Set();
-  for (const pkg of detectSourcePackages(flowSettings)) {
-    allPackages.add(pkg);
-  }
-  for (const pkg of detectDestinationPackages(flowSettings)) {
-    allPackages.add(pkg);
-  }
-  for (const pkg of detectTransformerPackages(flowSettings)) {
-    allPackages.add(pkg);
-  }
-  for (const pkg of detectStorePackages(flowSettings)) {
-    allPackages.add(pkg);
-  }
-  const npmPackages = /* @__PURE__ */ new Set();
-  for (const pkg of allPackages) {
-    if (!pkg.startsWith(".") && !pkg.startsWith("/")) {
-      npmPackages.add(pkg);
+  const sections = [
+    "sources",
+    "destinations",
+    "transformers",
+    "stores"
+  ];
+  for (const section of sections) {
+    for (const pkg of detectStepPackages(flowSettings, section)) {
+      allPackages.add(pkg);
     }
   }
-  return npmPackages;
+  return allPackages;
 }
 function detectExplicitCodeImports(flowSettings) {
   const explicitCodeImports = /* @__PURE__ */ new Map();
@@ -1755,12 +2017,12 @@ function validateComponentNames(components, section) {
 }
 function validateStoreReferences(flowSettings, storeIds) {
   const refs = [];
-  function collectRefs(obj, path15) {
+  function collectRefs(obj, path19) {
     if (typeof obj === "string" && obj.startsWith("$store:")) {
-      refs.push({ ref: obj.slice(7), location: path15 });
+      refs.push({ ref: obj.slice(7), location: path19 });
     } else if (obj && typeof obj === "object") {
       for (const [key, val] of Object.entries(obj)) {
-        collectRefs(val, `${path15}.${key}`);
+        collectRefs(val, `${path19}.${key}`);
       }
     }
   }
@@ -1785,10 +2047,10 @@ function validateStoreReferences(flowSettings, storeIds) {
   }
 }
 async function createEntryPoint(flowSettings, buildOptions, packagePaths) {
-  const destinationPackages = detectDestinationPackages(flowSettings);
-  const sourcePackages = detectSourcePackages(flowSettings);
-  const transformerPackages = detectTransformerPackages(flowSettings);
-  const storePackages = detectStorePackages(flowSettings);
+  const sourcePackages = detectStepPackages(flowSettings, "sources");
+  const destinationPackages = detectStepPackages(flowSettings, "destinations");
+  const transformerPackages = detectStepPackages(flowSettings, "transformers");
+  const storePackages = detectStepPackages(flowSettings, "stores");
   const explicitCodeImports = detectExplicitCodeImports(flowSettings);
   const storeIds = new Set(
     Object.keys(
@@ -1815,29 +2077,30 @@ async function createEntryPoint(flowSettings, buildOptions, packagePaths) {
   );
   const importsCode = importStatements.join("\n");
   const hasFlow = Object.values(flowSettings.sources || {}).some(
-    (s2) => s2.package || isInlineCode(s2.code)
+    (s) => s.package || hasCodeReference(s.code)
   ) || Object.values(flowSettings.destinations || {}).some(
-    (d2) => d2.package || isInlineCode(d2.code)
+    (d2) => d2.package || hasCodeReference(d2.code)
   );
   if (!hasFlow) {
     const userCode = buildOptions.code || "";
-    return importsCode ? `${importsCode}
+    return {
+      codeEntry: importsCode ? `${importsCode}
 
-${userCode}` : userCode;
+${userCode}` : userCode,
+      dataPayload: "{}",
+      hasFlow: false
+    };
   }
-  const { storesDeclaration, configObject } = buildConfigObject(
-    flowSettings,
-    explicitCodeImports
-  );
-  const wrappedCode = generatePlatformWrapper(
+  const { storesDeclaration, codeConfigObject, dataPayload } = buildSplitConfigObject(flowSettings, explicitCodeImports);
+  const wireConfigModule = generateSplitWireConfigModule(
     storesDeclaration,
-    configObject,
-    buildOptions.code || "",
-    buildOptions
+    codeConfigObject,
+    buildOptions.code || ""
   );
-  return importsCode ? `${importsCode}
+  const codeEntry = importsCode ? `${importsCode}
 
-${wrappedCode}` : wrappedCode;
+${wireConfigModule}` : wireConfigModule;
+  return { codeEntry, dataPayload, hasFlow: true };
 }
 function createBuildError(buildError, code) {
   if (!buildError.errors || buildError.errors.length === 0) {
@@ -1862,12 +2125,55 @@ ${firstError.text}`
 ` + (location ? `  at ${location.file}:${location.line}:${location.column}` : "")
   );
 }
-function buildConfigObject(flowSettings, explicitCodeImports) {
+function buildSplitConfigObject(flowSettings, explicitCodeImports) {
   const flowWithProps = flowSettings;
   const sources = flowWithProps.sources || {};
   const destinations = flowWithProps.destinations || {};
   const transformers = flowWithProps.transformers || {};
   const stores = flowWithProps.stores || {};
+  const dataPayloadObj = {};
+  function resolveCodeVar(step) {
+    if (step.code && typeof step.code === "string" && !step.package) {
+      return step.code;
+    }
+    if (step.code && typeof step.code === "string" && step.package && explicitCodeImports.has(step.package)) {
+      return step.code;
+    }
+    return packageNameToVariable(step.package);
+  }
+  function getStepProps(step) {
+    const props = {};
+    for (const [key, value] of Object.entries(step)) {
+      if (key === "code" || key === "package") continue;
+      if (value !== void 0 && value !== null) {
+        props[key] = value;
+      }
+    }
+    return props;
+  }
+  function buildSplitStepEntry(section, stepId, step) {
+    const codeVar = resolveCodeVar(
+      step
+    );
+    const stepProps = getStepProps(step);
+    const { codeProps, dataProps } = classifyStepProperties(stepProps);
+    const codeEntries = [];
+    codeEntries.push(`code: ${codeVar}`);
+    for (const [key, value] of Object.entries(codeProps)) {
+      if (key === "code") continue;
+      codeEntries.push(`${key}: ${processConfigValue(value)}`);
+    }
+    for (const key of Object.keys(dataProps)) {
+      codeEntries.push(`${key}: __data.${section}.${stepId}.${key}`);
+    }
+    if (Object.keys(dataProps).length > 0) {
+      if (!dataPayloadObj[section]) dataPayloadObj[section] = {};
+      dataPayloadObj[section][stepId] = dataProps;
+    }
+    return `    ${stepId}: {
+      ${codeEntries.join(",\n      ")}
+    }`;
+  }
   Object.entries(sources).forEach(([name, source]) => {
     if (source.code !== true) {
       validateReference("Source", name, source);
@@ -1884,104 +2190,89 @@ function buildConfigObject(flowSettings, explicitCodeImports) {
     }
   });
   const sourcesEntries = Object.entries(sources).filter(
-    ([, source]) => source.code !== true && (source.package || isInlineCode(source.code))
+    ([, source]) => source.code !== true && (source.package || hasCodeReference(source.code))
   ).map(([key, source]) => {
     if (isInlineCode(source.code)) {
       return `    ${key}: ${generateInlineCode(source.code, source.config || {}, source.env, source.next, "next")}`;
     }
-    let codeVar;
-    if (source.code && typeof source.code === "string" && explicitCodeImports.has(source.package)) {
-      codeVar = source.code;
-    } else {
-      codeVar = packageNameToVariable(source.package);
-    }
-    const configStr = source.config ? processConfigValue(source.config) : "{}";
-    const envStr = source.env ? `,
-      env: ${processConfigValue(source.env)}` : "";
-    const nextStr = source.next ? `,
-      next: ${JSON.stringify(source.next)}` : "";
-    return `    ${key}: {
-      code: ${codeVar},
-      config: ${configStr}${envStr}${nextStr}
-    }`;
+    return buildSplitStepEntry(
+      "sources",
+      key,
+      source
+    );
   });
   const destinationsEntries = Object.entries(destinations).filter(
-    ([, dest]) => dest.code !== true && (dest.package || isInlineCode(dest.code))
+    ([, dest]) => dest.code !== true && (dest.package || hasCodeReference(dest.code))
   ).map(([key, dest]) => {
     if (isInlineCode(dest.code)) {
       return `    ${key}: ${generateInlineCode(dest.code, dest.config || {}, dest.env, dest.before, "before", true)}`;
     }
-    let codeVar;
-    if (dest.code && typeof dest.code === "string" && explicitCodeImports.has(dest.package)) {
-      codeVar = dest.code;
-    } else {
-      codeVar = packageNameToVariable(dest.package);
-    }
-    const configStr = dest.config ? processConfigValue(dest.config) : "{}";
-    const envStr = dest.env ? `,
-      env: ${processConfigValue(dest.env)}` : "";
-    const beforeStr = dest.before ? `,
-      before: ${JSON.stringify(dest.before)}` : "";
-    return `    ${key}: {
-      code: ${codeVar},
-      config: ${configStr}${envStr}${beforeStr}
-    }`;
+    return buildSplitStepEntry(
+      "destinations",
+      key,
+      dest
+    );
   });
   const transformersEntries = Object.entries(transformers).filter(
-    ([, transformer]) => transformer.code !== true && (transformer.package || isInlineCode(transformer.code))
+    ([, transformer]) => transformer.code !== true && (transformer.package || hasCodeReference(transformer.code))
   ).map(([key, transformer]) => {
     if (isInlineCode(transformer.code)) {
       return `    ${key}: ${generateInlineCode(transformer.code, transformer.config || {}, transformer.env, transformer.next, "next")}`;
     }
-    let codeVar;
-    if (transformer.code && typeof transformer.code === "string" && explicitCodeImports.has(transformer.package)) {
-      codeVar = transformer.code;
-    } else {
-      codeVar = packageNameToVariable(transformer.package);
-    }
-    const configStr = transformer.config ? processConfigValue(transformer.config) : "{}";
-    const envStr = transformer.env ? `,
-      env: ${processConfigValue(transformer.env)}` : "";
-    const nextStr = transformer.next ? `,
-      next: ${JSON.stringify(transformer.next)}` : "";
-    return `    ${key}: {
-      code: ${codeVar},
-      config: ${configStr}${envStr}${nextStr}
-    }`;
+    return buildSplitStepEntry(
+      "transformers",
+      key,
+      transformer
+    );
   });
   Object.entries(stores).forEach(([name, store]) => {
-    if (store.package || isInlineCode(store.code)) {
+    if (store.package || hasCodeReference(store.code)) {
       validateReference("Store", name, store);
     }
   });
-  const storesEntries = Object.entries(stores).filter(([, store]) => store.package || isInlineCode(store.code)).map(([key, store]) => {
+  const storesEntries = Object.entries(stores).filter(([, store]) => store.package || hasCodeReference(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 codeVar = resolveCodeVar(store);
+    const storeProps = getStepProps(store);
+    const { codeProps, dataProps } = classifyStepProperties(storeProps);
+    const codeEntries = [];
+    codeEntries.push(`code: ${codeVar}`);
+    for (const [propKey, value] of Object.entries(codeProps)) {
+      if (propKey === "code") continue;
+      codeEntries.push(`${propKey}: ${processConfigValue(value)}`);
+    }
+    for (const propKey of Object.keys(dataProps)) {
+      codeEntries.push(`${propKey}: __data.stores.${key}.${propKey}`);
+    }
+    if (Object.keys(dataProps).length > 0) {
+      if (!dataPayloadObj["stores"]) dataPayloadObj["stores"] = {};
+      dataPayloadObj["stores"][key] = dataProps;
     }
-    const configStr = store.config ? processConfigValue(store.config) : "{}";
-    const envStr = store.env ? `,
-      env: ${processConfigValue(store.env)}` : "";
     return `    ${key}: {
-      code: ${codeVar},
-      config: ${configStr}${envStr}
+      ${codeEntries.join(",\n      ")}
     }`;
   });
   const storesDeclaration = storesEntries.length > 0 ? `const stores = {
 ${storesEntries.join(",\n")}
 };` : "const stores = {};";
-  const collectorStr = flowWithProps.collector ? `,
-  ...${processConfigValue(flowWithProps.collector)}` : "";
+  let collectorStr = "";
+  if (flowWithProps.collector) {
+    if (containsCodeMarkers(flowWithProps.collector)) {
+      collectorStr = `,
+  ...${processConfigValue(flowWithProps.collector)}`;
+    } else {
+      dataPayloadObj["collector"] = flowWithProps.collector;
+      collectorStr = `,
+  ...__data.collector`;
+    }
+  }
   const transformersStr = transformersEntries.length > 0 ? `,
   transformers: {
 ${transformersEntries.join(",\n")}
   }` : "";
-  const configObject = `{
+  const codeConfigObject = `{
   sources: {
 ${sourcesEntries.join(",\n")}
   },
@@ -1990,7 +2281,69 @@ ${destinationsEntries.join(",\n")}
   }${transformersStr},
   stores${collectorStr}
 }`;
-  return { storesDeclaration, configObject };
+  const dataPayload = JSON.stringify(dataPayloadObj, null, 2);
+  return { storesDeclaration, codeConfigObject, dataPayload };
+}
+function generateSplitWireConfigModule(storesDeclaration, codeConfigObject, userCode) {
+  const codeSection = userCode ? `
+${userCode}
+` : "";
+  return `export function wireConfig(__data) {
+  ${storesDeclaration}
+
+  const config = ${codeConfigObject};${codeSection}
+
+  return config;
+}
+
+export { startFlow };`;
+}
+function generateServerEntry(stage1Path, dataPayload) {
+  return `import { startFlow, wireConfig } from '${stage1Path}';
+
+const __configData = ${dataPayload};
+
+export default async function(context = {}) {
+  const config = wireConfig(__configData);
+
+  if (context.logger) config.logger = context.logger;
+
+  if (context.sourceSettings && config.sources) {
+    for (const src of Object.values(config.sources)) {
+      if (src.config?.settings) {
+        src.config.settings = { ...src.config.settings, ...context.sourceSettings };
+      }
+    }
+  }
+
+  const result = await startFlow(config);
+
+  const httpSource = Object.values(result.collector.sources || {})
+    .find(s => 'httpHandler' in s && typeof s.httpHandler === 'function');
+
+  return { ...result, httpHandler: httpSource ? httpSource.httpHandler : undefined };
+}`;
+}
+function generateWebEntry(stage1Path, dataPayload, options = {}) {
+  const assignments = [];
+  if (options.windowCollector) {
+    assignments.push(
+      `  if (typeof window !== 'undefined') window['${options.windowCollector}'] = collector;`
+    );
+  }
+  if (options.windowElb) {
+    assignments.push(
+      `  if (typeof window !== 'undefined') window['${options.windowElb}'] = elb;`
+    );
+  }
+  const assignmentCode = assignments.length > 0 ? "\n" + assignments.join("\n") : "";
+  return `import { startFlow, wireConfig } from '${stage1Path}';
+
+const __configData = ${dataPayload};
+
+(async () => {
+  const { collector, elb } = await startFlow(wireConfig(__configData));${assignmentCode}
+})();`;
 }
 function processConfigValue(value) {
   return serializeWithCode(value, 0);
@@ -2059,66 +2412,11 @@ ${spaces}}`;
   }
   return JSON.stringify(value);
 }
-function generatePlatformWrapper(storesDeclaration, configObject, userCode, buildOptions) {
-  if (buildOptions.platform === "browser") {
-    const windowAssignments = [];
-    if (buildOptions.windowCollector) {
-      windowAssignments.push(
-        `  if (typeof window !== 'undefined') window['${buildOptions.windowCollector}'] = collector;`
-      );
-    }
-    if (buildOptions.windowElb) {
-      windowAssignments.push(
-        `  if (typeof window !== 'undefined') window['${buildOptions.windowElb}'] = elb;`
-      );
-    }
-    const assignments = windowAssignments.length > 0 ? "\n" + windowAssignments.join("\n") : "";
-    return `(async () => {
-  ${storesDeclaration}
-
-  const config = ${configObject};
-
-  ${userCode}
-
-  const { collector, elb } = await startFlow(config);${assignments}
-})();`;
-  } else {
-    const codeSection = userCode ? `
-  ${userCode}
-` : "";
-    return `export default async function(context = {}) {
-  ${storesDeclaration}
-
-  const config = ${configObject};${codeSection}
-  // Apply context overrides (e.g., logger config from CLI)
-  if (context.logger) {
-    config.logger = { ...config.logger, ...context.logger };
-  }
-
-  // When runner provides external server, strip port from sources
-  // so they don't self-listen (runner owns the port)
-  if (context.externalServer && config.sources) {
-    for (const src of Object.values(config.sources)) {
-      if (src.config && src.config.settings && 'port' in src.config.settings) {
-        delete src.config.settings.port;
-      }
-    }
-  }
-
-  const result = await startFlow(config);
-
-  // Discover httpHandler from initialized sources (duck-typing, no source-type coupling)
-  const httpSource = Object.values(result.collector.sources || {})
-    .find(s => 'httpHandler' in s && typeof s.httpHandler === 'function');
-
-  return { ...result, httpHandler: httpSource ? httpSource.httpHandler : undefined };
-}`;
-  }
-}
 var VALID_JS_IDENTIFIER;
 var init_bundler = __esm({
   "src/commands/bundle/bundler.ts"() {
     "use strict";
+    init_config_classifier();
     init_package_manager();
     init_tmp();
     init_build_cache();
@@ -2127,12 +2425,12 @@ var init_bundler = __esm({
 });
 
 // src/commands/bundle/upload.ts
-import fs9 from "fs-extra";
+import fs11 from "fs-extra";
 function sanitizeUrl(url) {
   return url.split("?")[0];
 }
 async function uploadBundleToUrl(filePath, url, timeoutMs = 3e4) {
-  const bundleContent = await fs9.readFile(filePath);
+  const bundleContent = await fs11.readFile(filePath);
   const doUpload = async (attempt) => {
     const response = await fetch(url, {
       method: "PUT",
@@ -2211,8 +2509,8 @@ var init_api_client = __esm({
 });
 
 // src/commands/bundle/dockerfile.ts
-import path10 from "path";
-import fs10 from "fs-extra";
+import path12 from "path";
+import fs12 from "fs-extra";
 function buildDockerfileContent(platform, includedFolders) {
   const bundleFile = platform === "web" ? "walker.js" : "bundle.mjs";
   const lines = [
@@ -2222,21 +2520,21 @@ function buildDockerfileContent(platform, includedFolders) {
     `COPY ${bundleFile} /app/flow/${bundleFile}`
   ];
   for (const folder of includedFolders) {
-    const name = path10.basename(folder);
+    const name = path12.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);
+  const destPath = path12.join(outputDir, "Dockerfile");
+  if (customFile && await fs12.pathExists(customFile)) {
+    await fs12.copy(customFile, destPath);
     logger.info(`Dockerfile: ${destPath} (copied from ${customFile})`);
     return;
   }
   const dockerfile = buildDockerfileContent(platform, includedFolders || []);
-  await fs10.writeFile(destPath, dockerfile);
+  await fs12.writeFile(destPath, dockerfile);
   logger.info(`Dockerfile: ${destPath}`);
 }
 var init_dockerfile = __esm({
@@ -2246,15 +2544,15 @@ var init_dockerfile = __esm({
 });
 
 // src/commands/bundle/index.ts
-import path11 from "path";
-import fs11 from "fs-extra";
+import path13 from "path";
+import fs13 from "fs-extra";
 import { getPlatform as getPlatform2 } from "@walkeros/core";
 function resolveOutputPath(output, buildOptions) {
-  const resolved = path11.resolve(output);
-  const ext = path11.extname(resolved);
-  if (output.endsWith("/") || output.endsWith(path11.sep) || !ext) {
+  const resolved = path13.resolve(output);
+  const ext = path13.extname(resolved);
+  if (output.endsWith("/") || output.endsWith(path13.sep) || !ext) {
     const filename = buildOptions.platform === "browser" ? "walker.js" : "bundle.mjs";
-    return path11.join(resolved, filename);
+    return path13.join(resolved, filename);
   }
   return resolved;
 }
@@ -2284,7 +2582,7 @@ async function bundleCommand(options) {
       } catch {
         throw new Error("Invalid JSON received on stdin");
       }
-      configPath = path11.resolve(process.cwd(), "stdin.config.json");
+      configPath = path13.resolve(process.cwd(), "stdin.config.json");
     } else {
       const file = options.config || "bundle.config.json";
       configPath = resolveAsset(file, "config");
@@ -2338,19 +2636,19 @@ async function bundleCommand(options) {
         if (uploadUrl) {
           await uploadBundleToUrl(buildOptions.output, uploadUrl);
           logger.info(`Uploaded to: ${sanitizeUrl(uploadUrl)}`);
-          await fs11.remove(buildOptions.output);
+          await fs13.remove(buildOptions.output);
         }
         if (!options.json && !options.all && options.stats && stats) {
           displayStats(stats, logger);
         }
         if (writingToStdout && !options.json) {
-          const bundleContent = await fs11.readFile(buildOptions.output);
+          const bundleContent = await fs13.readFile(buildOptions.output);
           await writeResult(bundleContent, {});
         }
         if (options.dockerfile && options.output) {
           const platform = getPlatform2(flowSettings);
           if (platform) {
-            const outputDir = path11.dirname(buildOptions.output);
+            const outputDir = path13.dirname(buildOptions.output);
             const customFile = typeof options.dockerfile === "string" ? options.dockerfile : void 0;
             await generateDockerfile(
               outputDir,
@@ -2369,7 +2667,7 @@ async function bundleCommand(options) {
         }
       }
     }
-    const duration = timer.end() / 1e3;
+    const duration = timer.end();
     const successCount = results.filter((r2) => r2.success).length;
     const failureCount = results.filter((r2) => !r2.success).length;
     if (options.json) {
@@ -2406,7 +2704,7 @@ Build Summary: ${successCount}/${results.length} succeeded`
     }
     process.exit(0);
   } catch (error) {
-    const duration = timer.getElapsed() / 1e3;
+    const duration = timer.getElapsed();
     const errorMessage = getErrorMessage(error);
     if (options.json) {
       const jsonError = createErrorOutput(errorMessage, duration);
@@ -2421,7 +2719,7 @@ Build Summary: ${successCount}/${results.length} succeeded`
 }
 async function bundle(configOrPath, options = {}) {
   let rawConfig;
-  let configPath = path11.resolve(process.cwd(), "walkeros.config.json");
+  let configPath = path13.resolve(process.cwd(), "walkeros.config.json");
   if (typeof configOrPath === "string") {
     configPath = resolveAsset(configOrPath, "config");
     rawConfig = await loadJsonConfig(configPath);
@@ -2477,6 +2775,45 @@ var init_bundle = __esm({
   }
 });
 
+// src/commands/push/env-loader.ts
+var env_loader_exports = {};
+__export(env_loader_exports, {
+  loadDestinationEnvs: () => loadDestinationEnvs
+});
+async function loadDestinationEnvs(destinations, packages, configDir) {
+  const envs = {};
+  const resolveDir = configDir || process.cwd();
+  for (const [destKey, destConfig] of Object.entries(destinations)) {
+    const typedConfig = destConfig;
+    if (!typedConfig.package) {
+      continue;
+    }
+    try {
+      const packageName = typedConfig.package;
+      const isDemoPackage = packageName.includes("-demo");
+      const importPath = isDemoPackage ? resolvePackageImportPath(packageName, packages, resolveDir) : resolvePackageImportPath(packageName, packages, resolveDir, "/dev");
+      const module = await import(importPath);
+      const examplesModule = module.examples || module.default?.examples;
+      const envModule = examplesModule?.env;
+      if (envModule?.push) {
+        envs[destKey] = {
+          init: envModule.init,
+          push: envModule.push,
+          simulation: envModule.simulation || []
+        };
+      }
+    } catch {
+    }
+  }
+  return envs;
+}
+var init_env_loader = __esm({
+  "src/commands/push/env-loader.ts"() {
+    "use strict";
+    init_package_path();
+  }
+});
+
 // src/runtime/cache.ts
 var cache_exports = {};
 __export(cache_exports, {
@@ -2531,15 +2868,15 @@ __export(utils_exports, {
   isPreBuiltConfig: () => isPreBuiltConfig,
   prepareBundleForRun: () => prepareBundleForRun
 });
-import path13 from "path";
-import fs14 from "fs-extra";
+import path17 from "path";
+import fs16 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 fs16.ensureDir(tempDir);
+  const tempPath = path17.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
     verbose: options.verbose,
@@ -2551,7 +2888,12 @@ async function prepareBundleForRun(configPath, options) {
       platform: "node"
     }
   });
-  return tempPath;
+  return {
+    bundlePath: tempPath,
+    cleanup: async () => {
+      await fs16.remove(tempDir);
+    }
+  };
 }
 function isPreBuiltConfig(configPath) {
   return configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
@@ -2567,1074 +2909,703 @@ var init_utils3 = __esm({
 // src/index.ts
 init_bundle();
 
-// src/commands/simulate/simulator.ts
-import fs12 from "fs-extra";
+// src/commands/push/index.ts
+import path16 from "path";
+import fs15 from "fs-extra";
+import {
+  createIngest,
+  getPlatform as getPlatform4,
+  compileNext,
+  resolveNext,
+  isRouteArray,
+  buildCacheContext
+} from "@walkeros/core";
 
 // ../collector/dist/index.mjs
 import { assign as o } 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 b } from "@walkeros/core";
-import { tryCatch as y, tryCatchAsync as v } from "@walkeros/core";
-import { getMappingValue as k, tryCatchAsync as O } from "@walkeros/core";
-import { isObject as C, tryCatchAsync as j, useHooks as q } from "@walkeros/core";
-import { assign as L, 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";
-import { useHooks as an, tryCatchAsync as cn } from "@walkeros/core";
-var e = { Action: "action", Actions: "actions", Config: "config", Consent: "consent", Context: "context", Custom: "custom", Destination: "destination", Elb: "elb", Globals: "globals", Hook: "hook", Init: "init", Link: "link", On: "on", Prefix: "data-elb", Ready: "ready", Run: "run", Session: "session", Shutdown: "shutdown", User: "user", Walker: "walker" };
-var t = { Commands: e, Utils: { Storage: { Cookie: "cookie", Local: "local", Session: "session" } } };
-function s(n, e2) {
-  let t2 = false;
-  const s2 = {};
-  return Object.entries(e2).forEach(([n2, e3]) => {
-    const o2 = !!e3;
-    s2[n2] = o2, t2 = t2 || o2;
-  }), n.consent = o(n.consent, s2), { update: s2, runQueue: t2 };
-}
-function D(n) {
-  const e2 = {};
-  for (const [t2, o2] of Object.entries(n)) o2.config?.next ? e2[t2] = { next: o2.config.next } : e2[t2] = {};
-  return e2;
-}
-function A(n, e2) {
-  const t2 = n.config || {}, o2 = n[e2];
-  return void 0 !== o2 ? { config: { ...t2, [e2]: o2 }, chainValue: o2 } : { config: t2, chainValue: void 0 };
-}
-function E(n, e2 = {}) {
-  if (!n) return [];
-  if (Array.isArray(n)) return n;
-  const t2 = [], o2 = /* @__PURE__ */ new Set();
-  let s2 = n;
-  for (; s2 && e2[s2] && !o2.has(s2); ) {
-    o2.add(s2), t2.push(s2);
-    const n2 = e2[s2].next;
-    if (Array.isArray(n2)) {
-      t2.push(...n2);
+import { buildCacheContext as a, clone as c, compileCache as u, checkCache as f, storeCache as l, compileNext as d, createIngest as g, debounce as p, getId as m, getGrantedConsent as h, isDefined as y, isFunction as v, isObject as b, isRouteArray as w, processEventMapping as k, resolveNext as C, tryCatchAsync as O, useHooks as j } from "@walkeros/core";
+import { isArray as A } from "@walkeros/core";
+import { tryCatch as x, tryCatchAsync as q } from "@walkeros/core";
+import { createIngest as S, getMappingValue as $, tryCatchAsync as D, compileNext as _, resolveNext as I, isRouteArray as P, compileCache as E, checkCache as M, storeCache as R, applyUpdate as H, buildCacheContext as T } from "@walkeros/core";
+import { createIngest as G, isObject as N, tryCatchAsync as B, useHooks as U, compileNext as F, resolveNext as W, isRouteArray as L, compileCache as V, checkCache as z, storeCache as J, buildCacheContext as K } from "@walkeros/core";
+import { assign as ve, getId as be, isFunction as we, isString as ke } from "@walkeros/core";
+import { isObject as Ce } from "@walkeros/core";
+import { createIngest as qe, getGrantedConsent as Se, processEventMapping as $e, tryCatchAsync as De, useHooks as _e } from "@walkeros/core";
+import { useHooks as Pe, tryCatchAsync as Ee } from "@walkeros/core";
+import { useHooks as Me } from "@walkeros/core";
+function Q(e, n) {
+  return e.storeId && n.stores[e.storeId] ? n.stores[e.storeId] : n.stores.__cache;
+}
+function X(e) {
+  const n = {};
+  for (const [t, o2] of Object.entries(e)) {
+    const e2 = o2.config?.next;
+    e2 && !L(e2) ? n[t] = { next: e2 } : n[t] = {};
+  }
+  return n;
+}
+function Z(e, n = {}) {
+  if (!e) return [];
+  if (Array.isArray(e)) return e;
+  const t = [], o2 = /* @__PURE__ */ new Set();
+  let s = e;
+  for (; s && n[s] && !o2.has(s); ) {
+    o2.add(s), t.push(s);
+    const e2 = n[s].next;
+    if (Array.isArray(e2)) {
+      t.push(...e2);
       break;
     }
-    s2 = n2;
+    s = e2;
   }
-  return t2;
+  return t;
 }
-async function x(n, e2, t2) {
-  if (e2.init && !e2.config.init) {
-    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 i2 = await q(e2.init, "TransformerInit", n.hooks)(r2);
+async function ee(e, n, t) {
+  if (n.init && !n.config.init) {
+    const o2 = n.type || "unknown", s = e.logger.scope(`transformer:${o2}`), r2 = { collector: e, logger: s, id: t, ingest: G(t), config: n.config, env: oe(n.config.env) };
+    s.debug("init");
+    const i2 = await U(n.init, "TransformerInit", e.hooks)(r2);
     if (false === i2) return false;
-    e2.config = { ...i2 || e2.config, env: i2?.env || e2.config.env, init: true }, s2.debug("init done");
+    n.config = { ...i2 || n.config, env: i2?.env || n.config.env, init: true }, s.debug("init done");
   }
   return true;
 }
-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 } : {} } };
+async function ne(e, n, t, o2, s, r2) {
+  const i2 = n.type || "unknown", a2 = e.logger.scope(`transformer:${i2}`), c2 = { collector: e, logger: a2, id: t, ingest: s, config: n.config, env: { ...oe(n.config.env), ...r2 ? { respond: r2 } : {} } };
   a2.debug("push", { event: o2.name });
-  const u2 = await q(e2.push, "TransformerPush", n.hooks)(o2, c2);
+  const u2 = await U(n.push, "TransformerPush", e.hooks)(o2, c2);
   return a2.debug("push done"), u2;
 }
-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}`);
+async function te(e, n, t, o2, s, r2, i2) {
+  i2 && s?._meta && (s._meta.chainPath = i2);
+  let a2 = o2, c2 = r2;
+  for (const o3 of t) {
+    const r3 = n[o3];
+    if (!r3) {
+      e.logger.warn(`Transformer not found: ${o3}`);
       continue;
     }
-    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 || i2, s2, a2) : (n.logger.warn(`Branch target not found: ${JSON.stringify(c2)}`), null);
-      }
-      t4 && (i2 = t4);
-    }
-  }
-  return i2;
-}
-function $(n) {
-  return n && C(n) ? n : {};
-}
-async function R(n, e2, 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), 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 O(o2)(d2);
-  if (!m2) return;
-  const p2 = m2.type || "unknown", h2 = n.logger.scope(p2).scope(e2);
-  return g2.logger = h2, i2 && (m2.config = { ...m2.config, primary: i2 }), m2;
-}
-async function T(n, e2 = {}) {
-  const t2 = {};
-  for (const [o2, s2] of Object.entries(e2)) {
-    const { config: e3 = {} } = s2;
-    if (e3.require && e3.require.length > 0) {
-      n.pending.sources[o2] = s2;
+    if (s && s._meta && s._meta.path.length > 256) return e.logger.error(`Max path length exceeded at ${o3}`), { event: null, respond: c2 };
+    s && s._meta && (s._meta.hops++, s._meta.path.push(o3));
+    if (!await B(ee)(e, r3, o3)) return e.logger.error(`Transformer init failed: ${o3}`), { event: null, respond: c2 };
+    if (i2 && void 0 !== r3.config?.chainMocks?.[i2]) {
+      const n2 = r3.config.chainMocks[i2];
+      e.logger.scope(`transformer:${r3.type || "unknown"}`).debug("chainMock", { chain: i2 }), a2 = n2;
       continue;
     }
-    const r2 = await R(n, o2, s2);
-    r2 && (t2[o2] = r2);
+    if (void 0 !== r3.config?.mock) {
+      e.logger.scope(`transformer:${r3.type || "unknown"}`).debug("mock"), a2 = r3.config.mock;
+      continue;
+    }
+    if (r3.config?.disabled) continue;
+    const u2 = r3.config?.cache, f2 = u2 ? V(u2) : void 0, l2 = f2 ? Q(f2, e) : void 0;
+    let d2;
+    if (f2 && l2) {
+      const e2 = K(s, a2), n2 = z(f2, l2, e2, `t:${o3}`);
+      if ("HIT" === n2?.status && n2.value) {
+        if (a2 = n2.value, f2.full) return { event: a2, respond: c2 };
+        continue;
+      }
+      "MISS" === n2?.status && (d2 = { key: n2.key, ttl: n2.rule.ttl });
+    }
+    const g2 = r3.config.before;
+    if (g2) {
+      const t2 = Z("string" == typeof g2 || Array.isArray(g2) && !L(g2) ? g2 : W(F(g2), K(s, a2)) || void 0, X(n));
+      if (t2.length > 0) {
+        const o4 = await te(e, n, t2, a2, s, c2, i2);
+        if (null === o4.event) return { event: null, respond: o4.respond ?? c2 };
+        o4.respond && (c2 = o4.respond), a2 = Array.isArray(o4.event) ? o4.event[0] : o4.event;
+      }
+    }
+    const p2 = await B(ne, (n2) => (e.logger.scope(`transformer:${r3.type || "unknown"}`).error("Push failed", { error: n2 }), false))(e, r3, o3, a2, s, c2);
+    if (false === p2) return { event: null, respond: c2 };
+    if (Array.isArray(p2)) {
+      const r4 = t.slice(t.indexOf(o3) + 1), u3 = await Promise.all(p2.map(async (t2) => {
+        const o4 = t2.event || a2, u4 = s ? { ...s, _meta: { ...s._meta, path: [...s._meta.path] } } : G("unknown");
+        if (t2.next) {
+          let s2 = t2.next;
+          if (L(t2.next)) {
+            const e2 = F(t2.next);
+            s2 = W(e2, K(u4, o4));
+          }
+          if (s2) {
+            const t3 = Z(s2, X(n));
+            if (t3.length > 0) return te(e, n, t3, o4, u4, c2, i2);
+          }
+          return { event: o4, respond: c2 };
+        }
+        return r4.length > 0 ? te(e, n, r4, o4, u4, c2, i2) : { event: o4, respond: c2 };
+      }));
+      let f3 = c2;
+      const l3 = [];
+      for (const e2 of u3.flat()) if (null !== e2) if (e2 && "object" == typeof e2 && "event" in e2) {
+        const n2 = e2;
+        if (n2.respond && (f3 = n2.respond), null === n2.event) continue;
+        Array.isArray(n2.event) ? l3.push(...n2.event) : l3.push(n2.event);
+      } else l3.push(e2);
+      return 0 === l3.length ? { event: null, respond: f3 } : 1 === l3.length ? { event: l3[0], respond: f3 } : { event: l3, respond: f3 };
+    }
+    if (p2 && "object" == typeof p2) {
+      const { event: t2, respond: o4, next: r4 } = p2;
+      if (o4 && (c2 = o4), r4) {
+        let o5 = r4;
+        if (L(r4)) {
+          const e2 = F(r4);
+          if (o5 = W(e2, K(s, a2)), !o5) {
+            t2 && (a2 = t2);
+            continue;
+          }
+        }
+        const u3 = Z(o5, X(n));
+        return u3.length > 0 ? te(e, n, u3, t2 || a2, s, c2, i2) : (e.logger.warn(`Branch target not found: ${JSON.stringify(r4)}`), { event: null, respond: c2 });
+      }
+      t2 && (a2 = t2);
+    }
+    if (d2 && l2 && J(l2, d2.key, a2, d2.ttl), (!p2 || "object" == typeof p2 && !p2.next) && r3.config.next && L(r3.config.next)) {
+      const t2 = r3.config.next, o4 = F(t2), u3 = W(o4, K(s, a2));
+      if (u3) {
+        const t3 = Z(u3, X(n));
+        if (t3.length > 0) return te(e, n, t3, a2, s, c2, i2);
+      }
+      return { event: a2, respond: c2 };
+    }
   }
-  return t2;
+  return { event: a2, respond: c2 };
 }
-async function I(n, e2, t2) {
-  const o2 = n.on, s2 = o2[e2] || [], r2 = b(t2) ? t2 : [t2];
-  r2.forEach((n2) => {
-    s2.push(n2);
-  }), o2[e2] = s2, await G(n, e2, r2);
+function oe(e) {
+  return e && N(e) ? e : {};
 }
-function B(n, e2, t2, o2, s2) {
-  if (!e2.on) return;
-  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: W(e2.env, e2.config.env) };
-  y(e2.on)(o2, a2);
+function Te(e) {
+  if (null === e || "object" != typeof e) return e;
+  if (Array.isArray(e)) return e.map(Te);
+  const n = {};
+  for (const [t, o2] of Object.entries(e)) n[t] = "function" == typeof o2 ? o2 : Te(o2);
+  return n;
 }
-async function G(n, e2, o2, s2) {
-  let r2, i2 = o2 || [];
-  switch (o2 || (i2 = n.on[e2] || []), e2) {
-    case t.Commands.Consent:
-      r2 = s2 || n.consent;
-      break;
-    case t.Commands.Session:
-      r2 = n.session;
-      break;
-    case t.Commands.User:
-      r2 = s2 || n.user;
-      break;
-    case t.Commands.Custom:
-      r2 = s2 || n.custom;
-      break;
-    case t.Commands.Globals:
-      r2 = s2 || n.globals;
-      break;
-    case t.Commands.Config:
-      r2 = s2 || n.config;
-      break;
-    case t.Commands.Ready:
-    case t.Commands.Run:
-    default:
-      r2 = void 0;
-  }
-  let a2 = false;
-  for (const t2 of Object.values(n.sources)) if (t2.on) {
-    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: 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 r3 = s3.indexOf(e3);
-      if (-1 === r3) continue;
-      if (s3.splice(r3, 1), s3.length > 0) continue;
-      delete n2.pending.sources[t2];
-      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 r3 = s3.indexOf(e3);
-      if (-1 === r3) continue;
-      if (s3.splice(r3, 1), s3.length > 0) continue;
-      delete n2.pending.destinations[t2];
-      const i3 = M(o3);
-      false !== i3.config.queue && (i3.queuePush = [...n2.queue]), n2.destinations[t2] = i3;
-    }
-  })(n, e2), !i2.length) return !a2;
-  switch (e2) {
-    case t.Commands.Consent:
-      !(function(n2, e3, t2) {
-        const o3 = t2 || n2.consent;
-        e3.forEach((e4) => {
-          Object.keys(o3).filter((n3) => n3 in e4).forEach((t3) => {
-            y(e4[t3])(n2, o3);
-          });
-        });
-      })(n, i2, s2);
-      break;
-    case t.Commands.Ready:
-    case t.Commands.Run:
-      !(function(n2, e3) {
-        n2.allowed && e3.forEach((e4) => {
-          y(e4)(n2);
-        });
-      })(n, i2);
-      break;
-    case t.Commands.Session:
-      !(function(n2, e3) {
-        if (!n2.session) return;
-        e3.forEach((e4) => {
-          y(e4)(n2, n2.session);
-        });
-      })(n, i2);
-      break;
-    default:
-      i2.forEach((e3) => {
-        "function" == typeof e3 && y(e3)(n, r2);
-      });
-  }
-  return !a2;
-}
-async function H(n, e2, t2) {
-  const { code: o2, config: s2 = {}, env: r2 = {}, before: i2 } = e2;
-  if (!d(o2.push)) return J({ 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: W(o2.env, r2) };
-  let l2 = u2.config.id;
-  if (!l2) do {
-    l2 = f(4);
-  } while (n.destinations[l2]);
-  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: r2, globals: i2, user: u2 } = n;
-  if (!s2) return J({ 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: r2 }));
-    if (s3.queuePush = [], e2) {
-      const n2 = c(e2);
-      f3.push(n2);
-    }
-    if (!f3.length && !s3.queueOn?.length) return { id: o3, destination: s3, skipped: true };
-    if (!f3.length && s3.queueOn?.length) {
-      const e3 = await h(z)(n, s3, o3);
-      return { id: o3, destination: s3, skipped: !e3 };
-    }
-    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(...d3), !g3.length) return { id: o3, destination: s3, queue: f3 };
-    if (!await h(z)(n, s3, o3)) return { id: o3, destination: s3, queue: f3 };
-    let m3, p2;
-    s3.dlq || (s3.dlq = []);
-    const w2 = (function(n2, e3) {
-      const t3 = n2.config.before;
-      return t3 ? E(t3, D(e3)) : [];
-    })(s3, n.transformers);
-    let b2 = 0;
-    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;
-        r3 = o4;
-      }
-      const c2 = Date.now(), f4 = await h(F, (e4) => {
-        const t3 = s3.type || "unknown";
-        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 b2 += Date.now() - c2, void 0 !== f4 && (p2 = f4), e3;
-    })), { id: o3, destination: s3, error: m3, response: p2, totalDuration: b2 };
-  })), g2 = {}, d2 = {}, m2 = {};
-  for (const e3 of f2) {
-    if (e3.skipped) continue;
-    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 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 J({ event: e2, ...Object.keys(g2).length && { done: g2 }, ...Object.keys(d2).length && { queued: d2 }, ...Object.keys(m2).length && { failed: m2 } });
-}
-async function z(n, e2, t2) {
-  if (e2.init && !e2.config.init) {
-    const o2 = e2.type || "unknown", s2 = n.logger.scope(o2), r2 = { collector: n, logger: s2, id: t2, config: e2.config, env: W(e2.env, e2.config.env) };
-    s2.debug("init");
-    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: r3 } of o3) B(n, e2, t2, s3, r3);
-    }
-    s2.debug("init done");
-  }
-  return true;
-}
-async function F(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: i2, data: a2.data, rule: a2.mapping, ingest: s2, env: { ...W(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;
-  }
-  {
-    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: i2, data: void 0, rule: d2, ingest: s2, env: { ...W(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 = [];
-      }, d2.batch) };
-    }
-    const o3 = e2.batches[m2];
-    o3.batched.events.push(a2.event), g(a2.data) && o3.batched.data.push(a2.data), o3.batchFn();
-  }
-  return true;
-}
-function J(n) {
-  return { ok: !n?.failed, ...n };
-}
-function M(n) {
-  const { code: e2, config: t2 = {}, env: o2 = {} } = n, { config: s2 } = A(n, "before"), r2 = { ...e2.config, ...t2, ...s2 }, i2 = W(e2.env, o2);
-  return { ...e2, config: r2, env: i2 };
-}
-async function N(n, e2 = {}) {
-  const t2 = {};
-  for (const [o2, s2] of Object.entries(e2)) s2.config?.require?.length ? n.pending.destinations[o2] = s2 : t2[o2] = M(s2);
-  return t2;
-}
-function W(n, e2) {
-  return n || e2 ? e2 ? n && m(n) && m(e2) ? { ...n, ...e2 } : e2 : n : {};
-}
-async function X(n, e2, t2) {
-  const o2 = Object.entries(n).map(async ([n2, o3]) => {
-    const s2 = o3.destroy;
-    if (!s2) return;
-    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) {
-      i2.error(`${e2} '${n2}' destroy failed: ${t3}`);
-    }
-  });
-  await Promise.allSettled(o2);
-}
-async function Y(n, e2, o2, r2) {
-  let i2, a2, c2 = false, u2 = false;
-  switch (e2) {
-    case t.Commands.Config:
-      K(o2) && (L(n.config, o2, { shallow: false }), a2 = o2, c2 = true);
-      break;
-    case t.Commands.Consent:
-      if (K(o2)) {
-        const { update: e3, runQueue: t2 } = s(n, o2);
-        a2 = e3, c2 = true, u2 = t2;
-      }
-      break;
-    case t.Commands.Custom:
-      K(o2) && (n.custom = L(n.custom, o2), a2 = o2, c2 = true);
-      break;
-    case t.Commands.Destination:
-      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 = L(n.globals, o2), a2 = o2, c2 = true);
-      break;
-    case t.Commands.On:
-      _(o2) && await I(n, o2, r2);
-      break;
-    case t.Commands.Ready:
-      c2 = true;
-      break;
-    case t.Commands.Run:
-      i2 = await nn(n, o2), c2 = true;
-      break;
-    case t.Commands.Session:
-      c2 = true;
-      break;
-    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.stores, "store", e3);
-      })(n);
-      break;
-    case t.Commands.User:
-      K(o2) && (L(n.user, o2, { shallow: false }), a2 = o2, c2 = true);
-  }
-  return c2 && await G(n, e2, void 0, a2), u2 && (i2 = await U(n)), i2 || J({ 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: 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: b2 = o2, timing: y2 = 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: b2, timestamp: s2, timing: y2, 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 = L(n.consent, e2.consent)), e2.user && (n.user = L(n.user, e2.user)), e2.globals && (n.globals = L(n.config.globalsStatic || {}, e2.globals)), e2.custom && (n.custom = L(n.custom, e2.custom))), Object.values(n.destinations).forEach((n2) => {
-    n2.queuePush = [];
-  }), n.queue = [], n.round++;
-  return await U(n);
-}
-function rn(n, e2) {
-  return sn(async (t2, o2 = {}) => await on(async () => {
-    const s2 = Date.now(), { id: r2, ingest: i2, respond: a2, mapping: c2, preChain: u2 } = o2;
-    let f2 = t2;
-    const l2 = i2 ? Object.freeze(i2) : void 0;
-    if (c2) {
-      const e3 = await tn(f2, c2, n);
-      if (e3.ignore) return J({ ok: true });
-      if (c2.consent) {
-        if (!en(c2.consent, n.consent, e3.event.consent)) return J({ ok: true });
-      }
-      f2 = e3.event;
-    }
-    if (u2?.length && n.transformers && Object.keys(n.transformers).length > 0) {
-      const e3 = await S(n, n.transformers, u2, f2, l2, a2);
-      if (null === e3) return J({ ok: true });
-      f2 = e3;
-    }
-    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;
-  }, () => J({ ok: false }))(), "Push", n.hooks);
-}
-async function un(n) {
-  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: "3.0.2", sources: {}, pending: { sources: {}, destinations: {} }, push: void 0, command: void 0 };
-  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), () => J({ ok: false }))(), "Command", n2.hooks);
-  })(a2, Y);
-  const c2 = n.stores || {};
-  return 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), c3 = { collector: n2, logger: a3, id: o3, config: r2, env: i2 }, u2 = await e4(c3);
-      t3[o3] = u2;
-    }
-    return t3;
-  })(a2, c2), (function(n2, e3, t3) {
-    const o3 = /* @__PURE__ */ new Map();
-    for (const [t4, s4] of Object.entries(n2)) e3[t4] && o3.set(s4, e3[t4]);
-    if (0 !== o3.size) {
-      for (const n3 of [t3.transformers, t3.destinations, t3.sources]) if (n3) for (const e4 of Object.values(n3)) s3(e4.env);
-    }
-    function s3(n3) {
-      if (n3) {
-        for (const [e4, t4] of Object.entries(n3)) if ("object" == typeof t4 && null !== t4) {
-          const s4 = o3.get(t4);
-          s4 && (n3[e4] = s4);
-        }
-      }
-    }
-  })(c2, a2.stores, n), a2.destinations = await N(a2, n.destinations || {}), a2.transformers = await (async function(n2, e3 = {}) {
-    const t3 = {};
-    for (const [o3, s3] of Object.entries(e3)) {
-      const { code: e4, env: r2 = {} } = s3, { config: i2 } = A(s3, "next"), a3 = Object.keys(r2).length > 0 ? { ...i2, env: r2 } : i2, c3 = n2.logger.scope("transformer").scope(o3), u2 = { collector: n2, logger: c3, id: o3, config: a3, env: r2 }, f2 = await e4(u2);
-      t3[o3] = f2;
-    }
-    return t3;
-  })(a2, n.transformers || {}), a2;
-}
-async function fn(n) {
-  n = n || {};
-  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);
-    }
-    let a3;
-    if ("string" == typeof n2) a3 = { name: n2 }, e3 && "object" == typeof e3 && !Array.isArray(e3) && (a3.data = e3);
-    else {
-      if (!n2 || "object" != typeof n2) return J({ ok: false });
-      a3 = n2, e3 && "object" == typeof e3 && !Array.isArray(e3) && (a3.data = { ...a3.data || {}, ...e3 });
-    }
-    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: 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 };
-}
-function ln(n) {
-  if (null === n || "object" != typeof n) return n;
-  if (Array.isArray(n)) return n.map(ln);
-  const e2 = {};
-  for (const [t2, o2] of Object.entries(n)) e2[t2] = "function" == typeof o2 ? o2 : ln(o2);
-  return e2;
-}
-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 r2 = s2;
-    for (let n3 = 0; n3 < o3.length - 1 && null != r2[o3[n3]]; n3++) r2 = r2[o3[n3]];
+function Ge(e) {
+  const n = [], { simulation: t, ...o2 } = e, s = Te(o2);
+  for (const e2 of t) {
+    const t2 = e2.startsWith("call:") ? e2.slice(5) : e2, o3 = t2.split(".");
+    let r2 = s;
+    for (let e3 = 0; e3 < o3.length - 1 && null != r2[o3[e3]]; e3++) r2 = r2[o3[e3]];
     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);
+    "function" == typeof a2 && (r2[i2] = function(...e3) {
+      return n.push({ fn: t2, args: e3, ts: Date.now() }), a2.apply(this, e3);
     });
   }
-  return { wrappedEnv: s2, calls: e2 };
-}
-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: 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 = {}, createTrigger: s2, input: r2, consent: i2 } = n2, { content: a2, trigger: c2 } = r2, u2 = { functional: true, marketing: true, analytics: true }, f2 = [], l2 = { consent: i2 || u2, sources: { sim: { code: t2, config: o2, next: "spy" } }, transformers: { spy: { code: () => ({ type: "spy", config: {}, push: (n3) => (f2.push(JSON.parse(JSON.stringify(n3))), { event: n3 }) }) } } }, { trigger: g2 } = await s2(l2);
-          void 0 !== a2 && await g2(c2?.type, c2?.options)(a2);
-          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: 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: 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) {
-    return { step: n.step, name: n.name, events: [], calls: [], duration: Date.now() - e2, error: t2 instanceof Error ? t2 : new Error(String(t2)) };
-  }
+  return { wrappedEnv: s, calls: n };
 }
 
-// src/commands/simulate/simulator.ts
+// src/commands/push/index.ts
 init_cli_logger();
 init_core();
-init_config();
 init_tmp();
+init_config();
+init_utils();
+init_bundler();
 
-// src/commands/simulate/env-loader.ts
-async function loadDestinationEnvs(destinations) {
-  const envs = {};
-  for (const [destKey, destConfig] of Object.entries(destinations)) {
-    const typedConfig = destConfig;
-    if (!typedConfig.package) {
-      continue;
-    }
-    try {
-      const packageName = typedConfig.package;
-      const isDemoPackage = packageName.includes("-demo");
-      const importPath = isDemoPackage ? packageName : `${packageName}/dev`;
-      const module = await import(importPath);
-      const examplesModule = module.examples || module.default?.examples;
-      const envModule = examplesModule?.env;
-      if (envModule?.push) {
-        envs[destKey] = {
-          init: envModule.init,
-          push: envModule.push,
-          simulation: envModule.simulation || []
-        };
-      }
-    } catch {
-    }
-  }
-  return envs;
-}
-
-// src/commands/simulate/simulator.ts
-function callsToUsage(destName, calls) {
-  if (!calls.length) return {};
-  return {
-    [destName]: calls.map((c2) => ({
-      type: "call",
-      path: c2.fn,
-      args: c2.args,
-      timestamp: c2.ts
-    }))
-  };
-}
-async function simulateCore(inputPath, event, options = {}) {
-  const logger = createCLILogger({
-    verbose: options.verbose || false,
-    silent: options.silent || false,
-    json: options.json || false
-  });
-  try {
-    logger.debug(`Simulating event: ${JSON.stringify(event)}`);
-    const result = await executeSimulation(event, inputPath, options.platform, {
-      flow: options.flow,
-      step: options.step,
-      verbose: options.verbose
-    });
-    return result;
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    return {
-      success: false,
-      error: errorMessage
-    };
-  }
-}
-function formatSimulationResult(result, options = {}) {
-  if (options.json) {
-    const output = {
-      result: result.elbResult,
-      usage: result.usage,
-      duration: result.duration
-    };
-    if (result.capturedEvents) {
-      output.capturedEvents = result.capturedEvents;
-    }
-    return JSON.stringify(output, null, 2);
-  }
-  const lines = [];
-  if (result.success) {
-    lines.push("Simulation completed");
-  } else {
-    lines.push(`Simulation failed: ${result.error}`);
+// src/commands/push/overrides.ts
+function buildOverrides(flags, flowConfig) {
+  const simulateFlags = flags.simulate ?? [];
+  const mockFlags = flags.mock ?? [];
+  if (simulateFlags.length === 0 && mockFlags.length === 0) {
+    return {};
   }
-  if (result.capturedEvents) {
-    lines.push(`Captured ${result.capturedEvents.length} event(s)`);
-    for (const evt of result.capturedEvents) {
-      lines.push(`  - ${evt.name || "unknown"}`);
-    }
+  const simulateNames = /* @__PURE__ */ new Set();
+  const sourceSimulateNames = /* @__PURE__ */ new Set();
+  const mockNames = /* @__PURE__ */ new Set();
+  const overrides = {};
+  for (const step of simulateFlags) {
+    const { type, name } = parseStep(step);
+    if (type === "destination") {
+      simulateNames.add(name);
+      if (!overrides.destinations) overrides.destinations = {};
+      overrides.destinations[name] = { simulate: true };
+    } else if (type === "transformer") {
+      if (!overrides.transformers) overrides.transformers = {};
+      overrides.transformers[name] = { simulate: true };
+    } else {
+      sourceSimulateNames.add(name);
+      if (!overrides.sources) overrides.sources = {};
+      overrides.sources[name] = { simulate: true };
+    }
+  }
+  const hasSource = sourceSimulateNames.size > 0;
+  const hasTransformer = overrides.transformers && Object.keys(overrides.transformers).length > 0;
+  const hasDestination = simulateNames.size > 0;
+  const simulatedTypes = [
+    hasSource && "source",
+    hasTransformer && "transformer",
+    hasDestination && "destination"
+  ].filter(Boolean);
+  if (simulatedTypes.length > 1) {
+    throw new Error(
+      `Cannot simulate both ${simulatedTypes.join(" and ")} in the same invocation. Run separate commands for each step type.`
+    );
   }
-  return lines.join("\n");
-}
-async function executeSimulation(event, inputPath, platformOverride, options = {}) {
-  const startTime = Date.now();
-  const tempDir = getTmpPath();
-  try {
-    await fs12.ensureDir(tempDir);
-    const detected = await detectInput(inputPath, platformOverride);
-    if (!isObject(event) || !("name" in event) || typeof event.name !== "string") {
+  for (const step of mockFlags) {
+    const eqIndex = step.indexOf("=");
+    if (eqIndex === -1) {
       throw new Error(
-        'Event must be an object with a "name" property of type string'
+        `Invalid --mock format: "${step}". Expected destination.NAME=VALUE`
       );
     }
-    const typedEvent = event;
-    if (detected.type !== "config") {
+    const stepPart = step.slice(0, eqIndex);
+    const valuePart = step.slice(eqIndex + 1);
+    const parsed = parseStep(stepPart);
+    if (parsed.type === "source") {
       throw new Error(
-        `Input "${inputPath}" is not valid JSON config. simulate only accepts Flow.Config config files.`
+        `--mock is not supported for sources. Use --simulate source.${parsed.name}`
       );
     }
-    return await executeConfigSimulation(
-      detected.content,
-      inputPath,
-      typedEvent,
-      tempDir,
-      startTime,
-      options.flow,
-      options.step
-    );
-  } catch (error) {
-    const duration = Date.now() - startTime;
-    return {
-      success: false,
-      error: getErrorMessage(error),
-      duration
-    };
-  } finally {
-    if (tempDir) {
-      await fs12.remove(tempDir).catch(() => {
-      });
+    if (parsed.type === "transformer" && !parsed.chainType) {
+      throw new Error(
+        `Use --mock destination.NAME.before.${parsed.name}=VALUE for path-specific transformer mocks`
+      );
     }
-  }
-}
-function parseStepTarget(stepTarget, flowConfig) {
-  if (stepTarget) {
-    const dotIndex = stepTarget.indexOf(".");
-    if (dotIndex > -1) {
-      const type = stepTarget.substring(0, dotIndex);
-      const name = stepTarget.substring(dotIndex + 1);
-      const section = flowConfig[type + "s"];
-      if (!section?.[name]) {
-        throw new Error(`Step "${stepTarget}" not found in flow config`);
+    let parsedValue;
+    try {
+      parsedValue = JSON.parse(valuePart);
+    } catch {
+      parsedValue = valuePart;
+    }
+    if (parsed.chainType && parsed.transformerId) {
+      const chainPath = `destination.${parsed.name}.${parsed.chainType}`;
+      if (!overrides.transformerMocks) overrides.transformerMocks = {};
+      if (!overrides.transformerMocks[chainPath])
+        overrides.transformerMocks[chainPath] = {};
+      overrides.transformerMocks[chainPath][parsed.transformerId] = parsedValue;
+    } else {
+      if (simulateNames.has(parsed.name)) {
+        throw new Error(
+          `Destination "${parsed.name}" cannot be in both --simulate and --mock`
+        );
+      }
+      mockNames.add(parsed.name);
+      if (!overrides.destinations) overrides.destinations = {};
+      overrides.destinations[parsed.name] = { config: { mock: parsedValue } };
+    }
+  }
+  const allDestinations = Object.keys(flowConfig.destinations ?? {});
+  const targetedNames = /* @__PURE__ */ new Set([...simulateNames, ...mockNames]);
+  if (targetedNames.size > 0) {
+    if (!overrides.destinations) overrides.destinations = {};
+    for (const destName of allDestinations) {
+      if (!targetedNames.has(destName)) {
+        overrides.destinations[destName] = { config: { disabled: true } };
       }
-      return { type, name, config: section[name] };
     }
   }
-  const destinations = flowConfig.destinations;
-  if (destinations) {
-    const [name, config] = Object.entries(destinations)[0];
-    return {
-      type: "destination",
-      name,
-      config
-    };
-  }
-  throw new Error("No destination found in flow config");
+  return overrides;
 }
-async function executeConfigSimulation(_content, configPath, typedEvent, tempDir, startTime, flowName, stepTarget) {
-  const { flowSettings } = await loadFlowConfig(configPath, {
-    flowName
-  });
-  const step = parseStepTarget(
-    stepTarget,
-    flowSettings
-  );
-  if (step.type === "destination") {
-    const packageName = step.config.package;
-    if (!packageName) {
-      throw new Error(`Destination "${step.name}" has no package field`);
-    }
-    const destModule = await import(packageName);
-    const code = destModule.default || Object.values(destModule)[0];
-    const destinations = flowSettings.destinations;
-    const envs = await loadDestinationEnvs(destinations || {});
-    const destEnv = envs[step.name];
-    const result = await dn({
-      step: "destination",
-      name: step.name,
-      code,
-      event: typedEvent,
-      config: step.config.config,
-      env: destEnv?.push,
-      track: destEnv?.simulation
-    });
-    const duration = Date.now() - startTime;
-    return {
-      success: !result.error,
-      error: result.error?.message,
-      usage: callsToUsage(step.name, result.calls),
-      duration,
-      logs: []
-    };
-  }
-  if (step.type === "transformer") {
-    const packageName = step.config.package;
-    if (!packageName) {
-      throw new Error(`Transformer "${step.name}" has no package field`);
-    }
-    const mod = await import(packageName);
-    const code = mod.default || Object.values(mod)[0];
-    const result = await dn({
-      step: "transformer",
-      name: step.name,
-      code,
-      event: typedEvent,
-      config: step.config.config
-    });
-    const duration = Date.now() - startTime;
-    return {
-      success: !result.error,
-      error: result.error?.message,
-      capturedEvents: result.events,
-      duration,
-      usage: {},
-      logs: []
-    };
+function parseStep(step) {
+  const parts = step.split(".");
+  if (parts.length < 2) {
+    throw new Error(
+      `Invalid step format: "${step}". Expected "source.NAME" or "destination.NAME"`
+    );
   }
-  throw new Error(`Unknown step type: ${step.type}`);
-}
-
-// src/commands/simulate/source-simulator.ts
-init_core();
-async function loadSourcePackage(packageName) {
-  const mainModule = await import(packageName);
-  const code = mainModule.default || Object.values(mainModule)[0];
-  if (!code || typeof code !== "function") {
-    throw new Error(`Package ${packageName} missing source init function`);
+  const prefix = parts[0];
+  if (prefix !== "source" && prefix !== "destination" && prefix !== "transformer") {
+    throw new Error(
+      `Unsupported step type: "${prefix}". Use "source", "destination", or "transformer"`
+    );
   }
-  let createTrigger;
-  try {
-    const devModule = await import(`${packageName}/dev`);
-    const examples = devModule.examples || devModule.default?.examples;
-    if (examples?.createTrigger && typeof examples.createTrigger === "function") {
-      createTrigger = examples.createTrigger;
-    }
-  } catch {
+  const name = parts[1];
+  if (!name) {
+    throw new Error(
+      `Invalid step format: "${step}". Missing name after "${prefix}."`
+    );
   }
-  return { code, createTrigger };
-}
-async function simulateSourceCLI(flowConfig, sourceInput, options) {
-  const startTime = Date.now();
-  try {
-    const sources = flowConfig.sources;
-    if (!sources) {
-      throw new Error("Flow config has no sources");
-    }
-    const sourceConfig = sources[options.sourceStep];
-    if (!sourceConfig) {
-      const available = Object.keys(sources).join(", ");
+  if (parts.length >= 4) {
+    const chainType = parts[2];
+    if (chainType !== "before" && chainType !== "next") {
       throw new Error(
-        `Source "${options.sourceStep}" not found. Available: ${available}`
+        `Invalid chain type: "${chainType}". Use "before" or "next"`
       );
     }
-    if (!sourceConfig.package) {
-      throw new Error(`Source "${options.sourceStep}" has no package field`);
-    }
-    const { code, createTrigger } = await loadSourcePackage(
-      sourceConfig.package
-    );
-    if (!createTrigger) {
+    const transformerId = parts[3];
+    if (!transformerId) {
       throw new Error(
-        `Source package ${sourceConfig.package} has no createTrigger export. Ensure the package exports createTrigger from its /dev subpath.`
+        `Invalid step format: "${step}". Missing transformer name after "${chainType}."`
       );
     }
-    const result = await dn({
-      step: "source",
-      name: options.sourceStep,
-      code,
-      config: sourceConfig.config || {},
-      createTrigger,
-      input: sourceInput || { content: void 0 }
-    });
-    return {
-      success: !result.error,
-      error: result.error?.message,
-      capturedEvents: result.events,
-      duration: Date.now() - startTime
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: getErrorMessage(error),
-      duration: Date.now() - startTime
-    };
-  }
-}
-
-// 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) {
-  if (stepTarget) {
-    return findExampleInStep(config, exampleName, stepTarget);
-  }
-  return findExampleAcrossSteps(config, exampleName);
-}
-function findExampleInStep(config, exampleName, stepTarget) {
-  const dotIndex = stepTarget.indexOf(".");
-  if (dotIndex === -1) {
-    throw new Error(
-      `Invalid --step format: "${stepTarget}". Expected "type.name" (e.g. "destination.gtag")`
-    );
-  }
-  const type = stepTarget.substring(0, dotIndex);
-  const name = stepTarget.substring(dotIndex + 1);
-  const stepMap = getStepMap(config, type);
-  if (!stepMap) {
-    throw new Error(`No ${type}s found in flow config`);
+    return { type: prefix, name, chainType, transformerId };
   }
-  const step = stepMap[name];
-  if (!step) {
-    const available = Object.keys(stepMap).join(", ");
-    throw new Error(`${type} "${name}" not found. Available: ${available}`);
-  }
-  const examples = step.examples;
-  if (!examples || !examples[exampleName]) {
-    const available = examples ? Object.keys(examples).join(", ") : "none";
+  if (parts.length === 3) {
     throw new Error(
-      `Example "${exampleName}" not found in ${type} "${name}". Available: ${available}`
+      `Invalid step format: "${step}". Specify a transformer: "${step}.TRANSFORMER_NAME"`
     );
   }
-  return {
-    stepType: type,
-    stepName: name,
-    exampleName,
-    example: examples[exampleName]
-  };
+  return { type: prefix, name };
 }
-function findExampleAcrossSteps(config, exampleName) {
-  const matches = [];
-  const stepTypes = ["source", "transformer", "destination"];
-  for (const type of stepTypes) {
-    const stepMap = getStepMap(config, type);
-    if (!stepMap) continue;
-    for (const [name, step] of Object.entries(stepMap)) {
-      const examples = step.examples;
-      if (examples && examples[exampleName]) {
-        matches.push({
-          stepType: type,
-          stepName: name,
-          exampleName,
-          example: examples[exampleName]
-        });
+
+// src/commands/push/apply-overrides.ts
+function applyOverrides(config, overrides) {
+  if (overrides.destinations) {
+    const destinations = config.destinations;
+    if (destinations) {
+      for (const [id, override] of Object.entries(overrides.destinations)) {
+        const dest = destinations[id];
+        if (!dest) continue;
+        if (!dest.config) dest.config = {};
+        const destConfig = dest.config;
+        if (override.config?.disabled) destConfig.disabled = true;
+        if (override.config?.mock !== void 0)
+          destConfig.mock = override.config.mock;
+        if (override.env) {
+          destConfig.env = override.env;
+        }
       }
     }
   }
-  if (matches.length === 0) {
-    throw new Error(`Example "${exampleName}" not found in any step`);
-  }
-  if (matches.length > 1) {
-    const locations = matches.map((m2) => `${m2.stepType}.${m2.stepName}`).join(", ");
-    throw new Error(
-      `Example "${exampleName}" found in multiple steps: ${locations}. Use --step to disambiguate.`
-    );
-  }
-  return matches[0];
-}
-function getStepMap(config, type) {
-  switch (type) {
-    case "source":
-      return config.sources;
-    case "transformer":
-      return config.transformers;
-    case "destination":
-      return config.destinations;
-    default:
-      throw new Error(
-        `Invalid step type: "${type}". Must be "source", "transformer", or "destination"`
-      );
+  if (overrides.transformerMocks) {
+    const transformers = config.transformers;
+    if (transformers) {
+      for (const [chainPath, mocks] of Object.entries(
+        overrides.transformerMocks
+      )) {
+        for (const [transformerId, mockValue] of Object.entries(mocks)) {
+          const transformer = transformers[transformerId];
+          if (!transformer) continue;
+          if (!transformer.config) transformer.config = {};
+          const tConfig = transformer.config;
+          if (!tConfig.chainMocks) tConfig.chainMocks = {};
+          tConfig.chainMocks[chainPath] = mockValue;
+        }
+      }
+    }
   }
 }
 
-// src/commands/simulate/compare.ts
-function compareOutput(expected, actual) {
-  const expectedStr = JSON.stringify(expected, null, 2);
-  const actualStr = JSON.stringify(actual, null, 2);
-  if (expectedStr === actualStr) {
-    return { expected, actual, match: true };
+// src/commands/push/index.ts
+init_package_path();
+
+// src/commands/push/flow-context.ts
+init_utils2();
+import path14 from "path";
+import { pathToFileURL } from "url";
+import { JSDOM, VirtualConsole } from "jsdom";
+
+// src/commands/push/async-drain.ts
+function installTimerInterception(options = {}) {
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const realSetTimeout = globalThis.setTimeout.bind(globalThis);
+  const targets = [];
+  function patchTarget(target) {
+    targets.push({
+      target,
+      setTimeout: target.setTimeout,
+      clearTimeout: target.clearTimeout,
+      setInterval: target.setInterval,
+      clearInterval: target.clearInterval
+    });
+    target.setTimeout = (callback, delay, ...args) => {
+      if (typeof callback !== "function") return 0;
+      const id = nextId++;
+      pending.set(id, { id, callback, delay: delay ?? 0, type: "timeout", args, cleared: false });
+      return id;
+    };
+    target.clearTimeout = (id) => {
+      if (id == null) return;
+      const numId = typeof id === "number" ? id : Number(id);
+      const entry = pending.get(numId);
+      if (entry) entry.cleared = true;
+    };
+    target.setInterval = (callback, delay, ...args) => {
+      if (typeof callback !== "function") return 0;
+      const id = nextId++;
+      pending.set(id, { id, callback, delay: delay ?? 0, type: "interval", args, cleared: false });
+      return id;
+    };
+    target.clearInterval = target.clearTimeout;
+  }
+  patchTarget(globalThis);
+  if (options.domWindow && options.domWindow !== globalThis) {
+    patchTarget(options.domWindow);
+  }
+  const drainMicrotasks = () => new Promise((resolve3) => realSetTimeout(resolve3, 0));
+  async function flush(wallTimeout = 5e3) {
+    const deadline = Date.now() + wallTimeout;
+    const maxIterations = 100;
+    let iterations = 0;
+    while (iterations < maxIterations) {
+      await drainMicrotasks();
+      const ready = Array.from(pending.values()).filter((t) => !t.cleared).sort((a2, b2) => a2.delay - b2.delay);
+      if (ready.length === 0) break;
+      for (const timer of ready) {
+        if (timer.cleared) continue;
+        pending.delete(timer.id);
+        if (timer.type === "interval") {
+          timer.cleared = true;
+          const newId = nextId++;
+          pending.set(newId, { ...timer, id: newId, cleared: false });
+        }
+        try {
+          timer.callback(...timer.args);
+        } catch (err) {
+          console.warn("[async-drain] Timer callback error:", err);
+        }
+      }
+      await drainMicrotasks();
+      if (Date.now() > deadline) {
+        break;
+      }
+      iterations++;
+    }
+    pending.clear();
   }
-  return {
-    expected,
-    actual,
-    match: false,
-    diff: `Expected:
-${expectedStr}
-
-Actual:
-${actualStr}`
-  };
+  function countPending() {
+    return Array.from(pending.values()).filter((t) => !t.cleared).length;
+  }
+  function restore() {
+    for (const saved of targets) {
+      saved.target.setTimeout = saved.setTimeout;
+      saved.target.clearTimeout = saved.clearTimeout;
+      saved.target.setInterval = saved.setInterval;
+      saved.target.clearInterval = saved.clearInterval;
+    }
+    pending.clear();
+  }
+  return { flush, countPending, restore };
 }
 
-// src/commands/simulate/index.ts
-async function simulateCommand(options) {
-  const logger = createCLILogger({ ...options, stderr: true });
+// src/commands/push/flow-context.ts
+async function withFlowContext(options, fn) {
+  const { esmPath, platform, logger, snapshotCode, timeout, networkCalls, asyncDrain } = options;
   const startTime = Date.now();
-  try {
-    let config;
-    if (isStdinPiped() && !options.config) {
-      const stdinContent = await readStdin();
-      const fs15 = await import("fs-extra");
-      const path15 = await import("path");
-      const tmpPath = getTmpPath(void 0, "stdin-simulate.json");
-      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";
-    }
-    const result = await simulate(config, options.event, {
-      flow: options.flow,
-      json: options.json,
-      verbose: options.verbose,
-      silent: options.silent,
-      platform: options.platform,
-      step: options.step
+  const g2 = global;
+  let savedWindow, savedDocument, savedNavigator;
+  let savedFetch;
+  let dom;
+  let timerControl;
+  if (platform === "web") {
+    const virtualConsole = new VirtualConsole();
+    dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+      url: "http://localhost",
+      runScripts: "dangerously",
+      resources: "usable",
+      virtualConsole
     });
-    const resultWithDuration = {
-      ...result,
-      duration: (Date.now() - startTime) / 1e3
-    };
-    const formatted = formatSimulationResult(resultWithDuration, {
-      json: options.json
+    savedWindow = g2.window;
+    savedDocument = g2.document;
+    savedNavigator = g2.navigator;
+    g2.window = dom.window;
+    g2.document = dom.window.document;
+    Object.defineProperty(global, "navigator", {
+      value: dom.window.navigator,
+      configurable: true,
+      writable: true
     });
-    await writeResult(formatted + "\n", { output: options.output });
-    process.exit(result.success ? 0 : 1);
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    if (options.json) {
-      const errorOutput = JSON.stringify(
-        {
-          success: false,
-          error: errorMessage,
-          duration: (Date.now() - startTime) / 1e3
-        },
-        null,
-        2
-      );
-      await writeResult(errorOutput + "\n", { output: options.output });
-    } else {
-      logger.error(`Error: ${errorMessage}`);
+    if (networkCalls) {
+      savedFetch = global.fetch;
+      applyNetworkPolyfills(dom, networkCalls);
+      global.fetch = dom.window.fetch;
     }
-    process.exit(1);
   }
-}
-async function simulate(configOrPath, event, options = {}) {
-  if (typeof configOrPath !== "string") {
-    throw new Error(
-      "simulate() currently only supports config file paths. Please provide a path to a configuration file."
-    );
+  if (asyncDrain) {
+    timerControl = installTimerInterception({
+      domWindow: platform === "web" && dom ? dom.window : void 0
+    });
   }
-  let resolvedEvent = event;
-  if (typeof event === "string") {
-    resolvedEvent = await loadJsonFromSource(event, { name: "event" });
-  }
-  const isSourceSimulation = 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(", ")}`
-      );
+  try {
+    if (snapshotCode) {
+      if (platform === "web" && dom) {
+        logger.debug("Evaluating snapshot in JSDOM");
+        dom.window.eval(snapshotCode);
+      } else {
+        logger.debug("Evaluating snapshot in Node");
+        const vm = await import("vm");
+        vm.runInThisContext(snapshotCode);
+      }
     }
-    const flowSettings = setup.flows[flowName];
-    if (!flowSettings) {
+    const fileUrl = pathToFileURL(path14.resolve(esmPath)).href;
+    const module = await import(`${fileUrl}?t=${Date.now()}`);
+    const { wireConfig, startFlow } = module;
+    if (typeof wireConfig !== "function" || typeof startFlow !== "function") {
       throw new Error(
-        `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
+        "Invalid ESM bundle: missing wireConfig or startFlow exports"
       );
     }
-    const sourceStep = options.step.substring("source.".length);
-    result = await simulateSourceCLI(
-      flowSettings,
-      resolvedEvent,
-      {
-        flow: options.flow,
-        sourceStep,
-        json: options.json,
-        verbose: options.verbose,
-        silent: options.silent
+    const flowModule = {
+      wireConfig,
+      startFlow,
+      __configData: module.__configData
+    };
+    if (timerControl) {
+      const result = await fn(flowModule);
+      await timerControl.flush(asyncDrain?.timeout ?? 5e3);
+      return result;
+    } else if (timeout) {
+      const timeoutPromise = new Promise((_2, reject) => {
+        setTimeout(
+          () => reject(new Error(`Push timeout after ${timeout}ms`)),
+          timeout
+        );
+      });
+      return await Promise.race([fn(flowModule), timeoutPromise]);
+    }
+    return await fn(flowModule);
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  } finally {
+    if (timerControl) timerControl.restore();
+    if (savedFetch !== void 0) {
+      cleanupNetworkPolyfills(savedFetch);
+    }
+    if (platform === "web") {
+      if (savedWindow !== void 0) g2.window = savedWindow;
+      else delete g2.window;
+      if (savedDocument !== void 0) g2.document = savedDocument;
+      else delete g2.document;
+      if (savedNavigator !== void 0) {
+        Object.defineProperty(global, "navigator", {
+          value: savedNavigator,
+          configurable: true,
+          writable: true
+        });
+      } else {
+        delete g2.navigator;
       }
-    );
-  } else {
-    result = await simulateCore(configOrPath, resolvedEvent, {
-      json: options.json ?? false,
-      verbose: options.verbose ?? false,
-      silent: options.silent ?? false,
-      flow: options.flow,
-      platform: options.platform,
-      step: options.step
-    });
+    }
   }
-  return result;
+}
+function applyNetworkPolyfills(dom, networkCalls) {
+  dom.window.fetch = (async (input, init) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const method = init?.method || "GET";
+    const body = init?.body !== void 0 && init?.body !== null ? String(init.body) : null;
+    const headers = {};
+    if (init?.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach((v2, k2) => {
+          headers[k2] = v2;
+        });
+      } else if (typeof init.headers === "object") {
+        Object.entries(init.headers).forEach(
+          ([k2, v2]) => {
+            headers[k2] = v2;
+          }
+        );
+      }
+    }
+    networkCalls.push({
+      type: "fetch",
+      url,
+      method,
+      body,
+      headers,
+      timestamp: Date.now()
+    });
+    return new Response("", { status: 200, statusText: "OK" });
+  });
+  dom.window.navigator.sendBeacon = (url, data) => {
+    const body = data !== void 0 && data !== null ? String(data) : null;
+    networkCalls.push({ type: "beacon", url, body, timestamp: Date.now() });
+    return true;
+  };
+}
+function cleanupNetworkPolyfills(savedFetch) {
+  global.fetch = savedFetch;
 }
 
-// src/commands/push/index.ts
+// src/commands/push/prepare.ts
 init_cli_logger();
-init_core();
 init_tmp();
 init_config();
 init_bundler();
-import path12 from "path";
-import { JSDOM, VirtualConsole } from "jsdom";
-import fs13 from "fs-extra";
+import path15 from "path";
+import fs14 from "fs-extra";
 import { getPlatform as getPlatform3 } from "@walkeros/core";
-import { schemas as schemas2 } from "@walkeros/core/dev";
-import { Level as Level2 } from "@walkeros/core";
+async function prepareFlow(options) {
+  const logger = createCLILogger({
+    silent: options.silent,
+    verbose: options.verbose
+  });
+  logger.debug("Loading flow configuration");
+  const { flowSettings, buildOptions } = await loadFlowConfig(
+    options.configPath,
+    {
+      flowName: options.flow,
+      logger
+    }
+  );
+  const platform = getPlatform3(flowSettings);
+  const configDir = buildOptions.configDir || process.cwd();
+  const overrides = buildOverrides(
+    { simulate: options.simulate, mock: options.mock },
+    flowSettings
+  );
+  if (overrides.destinations) {
+    const { loadDestinationEnvs: loadDestinationEnvs2 } = await Promise.resolve().then(() => (init_env_loader(), env_loader_exports));
+    const envs = await loadDestinationEnvs2(
+      flowSettings.destinations ?? {},
+      flowSettings.packages,
+      configDir
+    );
+    for (const [destId, env] of Object.entries(envs)) {
+      if (overrides.destinations[destId] && env.push) {
+        overrides.destinations[destId].env = env.push;
+        if (env.simulation && env.simulation.length > 0) {
+          overrides.destinations[destId].simulation = env.simulation;
+        }
+      }
+    }
+  }
+  logger.debug("Bundling flow configuration");
+  const tempDir = getTmpPath(
+    void 0,
+    `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  );
+  await fs14.ensureDir(tempDir);
+  const bundlePath = path15.join(tempDir, "bundle.mjs");
+  const pushBuildOptions = {
+    ...buildOptions,
+    output: bundlePath,
+    format: "esm",
+    platform: platform === "web" ? "browser" : "node",
+    skipWrapper: true
+    // CLI imports ESM directly -- no platform wrapper
+  };
+  await bundleCore(flowSettings, pushBuildOptions, logger, false);
+  logger.debug(`Bundle created: ${bundlePath}`);
+  return {
+    bundlePath,
+    platform,
+    overrides,
+    flowSettings,
+    configDir,
+    cleanup: async () => {
+      await fs14.remove(tempDir).catch(() => {
+      });
+    }
+  };
+}
+
+// src/commands/push/index.ts
+import { schemas as schemas3 } from "@walkeros/core/dev";
+function resolveBeforeChain(before, transformers, ingest, event) {
+  if (!before) return [];
+  const next = before;
+  if (isRouteArray(next)) {
+    const compiled = compileNext(next);
+    const resolved = resolveNext(compiled, buildCacheContext(ingest, event));
+    if (!resolved) return [];
+    return Z(resolved, X(transformers));
+  }
+  return Z(
+    next,
+    X(transformers)
+  );
+}
 async function pushCore(inputPath, event, options = {}) {
   const logger = createCLILogger({
     silent: options.silent,
@@ -3643,53 +3614,45 @@ async function pushCore(inputPath, event, options = {}) {
   const startTime = Date.now();
   let tempDir;
   try {
-    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}`);
-    }
-    const parsedEvent = eventResult.data;
-    if (!parsedEvent.name) {
-      throw new Error('Invalid event: Missing required "name" property');
-    }
-    const validatedEvent = {
-      name: parsedEvent.name,
-      data: parsedEvent.data || {}
-    };
-    if (!validatedEvent.name.includes(" ")) {
-      logger.info(
-        `Warning: Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
-      );
-    }
     logger.debug("Detecting input type");
     const detected = await detectInput(
       inputPath,
       options.platform
     );
     let result;
+    let snapshotCode;
+    if (options.snapshot) {
+      snapshotCode = await loadConfig(options.snapshot, {
+        json: false
+      });
+      logger.debug(`Snapshot loaded (${snapshotCode.length} bytes)`);
+    }
     if (detected.type === "config") {
       result = await executeConfigPush(
         {
           config: inputPath,
           flow: options.flow,
-          verbose: options.verbose
+          verbose: options.verbose,
+          mock: options.mock
         },
-        validatedEvent,
+        event,
         logger,
         (dir) => {
           tempDir = dir;
-        }
+        },
+        snapshotCode
       );
     } else {
       result = await executeBundlePush(
         detected.content,
         detected.platform,
-        validatedEvent,
+        event,
         logger,
         (dir) => {
           tempDir = dir;
         },
-        { logger: { level: options.verbose ? Level2.DEBUG : Level2.ERROR } }
+        void 0,
+        snapshotCode
       );
     }
     return result;
@@ -3701,7 +3664,7 @@ async function pushCore(inputPath, event, options = {}) {
     };
   } finally {
     if (tempDir) {
-      await fs13.remove(tempDir).catch(() => {
+      await fs15.remove(tempDir).catch(() => {
       });
     }
   }
@@ -3712,21 +3675,63 @@ async function pushCommand(options) {
   try {
     let config;
     if (isStdinPiped() && !options.config) {
-      const stdinContent = await readStdin();
-      const tmpPath = getTmpPath(void 0, "stdin-push.json");
-      await fs13.ensureDir(path12.dirname(tmpPath));
-      await fs13.writeFile(tmpPath, stdinContent, "utf-8");
-      config = tmpPath;
+      config = await readStdinToTempFile("push");
     } else {
       config = options.config || "bundle.config.json";
     }
-    const result = await push(config, options.event, {
-      flow: options.flow,
-      json: options.json,
-      verbose: options.verbose,
-      silent: options.silent,
-      platform: options.platform
-    });
+    let resolvedEvent = options.event;
+    if (typeof options.event === "string") {
+      resolvedEvent = await loadJsonFromSource(options.event, {
+        name: "event"
+      });
+    }
+    const simulateFlag = options.simulate?.[0];
+    let result;
+    if (simulateFlag?.startsWith("source.")) {
+      result = await simulateSource(config, resolvedEvent, {
+        sourceId: simulateFlag.replace("source.", ""),
+        flow: options.flow,
+        silent: options.silent,
+        verbose: options.verbose,
+        snapshot: options.snapshot
+      });
+    } else if (simulateFlag?.startsWith("transformer.")) {
+      result = await simulateTransformer(
+        config,
+        resolvedEvent,
+        {
+          transformerId: simulateFlag.replace("transformer.", ""),
+          flow: options.flow,
+          mock: options.mock,
+          silent: options.silent,
+          verbose: options.verbose,
+          snapshot: options.snapshot
+        }
+      );
+    } else if (simulateFlag?.startsWith("destination.")) {
+      result = await simulateDestination(
+        config,
+        resolvedEvent,
+        {
+          destinationId: simulateFlag.replace("destination.", ""),
+          flow: options.flow,
+          mock: options.mock,
+          silent: options.silent,
+          verbose: options.verbose,
+          snapshot: options.snapshot
+        }
+      );
+    } else {
+      result = await push(config, resolvedEvent, {
+        flow: options.flow,
+        json: options.json,
+        verbose: options.verbose,
+        silent: options.silent,
+        platform: options.platform,
+        mock: options.mock,
+        snapshot: options.snapshot
+      });
+    }
     const duration = Date.now() - startTime;
     let output;
     if (options.json) {
@@ -3782,158 +3787,438 @@ 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."
     );
   }
-  let resolvedEvent = event;
-  if (typeof event === "string") {
-    resolvedEvent = await loadJsonFromSource(event, { name: "event" });
+  const parsed = schemas3.PartialEventSchema.safeParse(event);
+  if (!parsed.success) {
+    return {
+      success: false,
+      duration: 0,
+      error: `Invalid event: ${parsed.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join(", ")}`
+    };
   }
-  return await pushCore(configOrPath, resolvedEvent, {
+  return pushCore(configOrPath, event, {
     json: options.json ?? false,
     verbose: options.verbose ?? false,
     silent: options.silent ?? false,
     flow: options.flow,
-    platform: options.platform
+    platform: options.platform,
+    mock: options.mock,
+    snapshot: options.snapshot
   });
 }
-async function executeConfigPush(options, validatedEvent, logger, setTempDir) {
+async function executeConfigPush(options, validatedEvent, logger, setTempDir, snapshotCode) {
   logger.debug("Loading flow configuration");
   const { flowSettings, buildOptions } = await loadFlowConfig(options.config, {
     flowName: options.flow,
     logger
   });
-  const platform = getPlatform3(flowSettings);
+  const platform = getPlatform4(flowSettings);
+  const overrides = buildOverrides(
+    { mock: options.mock },
+    flowSettings
+  );
+  if (overrides.destinations) {
+    const { loadDestinationEnvs: loadDestinationEnvs2 } = await Promise.resolve().then(() => (init_env_loader(), env_loader_exports));
+    const configDir = buildOptions.configDir || process.cwd();
+    const envs = await loadDestinationEnvs2(
+      flowSettings.destinations ?? {},
+      flowSettings.packages,
+      configDir
+    );
+    for (const [destId, env] of Object.entries(envs)) {
+      if (overrides.destinations[destId] && env.push) {
+        overrides.destinations[destId].env = env.push;
+        if (env.simulation && env.simulation.length > 0) {
+          overrides.destinations[destId].simulation = env.simulation;
+        }
+      }
+    }
+  }
   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 fs13.ensureDir(tempDir);
-  const tempPath = path12.join(
-    tempDir,
-    `bundle.${platform === "web" ? "js" : "mjs"}`
-  );
+  await fs15.ensureDir(tempDir);
+  const tempPath = path16.join(tempDir, "bundle.mjs");
   const pushBuildOptions = {
     ...buildOptions,
     output: tempPath,
-    format: platform === "web" ? "iife" : "esm",
+    format: "esm",
     platform: platform === "web" ? "browser" : "node",
-    ...platform === "web" && {
-      windowCollector: "collector",
-      windowElb: "elb"
-    }
+    skipWrapper: true
+    // CLI imports ESM directly — no platform wrapper
   };
   await bundleCore(flowSettings, pushBuildOptions, logger, false);
   logger.debug(`Bundle created: ${tempPath}`);
-  if (platform === "web") {
-    logger.debug("Executing in web environment (JSDOM)");
-    return executeWebPush(tempPath, validatedEvent, logger);
-  } else if (platform === "server") {
-    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}`);
-  }
+  logger.debug(
+    `Executing in ${platform} environment (${platform === "web" ? "JSDOM" : "Node.js"})`
+  );
+  return executeDestinationPush(
+    tempPath,
+    validatedEvent,
+    logger,
+    platform,
+    overrides,
+    snapshotCode,
+    platform === "server" ? 6e4 : void 0
+  );
 }
-async function executeBundlePush(bundleContent, platform, validatedEvent, logger, setTempDir, context = {}) {
+async function executeBundlePush(bundleContent, platform, validatedEvent, logger, setTempDir, overrides = {}, snapshotCode) {
   const tempDir = getTmpPath(
     void 0,
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
-  await fs13.ensureDir(tempDir);
-  const tempPath = path12.join(
-    tempDir,
-    `bundle.${platform === "server" ? "mjs" : "js"}`
-  );
-  await fs13.writeFile(tempPath, bundleContent, "utf8");
+  await fs15.ensureDir(tempDir);
+  const tempPath = path16.join(tempDir, "bundle.mjs");
+  await fs15.writeFile(tempPath, bundleContent, "utf8");
   logger.debug(`Bundle written to: ${tempPath}`);
-  if (platform === "web") {
-    logger.debug("Executing in web environment (JSDOM)");
-    return executeWebPush(tempPath, validatedEvent, logger);
-  } else {
-    logger.debug("Executing in server environment (Node.js)");
-    return executeServerPush(tempPath, validatedEvent, logger, 6e4, context);
+  logger.debug(
+    `Executing in ${platform} environment (${platform === "web" ? "JSDOM" : "Node.js"})`
+  );
+  return executeDestinationPush(
+    tempPath,
+    validatedEvent,
+    logger,
+    platform,
+    overrides,
+    snapshotCode,
+    platform === "server" ? 6e4 : void 0
+  );
+}
+async function executeDestinationPush(esmPath, event, logger, platform, overrides, snapshotCode, timeout) {
+  const startTime = Date.now();
+  const networkCalls = [];
+  return withFlowContext(
+    { esmPath, platform, logger, snapshotCode, timeout, networkCalls, asyncDrain: { timeout: 5e3 } },
+    async (module) => {
+      const config = module.wireConfig(module.__configData ?? void 0);
+      applyOverrides(config, overrides || {});
+      const result = await module.startFlow(config);
+      if (!result?.collector?.push)
+        throw new Error("Invalid bundle: collector missing push");
+      const collector = result.collector;
+      logger.info(`Pushing event: ${event.name}`);
+      const elbResult = await collector.push(event);
+      await collector.command("shutdown");
+      return {
+        success: true,
+        elbResult,
+        ...networkCalls.length > 0 ? { networkCalls } : {},
+        duration: Date.now() - startTime
+      };
+    }
+  );
+}
+async function simulateSource(configPath, input, options) {
+  const startTime = Date.now();
+  const prepared = await prepareFlow({
+    configPath,
+    flow: options.flow,
+    simulate: ["source." + options.sourceId],
+    silent: options.silent,
+    verbose: options.verbose
+  });
+  try {
+    const logger = createCLILogger({
+      silent: options.silent,
+      verbose: options.verbose
+    });
+    const sourceConfig = (prepared.flowSettings.sources ?? {})[options.sourceId];
+    if (!sourceConfig?.package) {
+      throw new Error(
+        `Source "${options.sourceId}" has no package defined`
+      );
+    }
+    const devPath = resolvePackageImportPath(
+      sourceConfig.package,
+      prepared.flowSettings.packages,
+      prepared.configDir,
+      "/dev"
+    );
+    const devModule = await import(devPath);
+    const createTrigger = devModule.examples?.createTrigger || devModule.default?.examples?.createTrigger;
+    if (!createTrigger) {
+      throw new Error(
+        `Source package "${sourceConfig.package}" has no createTrigger in /dev export`
+      );
+    }
+    let snapshotCode;
+    if (options.snapshot) {
+      snapshotCode = await loadConfig(options.snapshot, {
+        json: false
+      });
+      logger.debug(`Snapshot loaded (${snapshotCode.length} bytes)`);
+    }
+    const networkCalls = [];
+    return await withFlowContext(
+      {
+        esmPath: prepared.bundlePath,
+        platform: prepared.platform,
+        logger,
+        snapshotCode,
+        networkCalls
+      },
+      async (module) => {
+        const config = module.wireConfig(module.__configData ?? void 0);
+        applyOverrides(config, prepared.overrides);
+        const captured = [];
+        config.hooks = {
+          ...config.hooks || {},
+          prePush: ({ fn }, event) => {
+            captured.push({ event, timestamp: Date.now() });
+            return { ok: true };
+          }
+        };
+        const instance = await createTrigger(config, { sourceId: options.sourceId });
+        const { trigger } = instance;
+        logger.info("Simulating source");
+        const inputRecord = input ?? {};
+        const content = inputRecord.content ?? input;
+        const triggerOpts = inputRecord.trigger;
+        await trigger(triggerOpts?.type, triggerOpts?.options)(content);
+        if (instance.flow?.collector?.command) {
+          await instance.flow.collector.command("shutdown");
+        }
+        return {
+          success: true,
+          ...captured.length > 0 ? { captured } : {},
+          ...networkCalls.length > 0 ? { networkCalls } : {},
+          duration: Date.now() - startTime
+        };
+      }
+    );
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  } finally {
+    await prepared.cleanup();
   }
 }
-async function executeWebPush(bundlePath, event, logger) {
+async function simulateTransformer(configPath, event, options) {
   const startTime = Date.now();
+  const parsed = schemas3.PartialEventSchema.safeParse(event);
+  if (!parsed.success) {
+    return {
+      success: false,
+      duration: 0,
+      error: parsed.error.message
+    };
+  }
+  const prepared = await prepareFlow({
+    configPath,
+    flow: options.flow,
+    simulate: ["transformer." + options.transformerId],
+    mock: options.mock,
+    silent: options.silent,
+    verbose: options.verbose
+  });
   try {
-    const virtualConsole = new VirtualConsole();
-    const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
-      url: "http://localhost",
-      runScripts: "dangerously",
-      resources: "usable",
-      virtualConsole
+    const logger = createCLILogger({
+      silent: options.silent,
+      verbose: options.verbose
     });
-    const { window } = dom;
-    logger.debug("Loading bundle...");
-    const bundleCode = await fs13.readFile(bundlePath, "utf8");
-    window.eval(bundleCode);
-    logger.debug("Waiting for collector...");
-    await waitForWindowProperty(
-      window,
-      "collector",
-      5e3
+    let snapshotCode;
+    if (options.snapshot) {
+      snapshotCode = await loadConfig(options.snapshot, {
+        json: false
+      });
+      logger.debug(`Snapshot loaded (${snapshotCode.length} bytes)`);
+    }
+    const networkCalls = [];
+    return await withFlowContext(
+      {
+        esmPath: prepared.bundlePath,
+        platform: prepared.platform,
+        logger,
+        snapshotCode,
+        networkCalls
+      },
+      async (module) => {
+        const config = module.wireConfig(module.__configData ?? void 0);
+        applyOverrides(config, prepared.overrides);
+        if (config.sources) config.sources = {};
+        if (config.destinations) config.destinations = {};
+        const result = await module.startFlow(config);
+        if (!result?.collector)
+          throw new Error("Invalid bundle: collector not available");
+        const collector = result.collector;
+        const transformer = collector.transformers?.[options.transformerId];
+        if (!transformer) {
+          throw new Error(
+            `Transformer "${options.transformerId}" not found in collector. Available: ${Object.keys(collector.transformers || {}).join(", ") || "none"}`
+          );
+        }
+        const initialized = await ee(
+          collector,
+          transformer,
+          options.transformerId
+        );
+        if (!initialized) {
+          throw new Error(
+            `Transformer "${options.transformerId}" failed to initialize`
+          );
+        }
+        const inputEvent = event;
+        const ingest = createIngest(options.transformerId);
+        const captured = [];
+        captured.push({ event: { ...inputEvent }, timestamp: Date.now() });
+        logger.info(`Simulating transformer: ${options.transformerId}`);
+        let processedEvent = inputEvent;
+        const before = transformer.config.before;
+        if (before && collector.transformers) {
+          const beforeChainIds = resolveBeforeChain(
+            before,
+            collector.transformers,
+            ingest,
+            processedEvent
+          );
+          if (beforeChainIds.length > 0) {
+            const beforeResult = await te(
+              collector,
+              collector.transformers,
+              beforeChainIds,
+              processedEvent,
+              ingest,
+              void 0,
+              `transformer.${options.transformerId}.before`
+            );
+            if (beforeResult === null) {
+              captured.push({ event: null, timestamp: Date.now() });
+              await collector.command("shutdown");
+              return {
+                success: true,
+                captured,
+                duration: Date.now() - startTime
+              };
+            }
+            processedEvent = Array.isArray(beforeResult) ? beforeResult[0] : beforeResult;
+          }
+        }
+        const pushResult = await ne(
+          collector,
+          transformer,
+          options.transformerId,
+          processedEvent,
+          ingest
+        );
+        if (pushResult === false) {
+          captured.push({ event: null, timestamp: Date.now() });
+        } else if (Array.isArray(pushResult)) {
+          for (const r2 of pushResult) {
+            captured.push({
+              event: r2.event || processedEvent,
+              timestamp: Date.now()
+            });
+          }
+        } else if (pushResult && typeof pushResult === "object" && pushResult.event) {
+          captured.push({ event: pushResult.event, timestamp: Date.now() });
+        } else {
+          captured.push({ event: processedEvent, timestamp: Date.now() });
+        }
+        await collector.command("shutdown");
+        return {
+          success: true,
+          captured,
+          ...networkCalls.length > 0 ? { networkCalls } : {},
+          duration: Date.now() - startTime
+        };
+      }
     );
-    const windowObj = window;
-    const collector = windowObj.collector;
-    logger.info(`Pushing event: ${event.name}`);
-    const elbResult = await collector.push({
-      name: event.name,
-      data: event.data
-    });
-    return {
-      success: true,
-      elbResult,
-      duration: Date.now() - startTime
-    };
   } catch (error) {
     return {
       success: false,
       duration: Date.now() - startTime,
       error: getErrorMessage(error)
     };
+  } finally {
+    await prepared.cleanup();
   }
 }
-async function executeServerPush(bundlePath, event, logger, timeout = 6e4, context = {}) {
+async function simulateDestination(configPath, event, options) {
   const startTime = Date.now();
-  let timer;
+  const parsed = schemas3.PartialEventSchema.safeParse(event);
+  if (!parsed.success) {
+    return {
+      success: false,
+      duration: 0,
+      error: parsed.error.message
+    };
+  }
+  const prepared = await prepareFlow({
+    configPath,
+    flow: options.flow,
+    simulate: ["destination." + options.destinationId],
+    mock: options.mock,
+    silent: options.silent,
+    verbose: options.verbose
+  });
   try {
-    const timeoutPromise = new Promise((_2, reject) => {
-      timer = setTimeout(
-        () => reject(new Error(`Server push timeout after ${timeout}ms`)),
-        timeout
-      );
+    const logger = createCLILogger({
+      silent: options.silent,
+      verbose: options.verbose
     });
-    const executePromise = (async () => {
-      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");
-      }
-      logger.debug("Calling factory function...");
-      const result = await flowModule.default(context);
-      if (!result || !result.collector || typeof result.collector.push !== "function") {
-        throw new Error(
-          "Factory function did not return valid result with collector"
-        );
-      }
-      const { collector } = result;
-      logger.info(`Pushing event: ${event.name}`);
-      const elbResult = await collector.push({
-        name: event.name,
-        data: event.data
+    let snapshotCode;
+    if (options.snapshot) {
+      snapshotCode = await loadConfig(options.snapshot, {
+        json: false
       });
-      return {
-        success: true,
-        elbResult,
-        duration: Date.now() - startTime
-      };
-    })();
-    return await Promise.race([executePromise, timeoutPromise]);
+    }
+    const networkCalls = [];
+    return await withFlowContext(
+      {
+        esmPath: prepared.bundlePath,
+        platform: prepared.platform,
+        logger,
+        snapshotCode,
+        networkCalls
+      },
+      async (module) => {
+        const config = module.wireConfig(module.__configData ?? void 0);
+        applyOverrides(config, prepared.overrides);
+        const destOverride = prepared.overrides.destinations?.[options.destinationId];
+        let trackedCalls = [];
+        if (destOverride?.simulation?.length) {
+          const destinations = config.destinations;
+          const destConfig = destinations[options.destinationId]?.config;
+          if (destConfig?.env) {
+            const combined = {
+              ...destConfig.env,
+              simulation: destOverride.simulation
+            };
+            const { wrappedEnv, calls } = Ge(combined);
+            destConfig.env = wrappedEnv;
+            trackedCalls = calls;
+          }
+        }
+        if (config.sources) config.sources = {};
+        const result = await module.startFlow(config);
+        if (!result?.collector)
+          throw new Error("Invalid bundle: collector not available");
+        const collector = result.collector;
+        if (!collector.destinations[options.destinationId] && !collector.pending.destinations[options.destinationId]) {
+          throw new Error(
+            `Destination "${options.destinationId}" not found in collector. Available: ${Object.keys(collector.destinations || {}).join(", ") || "none"}`
+          );
+        }
+        logger.info(`Simulating destination: ${options.destinationId}`);
+        const elbResult = await collector.push(event, {
+          include: [options.destinationId]
+        });
+        await collector.command("shutdown");
+        return {
+          success: true,
+          elbResult,
+          ...trackedCalls.length > 0 ? { usage: { [options.destinationId]: trackedCalls } } : {},
+          ...networkCalls.length > 0 ? { networkCalls } : {},
+          duration: Date.now() - startTime
+        };
+      }
+    );
   } catch (error) {
     return {
       success: false,
@@ -3941,35 +4226,17 @@ async function executeServerPush(bundlePath, event, logger, timeout = 6e4, conte
       error: getErrorMessage(error)
     };
   } finally {
-    clearTimeout(timer);
+    await prepared.cleanup();
   }
 }
-function waitForWindowProperty(window, prop, timeout = 5e3) {
-  return new Promise((resolve2, reject) => {
-    const start = Date.now();
-    const check = () => {
-      if (window[prop] !== void 0) {
-        resolve2();
-      } else if (Date.now() - start > timeout) {
-        reject(
-          new Error(
-            `Timeout waiting for window.${prop}. IIFE may have failed to execute.`
-          )
-        );
-      } else {
-        setImmediate(check);
-      }
-    };
-    check();
-  });
-}
 
 // src/commands/run/index.ts
 init_cli_logger();
 init_core();
+init_tmp();
 init_config_file();
 init_auth();
-import path14 from "path";
+import path18 from "path";
 import { writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
@@ -4017,12 +4284,12 @@ async function resolveBundle(bundleEnv) {
     return { path: bundleEnv, source: "file" };
   }
   if (isUrl2(bundleEnv)) {
-    const path15 = await fetchBundle(bundleEnv, writePath);
-    return { path: path15, source: "url" };
+    const path19 = await fetchBundle(bundleEnv, writePath);
+    return { path: path19, source: "url" };
   }
   if (isStdinPiped()) {
-    const path15 = await readBundleFromStdin(writePath);
-    return { path: path15, source: "stdin" };
+    const path19 = await readBundleFromStdin(writePath);
+    return { path: path19, source: "stdin" };
   }
   return { path: bundleEnv, source: "file" };
 }
@@ -4186,12 +4453,14 @@ function validatePort(port) {
 init_utils3();
 
 // src/commands/run/pipeline.ts
+init_tmp();
 import { writeFileSync as writeFileSync4 } from "fs";
+import fs17 from "fs-extra";
 
 // src/runtime/health-server.ts
 import http from "http";
 function createHealthServer(port, logger) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let flowHandler = null;
     const server = http.createServer((req, res) => {
       if (req.url === "/health" && req.method === "GET") {
@@ -4218,7 +4487,7 @@ function createHealthServer(port, logger) {
     server.headersTimeout = 1e4;
     server.listen(port, "0.0.0.0", () => {
       logger.info(`Health server listening on port ${port}`);
-      resolve2({
+      resolve3({
         server,
         setFlowHandler(handler) {
           flowHandler = handler;
@@ -4233,28 +4502,45 @@ function createHealthServer(port, logger) {
 }
 
 // src/runtime/runner.ts
-import { pathToFileURL } from "url";
-import { resolve, dirname as dirname2 } from "path";
-async function loadFlow(file, config, logger, loggerConfig, healthServer) {
+import { resolve as resolve2, dirname as dirname2 } from "path";
+
+// src/runtime/load-bundle.ts
+import { resolve } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function loadBundle(file, context, logger) {
   const absolutePath = resolve(file);
-  const flowDir = dirname2(absolutePath);
-  process.chdir(flowDir);
-  const fileUrl = pathToFileURL(absolutePath).href;
+  const fileUrl = pathToFileURL2(absolutePath).href;
+  logger?.debug?.(`Importing bundle: ${absolutePath}`);
   const module = await import(`${fileUrl}?t=${Date.now()}`);
   if (!module.default || typeof module.default !== "function") {
     throw new Error(
-      `Invalid flow bundle: ${file} must export a default function`
+      `Invalid bundle: ${file} must export a default factory function`
     );
   }
+  logger?.debug?.("Calling factory function...");
+  const result = await module.default(context ?? {});
+  if (!result || !result.collector || typeof result.collector.push !== "function") {
+    throw new Error(
+      `Invalid bundle: factory must return { collector } with a push function`
+    );
+  }
+  return {
+    collector: result.collector,
+    ...typeof result.httpHandler === "function" ? { httpHandler: result.httpHandler } : {}
+  };
+}
+
+// src/runtime/runner.ts
+async function loadFlow(file, config, logger, loggerConfig, healthServer) {
+  const absolutePath = resolve2(file);
+  const flowDir = dirname2(absolutePath);
+  process.chdir(flowDir);
   const flowContext = {
     ...config,
     ...loggerConfig ? { logger: loggerConfig } : {},
-    ...healthServer ? { externalServer: true } : {}
+    ...healthServer ? { sourceSettings: { port: void 0 } } : {}
   };
-  const result = await module.default(flowContext);
-  if (!result || !result.collector) {
-    throw new Error(`Invalid flow bundle: ${file} must return { collector }`);
-  }
+  const result = await loadBundle(absolutePath, flowContext, logger);
   if (healthServer && typeof result.httpHandler === "function") {
     healthServer.setFlowHandler(result.httpHandler);
   }
@@ -4520,6 +4806,8 @@ async function runPipeline(options) {
   logger.info(`Port: ${port}`);
   let heartbeat = null;
   let poller = null;
+  let currentBundleCleanup;
+  let currentConfigPath;
   if (api) {
     heartbeat = createHeartbeat(
       {
@@ -4554,28 +4842,44 @@ async function runPipeline(options) {
             );
             return;
           }
-          const tmpConfigPath = `/tmp/walkeros-flow-${Date.now()}.json`;
+          const tmpConfigPath = getTmpPath(
+            void 0,
+            `walkeros-flow-${Date.now()}.json`
+          );
           writeFileSync4(
             tmpConfigPath,
             JSON.stringify(content, null, 2),
             "utf-8"
           );
-          const newBundle = await api.prepareBundleForRun(tmpConfigPath, {
+          const newBundleResult = await api.prepareBundleForRun(tmpConfigPath, {
             verbose: false,
             silent: true,
             flowName: api.flowName
           });
           handle = await swapFlow(
             handle,
-            newBundle,
+            newBundleResult.bundlePath,
             runtimeConfig,
             logger,
             loggerConfig,
             healthServer
           );
-          writeCache(api.cacheDir, newBundle, JSON.stringify(content), version);
+          writeCache(
+            api.cacheDir,
+            newBundleResult.bundlePath,
+            JSON.stringify(content),
+            version
+          );
           configVersion = version;
           if (heartbeat) heartbeat.updateConfigVersion(version);
+          if (currentBundleCleanup)
+            await currentBundleCleanup().catch(() => {
+            });
+          if (currentConfigPath)
+            await fs17.remove(currentConfigPath).catch(() => {
+            });
+          currentBundleCleanup = newBundleResult.cleanup;
+          currentConfigPath = tmpConfigPath;
           logger.info(`Hot-swapped to version ${version}`);
         }
       },
@@ -4597,6 +4901,10 @@ async function runPipeline(options) {
         await handle.collector.command("shutdown");
       }
       await healthServer.close();
+      if (currentBundleCleanup) await currentBundleCleanup().catch(() => {
+      });
+      if (currentConfigPath) await fs17.remove(currentConfigPath).catch(() => {
+      });
       logger.info("Shutdown complete");
       clearTimeout(forceTimer);
       process.exit(0);
@@ -4745,15 +5053,16 @@ async function resolveBundlePath(configInput, apiConfig, logger) {
       logger.info(`Bundle: ${resolved.path}`);
     }
     if (isPreBuiltConfig(resolved.path)) {
-      return path14.resolve(resolved.path);
+      return path18.resolve(resolved.path);
     }
     const flowFile = validateFlowFile(resolved.path);
     logger.debug("Building flow bundle");
-    return lazyPrepareBundleForRun(flowFile, {
+    const result = await lazyPrepareBundleForRun(flowFile, {
       verbose: false,
       silent: true,
       flowName: apiConfig?.flowName
     });
+    return result.bundlePath;
   }
   if (apiConfig) {
     logger.info("Fetching config from API...");
@@ -4765,7 +5074,10 @@ async function resolveBundlePath(configInput, apiConfig, logger) {
         flowId: apiConfig.flowId
       });
       if (result.changed) {
-        const tmpConfigPath = `/tmp/walkeros-flow-${Date.now()}.json`;
+        const tmpConfigPath = getTmpPath(
+          void 0,
+          `walkeros-flow-${Date.now()}.json`
+        );
         writeFileSync5(
           tmpConfigPath,
           JSON.stringify(result.content, null, 2),
@@ -4773,7 +5085,7 @@ async function resolveBundlePath(configInput, apiConfig, logger) {
         );
         logger.info(`Config version: ${result.version}`);
         logger.info("Building flow...");
-        const bundlePath = await lazyPrepareBundleForRun(tmpConfigPath, {
+        const bundleResult = await lazyPrepareBundleForRun(tmpConfigPath, {
           verbose: false,
           silent: true,
           flowName: apiConfig.flowName
@@ -4782,14 +5094,14 @@ async function resolveBundlePath(configInput, apiConfig, logger) {
           const { writeCache: writeCache2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
           writeCache2(
             apiConfig.cacheDir,
-            bundlePath,
+            bundleResult.bundlePath,
             JSON.stringify(result.content),
             result.version
           );
         } catch {
           logger.debug("Cache write failed (non-critical)");
         }
-        return bundlePath;
+        return bundleResult.bundlePath;
       }
     } catch (error) {
       logger.error(
@@ -4807,7 +5119,7 @@ async function resolveBundlePath(configInput, apiConfig, logger) {
   }
   const defaultFile = "server-collect.mjs";
   logger.debug(`No config specified, using default: ${defaultFile}`);
-  return path14.resolve(defaultFile);
+  return path18.resolve(defaultFile);
 }
 async function run(options) {
   const startTime = Date.now();
@@ -4998,73 +5310,15 @@ function validateEntityActions(obj, prefix, errors) {
 }
 
 // src/commands/validate/validators/event.ts
-import { schemas as schemas3 } from "@walkeros/core/dev";
-var { PartialEventSchema } = schemas3;
-function validateEvent(input) {
-  const errors = [];
-  const warnings = [];
-  const details = {};
-  const event = typeof input === "object" && input !== null ? input : {};
-  if (!("name" in event) || event.name === void 0) {
-    errors.push({
-      path: "name",
-      message: "Event must have a name field",
-      code: "MISSING_EVENT_NAME"
-    });
-  } else if (typeof event.name !== "string" || event.name.trim() === "") {
-    errors.push({
-      path: "name",
-      message: "Event name cannot be empty",
-      value: event.name,
-      code: "EMPTY_EVENT_NAME"
-    });
-  } else {
-    const name = event.name;
-    if (!name.includes(" ")) {
-      errors.push({
-        path: "name",
-        message: 'Event name must be "entity action" format with space (e.g., "page view")',
-        value: name,
-        code: "INVALID_EVENT_NAME"
-      });
-      details.entity = null;
-      details.action = null;
-    } else {
-      const parts = name.trim().split(/\s+/);
-      const action = parts.pop();
-      const entity = parts.join(" ");
-      details.entity = entity;
-      details.action = action;
-    }
-  }
-  const zodResult = PartialEventSchema.safeParse(input);
-  if (!zodResult.success) {
-    for (const issue of zodResult.error.issues) {
-      const path15 = issue.path.join(".");
-      if (path15 === "name") continue;
-      errors.push({
-        path: path15 || "root",
-        message: issue.message,
-        code: "SCHEMA_VALIDATION"
-      });
-    }
-  }
-  if (!event.consent) {
-    warnings.push({
-      path: "consent",
-      message: "No consent object provided",
-      suggestion: "Consider adding a consent object for GDPR/privacy compliance"
-    });
-  }
-  details.hasConsent = !!event.consent;
-  details.hasData = !!event.data;
-  details.hasContext = !!event.context;
+init_event_validation();
+function validateEvent2(input) {
+  const result = validateEvent(input, "strict");
   return {
-    valid: errors.length === 0,
+    valid: result.valid,
     type: "event",
-    errors,
-    warnings,
-    details
+    errors: result.errors,
+    warnings: result.warnings,
+    details: result.details
   };
 }
 
@@ -5251,10 +5505,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 path15 = `${conn.from.type}.${conn.from.name} \u2192 ${conn.to.type}.${conn.to.name}`;
+  const path19 = `${conn.from.type}.${conn.from.name} \u2192 ${conn.to.type}.${conn.to.name}`;
   if (fromOuts.length === 0 || toIns.length === 0) {
     warnings.push({
-      path: path15,
+      path: path19,
       message: "Cannot check compatibility: missing out or in examples",
       suggestion: "Add out examples to the source step or in examples to the target step"
     });
@@ -5272,7 +5526,7 @@ function checkCompatibility(conn, errors, warnings) {
   }
   if (!hasMatch) {
     errors.push({
-      path: path15,
+      path: path19,
       message: "No compatible out/in pair found between connected steps",
       code: "INCOMPATIBLE_EXAMPLES"
     });
@@ -5368,13 +5622,13 @@ function validateMapping(input) {
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
 var SECTIONS = ["destinations", "sources", "transformers"];
-function resolveEntry(path15, flowConfig) {
+function resolveEntry(path19, 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 = path15.split(".");
+  const parts = path19.split(".");
   if (parts.length === 2) {
     const [section, key] = parts;
     if (!SECTIONS.includes(section)) {
@@ -5411,15 +5665,15 @@ function resolveEntry(path15, flowConfig) {
     }
     return { section: matches[0].section, key, entry: matches[0].entry };
   }
-  return `Invalid path "${path15}". Use "section.key" or just "key"`;
+  return `Invalid path "${path19}". Use "section.key" or just "key"`;
 }
-async function validateEntry(path15, flowConfig) {
-  const resolved = resolveEntry(path15, flowConfig);
+async function validateEntry(path19, flowConfig) {
+  const resolved = resolveEntry(path19, flowConfig);
   if (typeof resolved === "string") {
     return {
       valid: false,
       type: "entry",
-      errors: [{ path: path15, message: resolved, code: "ENTRY_VALIDATION" }],
+      errors: [{ path: path19, message: resolved, code: "ENTRY_VALIDATION" }],
       warnings: [],
       details: {}
     };
@@ -5450,7 +5704,7 @@ async function validateEntry(path15, flowConfig) {
       type: "entry",
       errors: [
         {
-          path: path15,
+          path: path19,
           message: error instanceof Error ? error.message : "Unknown error",
           code: "ENTRY_VALIDATION"
         }
@@ -5475,10 +5729,10 @@ async function validateEntry(path15, flowConfig) {
   const validate2 = ajv.compile(settingsSchema);
   const isValid = validate2(settings || {});
   if (!isValid) {
-    const errors = (validate2.errors || []).map((e2) => ({
-      path: e2.instancePath || "/",
-      message: e2.message || "Unknown error",
-      code: e2.keyword
+    const errors = (validate2.errors || []).map((e) => ({
+      path: e.instancePath || "/",
+      message: e.message || "Unknown error",
+      code: e.keyword
     }));
     return {
       valid: false,
@@ -5513,7 +5767,7 @@ async function validate(type, input, options = {}) {
     case "contract":
       return validateContract(resolved);
     case "event":
-      return validateEvent(resolved);
+      return validateEvent2(resolved);
     case "flow":
       return validateFlow(resolved, { flow: options.flow });
     case "mapping":
@@ -5798,10 +6052,10 @@ async function deleteProject(options = {}) {
     throw new Error(error.error?.message || "Failed to delete project");
   return data ?? { success: true };
 }
-async function handleResult(fn2, options) {
+async function handleResult(fn, options) {
   const logger = createCLILogger(options);
   try {
-    const result = await fn2();
+    const result = await fn();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
     logger.error(error instanceof Error ? error.message : String(error));
@@ -5957,10 +6211,10 @@ async function duplicateFlow(options) {
   if (error) throwApiError(error, "Failed to duplicate flow");
   return data;
 }
-async function handleResult2(fn2, options) {
+async function handleResult2(fn, options) {
   const logger = createCLILogger(options);
   try {
-    const result = await fn2();
+    const result = await fn();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
     logger.error(error instanceof Error ? error.message : String(error));
@@ -6119,8 +6373,8 @@ async function deploy(options) {
   if (error) {
     try {
       throwApiError(error, "Failed to start deployment");
-    } catch (e2) {
-      if (e2 instanceof ApiError && e2.code === "AMBIGUOUS_CONFIG") {
+    } catch (e) {
+      if (e instanceof ApiError && e.code === "AMBIGUOUS_CONFIG") {
         const names = await getAvailableFlowNames({
           flowId: options.flowId,
           projectId
@@ -6131,7 +6385,7 @@ Available: ${names.join(", ")}`,
           { code: "AMBIGUOUS_CONFIG" }
         );
       }
-      throw e2;
+      throw e;
     }
   }
   if (!options.wait) return data;
@@ -6268,7 +6522,7 @@ async function getDeploymentCommand(flowId, options) {
 // src/commands/deployments/index.ts
 init_auth();
 init_http();
-import { getPlatform as getPlatform4 } from "@walkeros/core";
+import { getPlatform as getPlatform5 } from "@walkeros/core";
 init_cli_logger();
 init_output();
 init_loader();
@@ -6324,10 +6578,10 @@ async function deleteDeployment(options) {
   const data = await response.json().catch(() => null);
   return data ?? { success: true };
 }
-async function handleResult3(fn2, options) {
+async function handleResult3(fn, options) {
   const logger = createCLILogger(options);
   try {
-    const result = await fn2();
+    const result = await fn();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
     logger.error(error instanceof Error ? error.message : String(error));
@@ -6401,7 +6655,7 @@ async function createDeployCommand(config, options) {
       const result2 = await loadFlowConfig(config, {
         flowName: options.flow
       });
-      type = getPlatform4(result2.flowSettings);
+      type = getPlatform5(result2.flowSettings);
     }
     const deployment = await createDeployment({
       type,
@@ -6502,14 +6756,14 @@ async function feedbackCommand(text) {
   }
 }
 function promptUser(question) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stderr
     });
     rl.question(question, (answer) => {
       rl.close();
-      resolve2(answer);
+      resolve3(answer);
     });
   });
 }
@@ -6522,6 +6776,108 @@ init_api_client();
 init_config_file();
 init_sse();
 init_utils();
+
+// src/commands/simulate/example-loader.ts
+function findExample(config, exampleName, stepTarget) {
+  if (stepTarget) {
+    return findExampleInStep(config, exampleName, stepTarget);
+  }
+  return findExampleAcrossSteps(config, exampleName);
+}
+function findExampleInStep(config, exampleName, stepTarget) {
+  const dotIndex = stepTarget.indexOf(".");
+  if (dotIndex === -1) {
+    throw new Error(
+      `Invalid --step format: "${stepTarget}". Expected "type.name" (e.g. "destination.gtag")`
+    );
+  }
+  const type = stepTarget.substring(0, dotIndex);
+  const name = stepTarget.substring(dotIndex + 1);
+  const stepMap = getStepMap(config, type);
+  if (!stepMap) {
+    throw new Error(`No ${type}s found in flow config`);
+  }
+  const step = stepMap[name];
+  if (!step) {
+    const available = Object.keys(stepMap).join(", ");
+    throw new Error(`${type} "${name}" not found. Available: ${available}`);
+  }
+  const examples = step.examples;
+  if (!examples || !examples[exampleName]) {
+    const available = examples ? Object.keys(examples).join(", ") : "none";
+    throw new Error(
+      `Example "${exampleName}" not found in ${type} "${name}". Available: ${available}`
+    );
+  }
+  return {
+    stepType: type,
+    stepName: name,
+    exampleName,
+    example: examples[exampleName]
+  };
+}
+function findExampleAcrossSteps(config, exampleName) {
+  const matches = [];
+  const stepTypes = ["source", "transformer", "destination"];
+  for (const type of stepTypes) {
+    const stepMap = getStepMap(config, type);
+    if (!stepMap) continue;
+    for (const [name, step] of Object.entries(stepMap)) {
+      const examples = step.examples;
+      if (examples && examples[exampleName]) {
+        matches.push({
+          stepType: type,
+          stepName: name,
+          exampleName,
+          example: examples[exampleName]
+        });
+      }
+    }
+  }
+  if (matches.length === 0) {
+    throw new Error(`Example "${exampleName}" not found in any step`);
+  }
+  if (matches.length > 1) {
+    const locations = matches.map((m2) => `${m2.stepType}.${m2.stepName}`).join(", ");
+    throw new Error(
+      `Example "${exampleName}" found in multiple steps: ${locations}. Use --step to disambiguate.`
+    );
+  }
+  return matches[0];
+}
+function getStepMap(config, type) {
+  switch (type) {
+    case "source":
+      return config.sources;
+    case "transformer":
+      return config.transformers;
+    case "destination":
+      return config.destinations;
+    default:
+      throw new Error(
+        `Invalid step type: "${type}". Must be "source", "transformer", or "destination"`
+      );
+  }
+}
+
+// src/commands/simulate/compare.ts
+function compareOutput(expected, actual) {
+  const expectedStr = JSON.stringify(expected, null, 2);
+  const actualStr = JSON.stringify(actual, null, 2);
+  if (expectedStr === actualStr) {
+    return { expected, actual, match: true };
+  }
+  return {
+    expected,
+    actual,
+    match: false,
+    diff: `Expected:
+${expectedStr}
+
+Actual:
+${actualStr}`
+  };
+}
 export {
   ApiError,
   apiFetch,
@@ -6567,6 +6923,7 @@ export {
   listFlowsCommand,
   listProjects,
   listProjectsCommand,
+  loadConfig,
   loadJsonConfig,
   loginCommand,
   logoutCommand,
@@ -6579,8 +6936,9 @@ export {
   requireProjectId,
   run,
   runCommand,
-  simulate,
-  simulateCommand,
+  simulateDestination,
+  simulateSource,
+  simulateTransformer,
   throwApiError,
   updateFlow,
   updateFlowCommand,