@walkeros/cli 2.0.0 → 2.1.0

package/dist/index.js

@@ -1,182 +1,58 @@
-// src/commands/bundle/index.ts
-import path10 from "path";
-import fs9 from "fs-extra";
-import { getPlatform as getPlatform2 } from "@walkeros/core";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
+  get: (a2, b2) => (typeof require !== "undefined" ? require : a2)[b2]
+}) : x2)(function(x2) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x2 + '" is not supported');
+});
+var __esm = (fn2, res) => function __init() {
+  return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// src/core/logger.ts
+// src/core/cli-logger.ts
 import chalk from "chalk";
-var BRAND_COLOR = "#01b5e2";
-function createLogger(options = {}) {
+import { createLogger, Level } from "@walkeros/core";
+function createCLILogger(options = {}) {
   const {
     verbose = false,
     silent = false,
     json = false,
     stderr = false
   } = options;
-  const shouldLog = !silent && !json;
-  const shouldDebug = verbose && !silent && !json;
   const out = stderr ? console.error : console.log;
-  return {
-    log: (...args) => {
-      if (shouldLog) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(message);
-      }
-    },
-    brand: (...args) => {
-      if (shouldLog) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(chalk.hex(BRAND_COLOR)(message));
-      }
-    },
-    error: (...args) => {
-      if (!json) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        console.error(chalk.red(message));
-      }
-    },
-    debug: (...args) => {
-      if (shouldDebug) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(`  ${message}`);
-      }
-    },
-    json: (data) => {
-      if (!silent) {
-        out(JSON.stringify(data, null, 2));
-      }
-    },
-    // Backward-compatible methods (all use default terminal color per design)
-    info: (...args) => {
-      if (shouldLog) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(message);
-      }
-    },
-    success: (...args) => {
-      if (shouldLog) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(message);
-      }
-    },
-    warning: (...args) => {
-      if (shouldLog) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(message);
-      }
-    },
-    warn: (...args) => {
-      if (shouldLog) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(message);
-      }
-    },
-    gray: (...args) => {
-      if (shouldLog) {
-        const message = args.map((arg) => String(arg)).join(" ");
-        out(message);
-      }
-    }
-  };
-}
-function createCommandLogger(options) {
   return createLogger({
-    verbose: options.verbose,
-    silent: options.silent ?? false,
-    json: options.json,
-    stderr: options.stderr
-  });
-}
-
-// src/core/collector-logger.ts
-function createCollectorLoggerConfig(cliLogger, verbose) {
-  return {
-    level: verbose ? "DEBUG" : "ERROR",
-    handler: (level, message, context, scope) => {
+    // Let handler control visibility — pass everything through
+    level: Level.DEBUG,
+    handler: (level, message, _context, scope) => {
       const scopePath = scope.length > 0 ? `[${scope.join(":")}] ` : "";
-      const hasContext = Object.keys(context).length > 0;
-      const contextStr = hasContext ? ` ${JSON.stringify(context)}` : "";
-      if (level === 0) {
-        cliLogger.error(`${scopePath}${message}${contextStr}`);
-      } else if (verbose) {
-        cliLogger.debug(`${scopePath}${message}${contextStr}`);
+      const fullMessage = `${scopePath}${message}`;
+      if (level === Level.ERROR) {
+        if (!json) console.error(chalk.red(fullMessage));
+        return;
       }
-    }
-  };
-}
-
-// src/core/timer.ts
-function createTimer() {
-  let startTime2 = 0;
-  let endTime = 0;
-  return {
-    start() {
-      startTime2 = Date.now();
-      endTime = 0;
-    },
-    end() {
-      endTime = Date.now();
-      return endTime - startTime2;
-    },
-    getElapsed() {
-      const currentTime = endTime || Date.now();
-      return currentTime - startTime2;
+      if (silent || json) return;
+      if (level === Level.DEBUG) {
+        if (!verbose) return;
+        out(`  ${fullMessage}`);
+        return;
+      }
+      out(fullMessage);
     },
-    format() {
-      const elapsed = this.getElapsed();
-      return (elapsed / 1e3).toFixed(2) + "s";
+    jsonHandler: (data) => {
+      if (!silent) out(JSON.stringify(data, null, 2));
     }
-  };
+  });
 }
-
-// src/core/output.ts
-import fs from "fs-extra";
-import path from "path";
-async function writeResult(content, options) {
-  if (options.output) {
-    const outputPath = path.resolve(options.output);
-    await fs.ensureDir(path.dirname(outputPath));
-    await fs.writeFile(outputPath, content);
-  } else {
-    process.stdout.write(content);
-    process.stdout.write("\n");
+var init_cli_logger = __esm({
+  "src/core/cli-logger.ts"() {
+    "use strict";
   }
-}
-function createJsonOutput(success, data, error, duration) {
-  return {
-    success,
-    ...data && { data },
-    ...error && { error },
-    ...duration && { duration }
-  };
-}
-function createSuccessOutput(data, duration) {
-  return createJsonOutput(true, data, void 0, duration);
-}
-function createErrorOutput(error, duration) {
-  return createJsonOutput(false, void 0, error, duration);
-}
-function formatBytes(bytes) {
-  return (bytes / 1024).toFixed(2);
-}
-
-// src/core/tmp.ts
-import path2 from "path";
-var DEFAULT_TMP_ROOT = ".tmp";
-function getTmpPath(tmpDir, ...segments) {
-  const root = tmpDir || DEFAULT_TMP_ROOT;
-  const absoluteRoot = path2.isAbsolute(root) ? root : path2.resolve(root);
-  return path2.join(absoluteRoot, ...segments);
-}
-
-// src/core/asset-resolver.ts
-import { fileURLToPath } from "url";
-import { existsSync as existsSync2 } from "fs";
-import path4 from "path";
-
-// src/config/utils.ts
-import fs2 from "fs-extra";
-import path3 from "path";
+});
 
 // src/lib/config-file.ts
 import {
@@ -226,6 +102,9 @@ function resolveToken() {
   if (config?.token) return { token: config.token, source: "config" };
   return null;
 }
+function resolveDeployToken() {
+  return process.env.WALKEROS_DEPLOY_TOKEN ?? null;
+}
 function resolveAppUrl() {
   const envUrl = process.env.WALKEROS_APP_URL;
   if (envUrl) return envUrl;
@@ -233,6 +112,11 @@ function resolveAppUrl() {
   if (config?.appUrl) return config.appUrl;
   return "https://app.walkeros.io";
 }
+var init_config_file = __esm({
+  "src/lib/config-file.ts"() {
+    "use strict";
+  }
+});
 
 // src/core/auth.ts
 function getToken() {
@@ -252,6 +136,19 @@ async function authenticatedFetch(url, init) {
     headers: { ...existingHeaders, ...authHeaders }
   });
 }
+async function deployAuthenticatedFetch(url, init) {
+  const deployToken = resolveDeployToken();
+  const token = deployToken ?? getToken();
+  if (!token)
+    throw new Error(
+      "No authentication token available. Set WALKEROS_DEPLOY_TOKEN or run walkeros auth login."
+    );
+  const existingHeaders = init?.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : Array.isArray(init?.headers) ? Object.fromEntries(init.headers) : init?.headers ?? {};
+  return fetch(url, {
+    ...init,
+    headers: { ...existingHeaders, Authorization: `Bearer ${token}` }
+  });
+}
 function resolveBaseUrl() {
   return resolveAppUrl();
 }
@@ -260,8 +157,227 @@ function requireProjectId() {
   if (!projectId) throw new Error("WALKEROS_PROJECT_ID not set.");
   return projectId;
 }
+var init_auth = __esm({
+  "src/core/auth.ts"() {
+    "use strict";
+    init_config_file();
+  }
+});
+
+// src/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+function findPackageJson() {
+  const paths = [
+    join2(versionDirname, "../package.json"),
+    // dist/ or src/
+    join2(versionDirname, "../../package.json")
+    // src/core/ (not used, but safe)
+  ];
+  for (const p2 of paths) {
+    try {
+      return readFileSync2(p2, "utf-8");
+    } catch {
+    }
+  }
+  return JSON.stringify({ version: "0.0.0" });
+}
+var versionFilename, versionDirname, VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    versionFilename = fileURLToPath2(import.meta.url);
+    versionDirname = dirname2(versionFilename);
+    VERSION = JSON.parse(findPackageJson()).version;
+  }
+});
+
+// src/commands/run/heartbeat.ts
+var heartbeat_exports = {};
+__export(heartbeat_exports, {
+  startHeartbeat: () => startHeartbeat
+});
+import { randomUUID } from "crypto";
+async function startHeartbeat(options) {
+  const projectId = options.projectId ?? requireProjectId();
+  const base = resolveBaseUrl();
+  const instanceId2 = randomUUID();
+  const healthEndpoint = options.healthEndpoint ?? "/health";
+  const intervalSec = options.heartbeatInterval ?? 60;
+  const log = createCLILogger();
+  const startTime = Date.now();
+  const heartbeatUrl = `${base}/api/projects/${projectId}/deployments/${options.deployment}/heartbeat`;
+  const initResponse = await deployAuthenticatedFetch(heartbeatUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      url: options.url,
+      healthEndpoint,
+      instanceId: instanceId2,
+      cliVersion: VERSION
+    })
+  });
+  if (!initResponse.ok) {
+    const err = await initResponse.json().catch(() => ({}));
+    throw new Error(
+      err.error?.message || `Initial heartbeat failed (${initResponse.status})`
+    );
+  }
+  const initData = await initResponse.json();
+  log.info(
+    `Registered as ${instanceId2} on deployment ${options.deployment} (${initData.deploymentId})`
+  );
+  const heartbeatTimer = setInterval(async () => {
+    try {
+      const resp = await deployAuthenticatedFetch(heartbeatUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          instanceId: instanceId2,
+          uptime: Math.floor((Date.now() - startTime) / 1e3),
+          cliVersion: VERSION,
+          metadata: {
+            nodeVersion: process.version,
+            platform: process.platform
+          }
+        })
+      });
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.action === "update" && data.bundleUrl) {
+          log.info(
+            `Update available: version ${data.versionNumber}, downloading from ${data.bundleUrl}`
+          );
+        } else if (data.action === "stop") {
+          log.info("Received stop signal from server, shutting down...");
+          await cleanup();
+          process.exit(0);
+        }
+      }
+    } catch (err) {
+      log.error(
+        `Heartbeat failed: ${err instanceof Error ? err.message : "Unknown error"}`
+      );
+    }
+  }, intervalSec * 1e3);
+  const cleanup = async () => {
+    clearInterval(heartbeatTimer);
+    try {
+      await deployAuthenticatedFetch(heartbeatUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          instanceId: instanceId2,
+          uptime: Math.floor((Date.now() - startTime) / 1e3),
+          shutting_down: true
+        })
+      });
+    } catch {
+    }
+  };
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  return { instanceId: instanceId2, deploymentId: initData.deploymentId, cleanup };
+}
+var init_heartbeat = __esm({
+  "src/commands/run/heartbeat.ts"() {
+    "use strict";
+    init_auth();
+    init_cli_logger();
+    init_version();
+  }
+});
+
+// src/commands/bundle/index.ts
+init_cli_logger();
+import path10 from "path";
+import fs10 from "fs-extra";
+import { getPlatform as getPlatform2 } from "@walkeros/core";
+
+// src/core/index.ts
+init_cli_logger();
+
+// src/core/timer.ts
+function createTimer() {
+  let startTime = 0;
+  let endTime = 0;
+  return {
+    start() {
+      startTime = Date.now();
+      endTime = 0;
+    },
+    end() {
+      endTime = Date.now();
+      return endTime - startTime;
+    },
+    getElapsed() {
+      const currentTime = endTime || Date.now();
+      return currentTime - startTime;
+    },
+    format() {
+      const elapsed = this.getElapsed();
+      return (elapsed / 1e3).toFixed(2) + "s";
+    }
+  };
+}
+
+// src/core/output.ts
+import fs from "fs-extra";
+import path from "path";
+async function writeResult(content, options) {
+  if (options.output) {
+    const outputPath = path.resolve(options.output);
+    await fs.ensureDir(path.dirname(outputPath));
+    await fs.writeFile(outputPath, content);
+  } else {
+    process.stdout.write(content);
+    process.stdout.write("\n");
+  }
+}
+function createJsonOutput(success, data, error, duration) {
+  return {
+    success,
+    ...data && { data },
+    ...error && { error },
+    ...duration && { duration }
+  };
+}
+function createSuccessOutput(data, duration) {
+  return createJsonOutput(true, data, void 0, duration);
+}
+function createErrorOutput(error, duration) {
+  return createJsonOutput(false, void 0, error, duration);
+}
+function formatBytes(bytes) {
+  return (bytes / 1024).toFixed(2);
+}
+
+// src/core/tmp.ts
+import os from "os";
+import path2 from "path";
+var DEFAULT_TMP_ROOT = os.tmpdir();
+function getTmpPath(tmpDir, ...segments) {
+  const root = tmpDir || DEFAULT_TMP_ROOT;
+  const absoluteRoot = path2.isAbsolute(root) ? root : path2.resolve(root);
+  return path2.join(absoluteRoot, ...segments);
+}
+
+// src/core/asset-resolver.ts
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
 
 // src/config/utils.ts
+import fs2 from "fs-extra";
+import path3 from "path";
+init_auth();
 function isUrl(str) {
   try {
     const url = new URL(str);
@@ -467,6 +583,7 @@ async function copyLocalPackage(localPkg, targetDir, logger2) {
 
 // src/core/input-detector.ts
 import fs4 from "fs-extra";
+init_auth();
 async function detectInput(inputPath, platformOverride) {
   const content = await loadContent(inputPath);
   try {
@@ -508,6 +625,32 @@ async function readStdin() {
   return content;
 }
 
+// src/core/index.ts
+init_auth();
+
+// src/core/sse.ts
+function parseSSEEvents(buffer) {
+  const events = [];
+  const blocks = buffer.split("\n\n");
+  const remainder = blocks.pop() || "";
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    let eventType = "message";
+    const dataLines = [];
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event:")) {
+        eventType = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice(5).trimStart());
+      }
+    }
+    if (dataLines.length > 0) {
+      events.push({ type: eventType, data: dataLines.join("\n") });
+    }
+  }
+  return { parsed: events, remainder };
+}
+
 // src/config/validators.ts
 import { schemas } from "@walkeros/core/dev";
 var { safeParseSetup } = schemas;
@@ -518,8 +661,8 @@ function validateFlowSetup(data) {
   const result = safeParseSetup(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 path14 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path14}: ${issue.message}`;
     }).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
@@ -569,13 +712,16 @@ function loadBundleConfig(rawConfig, options) {
   const setup = validateFlowSetup(rawConfig);
   const availableFlows = getAvailableFlows(setup);
   const flowName = resolveFlow(setup, options.flowName, availableFlows);
-  const flowConfig = getFlowConfig(setup, flowName);
+  let flowConfig = getFlowConfig(setup, flowName, { deferred: true });
   const platform = getPlatform(flowConfig);
   if (!platform) {
     throw new Error(
       `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
     );
   }
+  if (platform === "web") {
+    flowConfig = getFlowConfig(setup, flowName);
+  }
   const buildDefaults = getBuildDefaults(platform);
   const packages = flowConfig.packages || {};
   const output = options.buildOverrides?.output || getDefaultOutput(platform);
@@ -651,7 +797,7 @@ async function loadFlowConfig(configPath, options) {
 import esbuild from "esbuild";
 import path9 from "path";
 import fs8 from "fs-extra";
-import { packageNameToVariable } from "@walkeros/core";
+import { packageNameToVariable, ENV_MARKER_PREFIX } from "@walkeros/core";
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
@@ -691,10 +837,15 @@ async function getFlowConfigCacheKey(content, date) {
 // src/commands/bundle/package-manager.ts
 var PACKAGE_DOWNLOAD_TIMEOUT_MS = 6e4;
 async function withTimeout(promise, ms, errorMessage) {
-  const timeout = new Promise(
-    (_, reject) => setTimeout(() => reject(new Error(errorMessage)), ms)
-  );
-  return Promise.race([promise, timeout]);
+  let timer;
+  const timeout = new Promise((_2, reject) => {
+    timer = setTimeout(() => reject(new Error(errorMessage)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 function getPackageDirectory(baseDir, packageName, version) {
   return path7.join(baseDir, "node_modules", packageName);
@@ -726,7 +877,7 @@ function validateNoDuplicatePackages(packages) {
   if (conflicts.length > 0) {
     throw new Error(
       `Version conflicts detected:
-${conflicts.map((c) => `  - ${c}`).join("\n")}
+${conflicts.map((c2) => `  - ${c2}`).join("\n")}
 
 Each package must use the same version across all declarations. Please update your configuration to use consistent versions.`
     );
@@ -762,7 +913,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
   const packagePaths = /* @__PURE__ */ new Map();
   const downloadQueue = [...packages];
   const processed = /* @__PURE__ */ new Set();
-  const userSpecifiedPackages = new Set(packages.map((p) => p.name));
+  const userSpecifiedPackages = new Set(packages.map((p2) => p2.name));
   const localPackageMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     if (pkg.path) {
@@ -970,7 +1121,7 @@ function validateFlowConfig(flowConfig, logger2) {
   const sources = flowConfig.sources || {};
   for (const [sourceId, source] of Object.entries(sources)) {
     if (source && typeof source === "object" && source.code === true) {
-      logger2.warning(
+      logger2.warn(
         `DEPRECATED: Source "${sourceId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a source package instead.`
       );
       hasDeprecatedCodeTrue = true;
@@ -979,7 +1130,7 @@ function validateFlowConfig(flowConfig, logger2) {
   const destinations = flowConfig.destinations || {};
   for (const [destId, dest] of Object.entries(destinations)) {
     if (dest && typeof dest === "object" && dest.code === true) {
-      logger2.warning(
+      logger2.warn(
         `DEPRECATED: Destination "${destId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a destination package instead.`
       );
       hasDeprecatedCodeTrue = true;
@@ -988,14 +1139,14 @@ function validateFlowConfig(flowConfig, logger2) {
   const transformers = flowConfig.transformers || {};
   for (const [transformerId, transformer] of Object.entries(transformers)) {
     if (transformer && typeof transformer === "object" && transformer.code === true) {
-      logger2.warning(
+      logger2.warn(
         `DEPRECATED: Transformer "${transformerId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a transformer package instead.`
       );
       hasDeprecatedCodeTrue = true;
     }
   }
   if (hasDeprecatedCodeTrue) {
-    logger2.warning(
+    logger2.warn(
       `See https://www.elbwalker.com/docs/walkeros/getting-started/flow for migration guide.`
     );
   }
@@ -1005,7 +1156,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
   const bundleStartTime = Date.now();
   const hasDeprecatedFeatures = validateFlowConfig(flowConfig, logger2);
   if (hasDeprecatedFeatures) {
-    logger2.warning("Skipping deprecated code: true entries from bundle.");
+    logger2.warn("Skipping deprecated code: true entries from bundle.");
   }
   const TEMP_DIR = buildOptions.tempDir || getTmpPath();
   if (buildOptions.cache !== false) {
@@ -1020,7 +1171,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
         await fs8.writeFile(outputPath, cachedBuild);
         const stats = await fs8.stat(outputPath);
         const sizeKB = (stats.size / 1024).toFixed(1);
-        logger2.log(`Output: ${outputPath} (${sizeKB} KB, cached)`);
+        logger2.info(`Output: ${outputPath} (${sizeKB} KB, cached)`);
         if (showStats) {
           const stats2 = await fs8.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
@@ -1030,11 +1181,14 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
               // Size estimation not available for cached builds
             })
           );
+          const hasWildcardImports = /import\s+\*\s+as\s+\w+\s+from/.test(
+            buildOptions.code || ""
+          );
           return {
             totalSize: stats2.size,
             packages: packageStats,
             buildTime: Date.now() - bundleStartTime,
-            treeshakingEffective: true
+            treeshakingEffective: !hasWildcardImports
           };
         }
         return;
@@ -1123,7 +1277,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     const outputStats = await fs8.stat(outputPath);
     const sizeKB = (outputStats.size / 1024).toFixed(1);
     const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
-    logger2.log(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
+    logger2.info(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
     if (buildOptions.cache !== false) {
       const configContent = generateCacheKeyContent(flowConfig, buildOptions);
       const buildOutput = await fs8.readFile(outputPath, "utf-8");
@@ -1153,10 +1307,10 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     throw error;
   }
 }
-async function collectBundleStats(outputPath, packages, startTime2, entryContent) {
+async function collectBundleStats(outputPath, packages, startTime, entryContent) {
   const stats = await fs8.stat(outputPath);
   const totalSize = stats.size;
-  const buildTime = Date.now() - startTime2;
+  const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
     const importPattern = new RegExp(`from\\s+['"]${name}['"]`, "g");
     const namedImportPattern = new RegExp(
@@ -1428,9 +1582,9 @@ async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
   );
   const importsCode = importStatements.join("\n");
   const hasFlow = Object.values(flowConfig.sources || {}).some(
-    (s) => s.package || isInlineCode(s.code)
+    (s2) => s2.package || isInlineCode(s2.code)
   ) || Object.values(flowConfig.destinations || {}).some(
-    (d) => d.package || isInlineCode(d.code)
+    (d2) => d2.package || isInlineCode(d2.code)
   );
   if (!hasFlow) {
     const userCode = buildOptions.code || "";
@@ -1582,12 +1736,42 @@ function serializeWithCode(value, indent) {
     if (value.startsWith("$code:")) {
       return value.slice(6);
     }
+    const esc = ENV_MARKER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const markerRe = new RegExp(
+      esc + "([a-zA-Z_][a-zA-Z0-9_]*)(?::((?:(?!" + esc + `)[^\\s"'])*))?`,
+      "g"
+    );
+    if (markerRe.test(value)) {
+      markerRe.lastIndex = 0;
+      const pureRe = new RegExp(
+        "^" + esc + "([a-zA-Z_][a-zA-Z0-9_]*)(?::((?:(?!" + esc + `)[^\\s"'])*))?$`
+      );
+      const pureMatch = value.match(pureRe);
+      if (pureMatch) {
+        const [, name, defaultValue] = pureMatch;
+        return defaultValue !== void 0 ? `process.env[${JSON.stringify(name)}] ?? ${JSON.stringify(defaultValue)}` : `process.env[${JSON.stringify(name)}]`;
+      }
+      const segments = [];
+      let lastIndex = 0;
+      markerRe.lastIndex = 0;
+      let m2;
+      while ((m2 = markerRe.exec(value)) !== null) {
+        const staticPart = value.slice(lastIndex, m2.index).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$(?!{)/g, "\\$");
+        const [, name, defaultValue] = m2;
+        const envExpr = defaultValue !== void 0 ? `\${process.env[${JSON.stringify(name)}] ?? ${JSON.stringify(defaultValue)}}` : `\${process.env[${JSON.stringify(name)}]}`;
+        segments.push(staticPart + envExpr);
+        lastIndex = m2.index + m2[0].length;
+      }
+      const trailing = value.slice(lastIndex).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$(?!{)/g, "\\$");
+      segments.push(trailing);
+      return "`" + segments.join("") + "`";
+    }
     return JSON.stringify(value);
   }
   if (Array.isArray(value)) {
     if (value.length === 0) return "[]";
     const items = value.map(
-      (v) => nextSpaces + serializeWithCode(v, indent + 1)
+      (v2) => nextSpaces + serializeWithCode(v2, indent + 1)
     );
     return `[
 ${items.join(",\n")}
@@ -1597,7 +1781,7 @@ ${spaces}]`;
     const entries = Object.entries(value);
     if (entries.length === 0) return "{}";
     const props = entries.map(
-      ([k, v]) => `${nextSpaces}${JSON.stringify(k)}: ${serializeWithCode(v, indent + 1)}`
+      ([k2, v2]) => `${nextSpaces}${JSON.stringify(k2)}: ${serializeWithCode(v2, indent + 1)}`
     );
     return `{
 ${props.join(",\n")}
@@ -1637,11 +1821,56 @@ function generatePlatformWrapper(configObject, userCode, buildOptions) {
     config.logger = { ...config.logger, ...context.logger };
   }
 
-  return await startFlow(config);
+  // 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 };
 }`;
   }
 }
 
+// src/commands/bundle/upload.ts
+import fs9 from "fs-extra";
+function sanitizeUrl(url) {
+  return url.split("?")[0];
+}
+async function uploadBundleToUrl(filePath, url, timeoutMs = 3e4) {
+  const bundleContent = await fs9.readFile(filePath);
+  const doUpload = async (attempt) => {
+    const response = await fetch(url, {
+      method: "PUT",
+      body: bundleContent,
+      headers: {
+        "Content-Type": "application/javascript",
+        "Content-Length": String(bundleContent.length)
+      },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (response.status >= 500 && attempt === 1) {
+      return doUpload(2);
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Upload failed: ${response.status} ${response.statusText}`
+      );
+    }
+  };
+  await doUpload(1);
+}
+
 // src/commands/bundle/stats.ts
 function displayStats(stats, logger2) {
   logger2.info("\n\u{1F4CA} Bundle Statistics");
@@ -1666,6 +1895,7 @@ Package Breakdown:`);
 }
 
 // src/core/api-client.ts
+init_auth();
 import createClient from "openapi-fetch";
 function createApiClient() {
   const token = getToken();
@@ -1693,7 +1923,7 @@ async function bundleCommand(options) {
   const timer = createTimer();
   timer.start();
   const writingToStdout = !options.output;
-  const logger2 = createCommandLogger({
+  const logger2 = createCLILogger({
     ...options,
     stderr: writingToStdout
   });
@@ -1739,16 +1969,24 @@ async function bundleCommand(options) {
         if (options.cache !== void 0) {
           buildOptions.cache = options.cache;
         }
-        if (options.output) {
+        const outputIsUrl = options.output ? isUrl(options.output) : false;
+        const uploadUrl = outputIsUrl ? options.output : void 0;
+        if (outputIsUrl) {
+          const ext = buildOptions.platform === "browser" ? ".js" : ".mjs";
+          buildOptions.output = getTmpPath(
+            void 0,
+            `url-bundle-${Date.now()}${ext}`
+          );
+        } else if (options.output) {
           buildOptions.output = resolveOutputPath(options.output, buildOptions);
         } else {
           const ext = buildOptions.platform === "browser" ? ".js" : ".mjs";
           buildOptions.output = getTmpPath(void 0, "stdout-bundle" + ext);
         }
         if (isMultiFlow || options.all) {
-          logger2.log(`Bundling flow: ${flowName}...`);
+          logger2.info(`Bundling flow: ${flowName}...`);
         } else {
-          logger2.log("Bundling...");
+          logger2.info("Bundling...");
         }
         const shouldCollectStats = options.stats || options.json;
         const stats = await bundleCore(
@@ -1758,11 +1996,16 @@ async function bundleCommand(options) {
           shouldCollectStats
         );
         results.push({ flowName, success: true, stats });
+        if (uploadUrl) {
+          await uploadBundleToUrl(buildOptions.output, uploadUrl);
+          logger2.info(`Uploaded to: ${sanitizeUrl(uploadUrl)}`);
+          await fs10.remove(buildOptions.output);
+        }
         if (!options.json && !options.all && options.stats && stats) {
           displayStats(stats, logger2);
         }
         if (writingToStdout && !options.json) {
-          const bundleContent = await fs9.readFile(buildOptions.output);
+          const bundleContent = await fs10.readFile(buildOptions.output);
           await writeResult(bundleContent, {});
         }
         if (options.dockerfile && options.output) {
@@ -1782,8 +2025,8 @@ async function bundleCommand(options) {
       }
     }
     const duration = timer.end() / 1e3;
-    const successCount = results.filter((r) => r.success).length;
-    const failureCount = results.filter((r) => !r.success).length;
+    const successCount = results.filter((r2) => r2.success).length;
+    const failureCount = results.filter((r2) => !r2.success).length;
     if (options.json) {
       const jsonResult = failureCount === 0 ? createSuccessOutput(
         {
@@ -1804,7 +2047,7 @@ async function bundleCommand(options) {
       });
     } else {
       if (options.all) {
-        logger2.log(
+        logger2.info(
           `
 Build Summary: ${successCount}/${results.length} succeeded`
         );
@@ -1848,7 +2091,7 @@ async function bundle(configOrPath, options = {}) {
   if (options.cache !== void 0) {
     buildOptions.cache = options.cache;
   }
-  const logger2 = createCommandLogger(options);
+  const logger2 = createCLILogger(options);
   return await bundleCore(
     flowConfig,
     buildOptions,
@@ -1858,26 +2101,24 @@ async function bundle(configOrPath, options = {}) {
 }
 async function generateDockerfile(outputDir, platform, logger2, customFile) {
   const destPath = path10.join(outputDir, "Dockerfile");
-  if (customFile && await fs9.pathExists(customFile)) {
-    await fs9.copy(customFile, destPath);
-    logger2.log(`Dockerfile: ${destPath} (copied from ${customFile})`);
+  if (customFile && await fs10.pathExists(customFile)) {
+    await fs10.copy(customFile, destPath);
+    logger2.info(`Dockerfile: ${destPath} (copied from ${customFile})`);
     return;
   }
   const isWeb = platform === "web";
   const bundleFile = isWeb ? "walker.js" : "bundle.mjs";
-  const mode = isWeb ? "serve" : "collect";
   const dockerfile = `# Generated by walkeros CLI
 FROM walkeros/flow:latest
 
 COPY ${bundleFile} /app/flow/${bundleFile}
 
-ENV MODE=${mode}
 ENV BUNDLE=/app/flow/${bundleFile}
 
 EXPOSE 8080
 `;
-  await fs9.writeFile(destPath, dockerfile);
-  logger2.log(`Dockerfile: ${destPath}`);
+  await fs10.writeFile(destPath, dockerfile);
+  logger2.info(`Dockerfile: ${destPath}`);
 }
 async function bundleRemote(options) {
   const client = createApiClient();
@@ -1899,279 +2140,545 @@ async function bundleRemote(options) {
 }
 
 // src/commands/simulate/simulator.ts
-import path11 from "path";
 import fs11 from "fs-extra";
-import { getPlatform as getPlatform3 } from "@walkeros/core";
+import { Level as Level2 } from "@walkeros/core";
 
-// src/commands/simulate/tracker.ts
-var CallTracker = class {
-  calls = /* @__PURE__ */ new Map();
-  /**
-   * Wrap a function to track its calls
-   */
-  wrapFunction(name, fn) {
-    const self = this;
-    const targetFn = fn || (() => {
-    });
-    return new Proxy(targetFn, {
-      apply(_target, thisArg, args) {
-        self.logCall(name, args);
-        return targetFn.apply(thisArg, args);
-      }
-    });
-  }
-  /**
-   * Wrap an environment object, tracking specified paths
-   *
-   * @param env - Environment object (from destination's examples/env.ts)
-   * @param paths - Paths to track (e.g., ['gtag:window.gtag', 'gtag:window.dataLayer.push'])
-   */
-  wrapEnv(env, paths) {
-    const wrapped = {};
-    for (const [key, value] of Object.entries(env)) {
-      if (typeof value === "object" && value !== null) {
-        wrapped[key] = Array.isArray(value) ? [...value] : { ...value };
-      } else {
-        wrapped[key] = value;
-      }
-    }
-    for (const fullPath of paths) {
-      const [destKey, ...pathParts] = fullPath.split(":");
-      const path15 = pathParts.join(":");
-      if (!path15) continue;
-      const cleanPath = path15.replace(/^call:/, "");
-      const parts = cleanPath.split(".");
-      let current = wrapped;
-      let source = env;
-      for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (!current[part]) {
-          current[part] = {};
-        }
-        current = current[part];
-        source = source && typeof source[part] === "object" && source[part] !== null ? source[part] : void 0;
-      }
-      const finalKey = parts[parts.length - 1];
-      const originalFn = source?.[finalKey];
-      current[finalKey] = this.wrapFunction(
-        `${destKey}:${cleanPath}`,
-        typeof originalFn === "function" ? originalFn : void 0
-      );
-    }
-    return wrapped;
-  }
-  logCall(fullPath, args) {
-    const [destKey, ...pathParts] = fullPath.split(":");
-    const apiPath = pathParts.join(":");
-    if (!this.calls.has(destKey)) {
-      this.calls.set(destKey, []);
+// ../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 d, isFunction as g, isObject as m, processEventMapping as p, tryCatchAsync as h, useHooks as w } from "@walkeros/core";
+import { isArray as y } from "@walkeros/core";
+import { tryCatch as b, tryCatchAsync as v } from "@walkeros/core";
+import { getMappingValue as k, tryCatchAsync as C } from "@walkeros/core";
+import { isObject as O, tryCatchAsync as q, useHooks as j } from "@walkeros/core";
+import { assign as M, getId as Q, isFunction as V, isString as K } from "@walkeros/core";
+import { isObject as X } from "@walkeros/core";
+import { getGrantedConsent as tn, processEventMapping as on, tryCatchAsync as sn, useHooks as rn } from "@walkeros/core";
+import { useHooks as cn, tryCatchAsync as un } 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) {
+  return null != n && false !== n && "object" == typeof n && true === n.__branch;
+}
+function A(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 E(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 P(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);
+      break;
     }
-    this.calls.get(destKey).push({
-      type: "call",
-      path: apiPath,
-      args,
-      timestamp: Date.now()
-    });
-  }
-  getCalls() {
-    return Object.fromEntries(this.calls);
+    s2 = n2;
   }
-  reset() {
-    this.calls.clear();
+  return t2;
+}
+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: R(e2.config.env) };
+    s2.debug("init");
+    const i2 = await j(e2.init, "TransformerInit", n.hooks)(r2);
+    if (false === i2) return false;
+    e2.config = { ...i2 || e2.config, init: true }, s2.debug("init done");
   }
-};
-
-// src/commands/simulate/jsdom-executor.ts
-import { JSDOM, VirtualConsole } from "jsdom";
-import fs10 from "fs-extra";
-function buildSandboxFromEnvs(envs, destinations, tracker) {
-  const baseBrowserMocks = {
-    Image: class MockImage {
-      src = "";
-      onload = (() => {
-      });
-      onerror = (() => {
-      });
-    },
-    fetch: async () => ({ ok: true, json: async () => ({}) }),
-    location: { href: "http://localhost" },
-    navigator: { userAgent: "Mozilla/5.0 (walkerOS Simulation)" }
-  };
-  const sandbox = {
-    window: { ...baseBrowserMocks },
-    document: {}
-  };
-  for (const [destKey, destConfig] of Object.entries(destinations)) {
-    const destEnv = envs[destKey];
-    if (!destEnv?.push) continue;
-    const mockEnv = destEnv.push;
-    const trackPaths = destEnv.simulation || [];
-    const trackedEnv = tracker.wrapEnv(
-      mockEnv,
-      trackPaths.map((p) => `${destKey}:${p}`)
-    );
-    if (trackedEnv.window && typeof trackedEnv.window === "object") {
-      Object.assign(sandbox.window, trackedEnv.window);
+  return true;
+}
+async function S(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: { ...R(e2.config.env), ...r2 ? { respond: r2 } : {} } };
+  a2.debug("push", { event: o2.name });
+  const u2 = await j(e2.push, "TransformerPush", n.hooks)(o2, c2);
+  return a2.debug("push done"), u2;
+}
+async function $(n, e2, t2, o2, s2, r2) {
+  let i2 = o2;
+  for (const o3 of t2) {
+    const t3 = e2[o3];
+    if (!t3) {
+      n.logger.warn(`Transformer not found: ${o3}`);
+      continue;
     }
-    if (trackedEnv.document && typeof trackedEnv.document === "object") {
-      Object.assign(sandbox.document, trackedEnv.document);
+    if (!await q(x)(n, t3, o3)) return n.logger.error(`Transformer init failed: ${o3}`), null;
+    const a2 = await q(S, (e3) => (n.logger.scope(`transformer:${t3.type || "unknown"}`).error("Push failed", { error: e3 }), false))(n, t3, o3, i2, s2, r2);
+    if (false === a2) return null;
+    if (D(a2)) {
+      const t4 = P(a2.next, A(e2));
+      return t4.length > 0 ? $(n, e2, t4, a2.event, s2, r2) : (n.logger.warn(`Branch target not found: ${JSON.stringify(a2.next)}`), null);
+    }
+    void 0 !== a2 && (i2 = a2);
+  }
+  return i2;
+}
+function R(n) {
+  return n && O(n) ? n : {};
+}
+async function T(n, e2, t2) {
+  const { code: o2, config: s2 = {}, env: r2 = {}, primary: i2, next: a2 } = t2;
+  let c2, u2;
+  const f2 = P(a2, A(n.transformers)), l2 = n.logger.scope("source").scope(e2), d2 = { push: (t3, o3 = {}) => n.push(t3, { ...o3, id: e2, ingest: c2, respond: u2, mapping: s2, preChain: f2 }), command: n.command, sources: n.sources, elb: n.sources.elb.push, logger: l2, ...r2 }, g2 = { collector: n, logger: l2, id: e2, config: s2, env: d2, setIngest: async (e3) => {
+    c2 = s2.ingest ? await k(e3, s2.ingest, { collector: n }) : void 0;
+  }, setRespond: (n2) => {
+    u2 = n2;
+  } }, m2 = await C(o2)(g2);
+  if (!m2) return;
+  const p2 = m2.type || "unknown", h2 = n.logger.scope(p2).scope(e2);
+  return d2.logger = h2, i2 && (m2.config = { ...m2.config, primary: i2 }), m2;
+}
+async function I(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;
+      continue;
     }
+    const r2 = await T(n, o2, s2);
+    r2 && (t2[o2] = r2);
   }
-  return sandbox;
+  return t2;
 }
-function waitForWindowProperty(window, prop, timeout = 5e3) {
-  return new Promise((resolve3, reject) => {
-    const start = Date.now();
-    const check = () => {
-      if (window[prop] !== void 0) {
-        resolve3();
-      } else if (Date.now() - start > timeout) {
-        reject(
-          new Error(
-            `Timeout waiting for window.${prop}. IIFE may have failed to execute or assign to window.`
-          )
-        );
-      } else {
-        setImmediate(check);
-      }
-    };
-    check();
-  });
+async function B(n, e2, t2) {
+  const o2 = n.on, s2 = o2[e2] || [], r2 = y(t2) ? t2 : [t2];
+  r2.forEach((n2) => {
+    s2.push(n2);
+  }), o2[e2] = s2, await H(n, e2, r2);
 }
-async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, timeout = 1e4) {
-  const start = Date.now();
-  const virtualConsole = new VirtualConsole();
-  const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
-    url: "http://localhost",
-    runScripts: "dangerously",
-    // Allow script execution
-    resources: "usable",
-    virtualConsole
-  });
-  const { window } = dom;
-  const sandbox = buildSandboxFromEnvs(envs, destinations, tracker);
-  Object.assign(window, sandbox.window);
-  Object.assign(window.document, sandbox.document);
-  const bundleCode = await fs10.readFile(bundlePath, "utf8");
-  try {
-    window.eval(bundleCode);
-  } catch (error) {
-    throw new Error(`Bundle execution failed: ${getErrorMessage(error)}`);
-  }
-  try {
-    await waitForWindowProperty(
-      window,
-      "collector",
-      timeout
-    );
-    await waitForWindowProperty(
-      window,
-      "elb",
-      timeout
-    );
-  } catch (error) {
-    throw new Error(
-      `Window property assignment failed: ${getErrorMessage(error)}`
-    );
-  }
-  const { collector, elb } = window;
-  let elbResult;
-  try {
-    elbResult = await elb(event.name, event.data);
-  } catch (error) {
-    throw new Error(`Event execution failed: ${getErrorMessage(error)}`);
-  }
-  return {
-    collector,
-    elb,
-    elbResult,
-    usage: tracker.getCalls(),
-    duration: Date.now() - start
-  };
+function G(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: L(e2.env, e2.config.env) };
+  b(e2.on)(o2, a2);
 }
-
-// src/commands/simulate/node-executor.ts
-import { pathToFileURL } from "url";
-function buildGlobalMocksFromEnvs(envs, destinations, tracker) {
-  const globalMocks = {};
-  for (const [destKey] of Object.entries(destinations)) {
-    const destEnv = envs[destKey];
-    if (!destEnv?.push) continue;
-    const mockEnv = destEnv.push;
-    const trackPaths = destEnv.simulation || [];
-    const trackedEnv = tracker.wrapEnv(
-      mockEnv,
-      trackPaths.map((p) => `${destKey}:${p}`)
-    );
-    Object.assign(globalMocks, trackedEnv);
-  }
-  return globalMocks;
-}
-function injectGlobalMocks(mocks) {
-  const originalValues = {};
-  for (const [key, value] of Object.entries(mocks)) {
-    originalValues[key] = globalThis[key];
-    globalThis[key] = value;
+async function H(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 });
+      G(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 T(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 = W(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) => {
+            b(e4[t3])(n2, o3);
+          });
+        });
+      })(n, i2, s2);
+      break;
+    case t.Commands.Ready:
+    case t.Commands.Run:
+      !(function(n2, e3) {
+        n2.allowed && e3.forEach((e4) => {
+          b(e4)(n2);
+        });
+      })(n, i2);
+      break;
+    case t.Commands.Session:
+      !(function(n2, e3) {
+        if (!n2.session) return;
+        e3.forEach((e4) => {
+          b(e4)(n2, n2.session);
+        });
+      })(n, i2);
+      break;
+    default:
+      i2.forEach((e3) => {
+        "function" == typeof e3 && b(e3)(n, r2);
+      });
   }
-  return () => {
-    for (const [key, value] of Object.entries(originalValues)) {
-      if (value === void 0) {
-        delete globalThis[key];
-      } else {
-        globalThis[key] = value;
+  return !a2;
+}
+async function U(n, e2, t2) {
+  const { code: o2, config: s2 = {}, env: r2 = {}, before: i2 } = e2;
+  if (!g(o2.push)) return N({ ok: false, failed: { invalid: { type: "invalid", error: "Destination code must have a push method" } } });
+  const a2 = t2 || s2 || { init: false }, c2 = i2 ? { ...a2, before: i2 } : a2, u2 = { ...o2, config: c2, env: L(o2.env, r2) };
+  let l2 = u2.config.id;
+  if (!l2) do {
+    l2 = f(4);
+  } while (n.destinations[l2]);
+  return n.destinations[l2] = u2, false !== u2.config.queue && (u2.queuePush = [...n.queue]), _(n, void 0, {}, { [l2]: u2 });
+}
+async function _(n, e2, t2 = {}, o2) {
+  const { allowed: s2, consent: r2, globals: i2, user: u2 } = n;
+  if (!s2) return N({ ok: false });
+  e2 && (n.queue.push(e2), n.status.in++), o2 || (o2 = n.destinations);
+  const f2 = await Promise.all(Object.entries(o2 || {}).map(async ([o3, s3]) => {
+    let f3 = (s3.queuePush || []).map((n2) => ({ ...n2, consent: 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(F)(n, s3, o3);
+      return { id: o3, destination: s3, skipped: !e3 };
+    }
+    const d3 = [], g3 = f3.filter((n2) => {
+      const e3 = l(s3.config.consent, r2, n2.consent);
+      return !e3 || (n2.consent = e3, d3.push(n2), false);
+    });
+    if (s3.queuePush.push(...g3), !d3.length) return { id: o3, destination: s3, queue: f3 };
+    if (!await h(F)(n, s3, o3)) return { id: o3, destination: s3, queue: f3 };
+    let m3, p2;
+    s3.dlq || (s3.dlq = []);
+    const w2 = (function(n2, e3) {
+      const t3 = n2.config.before;
+      return t3 ? P(t3, A(e3)) : [];
+    })(s3, n.transformers);
+    let y2 = 0;
+    return await Promise.all(d3.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 $(n, n.transformers, w2, e3, t2.ingest, t2.respond);
+        if (null === o4) return e3;
+        r3 = o4;
       }
+      const c2 = Date.now(), f4 = await h(J, (e4) => {
+        const t3 = s3.type || "unknown";
+        n.logger.scope(t3).error("Push failed", { error: e4, event: r3.name }), m3 = e4, s3.dlq.push([r3, e4]);
+      })(n, s3, o3, r3, t2.ingest, t2.respond);
+      return y2 += Date.now() - c2, void 0 !== f4 && (p2 = f4), e3;
+    })), { id: o3, destination: s3, error: m3, response: p2, totalDuration: y2 };
+  })), d2 = {}, g2 = {}, m2 = {};
+  for (const e3 of f2) {
+    if (e3.skipped) continue;
+    const t3 = e3.destination, o3 = { type: t3.type || "unknown", data: e3.response };
+    n.status.destinations[e3.id] || (n.status.destinations[e3.id] = { count: 0, failed: 0, duration: 0 });
+    const s3 = n.status.destinations[e3.id], r3 = Date.now();
+    e3.error ? (o3.error = e3.error, m2[e3.id] = o3, s3.failed++, s3.lastAt = r3, s3.duration += e3.totalDuration || 0, n.status.failed++) : e3.queue && e3.queue.length ? (t3.queuePush = (t3.queuePush || []).concat(e3.queue), g2[e3.id] = o3) : (d2[e3.id] = o3, s3.count++, s3.lastAt = r3, s3.duration += e3.totalDuration || 0, n.status.out++);
+  }
+  return N({ event: e2, ...Object.keys(d2).length && { done: d2 }, ...Object.keys(g2).length && { queued: g2 }, ...Object.keys(m2).length && { failed: m2 } });
+}
+async function F(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: L(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) G(n, e2, t2, s3, r3);
+    }
+    s2.debug("init done");
+  }
+  return true;
+}
+async function J(n, e2, t2, o2, s2, r2) {
+  const { config: i2 } = e2, a2 = await p(o2, i2, n);
+  if (a2.ignore) return false;
+  const c2 = e2.type || "unknown", f2 = n.logger.scope(c2), l2 = { collector: n, logger: f2, id: t2, config: i2, data: a2.data, rule: a2.mapping, ingest: s2, env: { ...L(e2.env, i2.env), ...r2 ? { respond: r2 } : {} } }, g2 = a2.mapping, m2 = a2.mappingKey || "* *";
+  if (!g2?.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: g2, ingest: s2, env: { ...L(e2.env, i2.env), ...r2 ? { respond: r2 } : {} } };
+        f2.debug("push batch", { events: o5.events.length }), w(e2.pushBatch, "DestinationPushBatch", n.hooks)(o5, a3), f2.debug("push batch done"), o5.events = [], o5.data = [];
+      }, g2.batch) };
+    }
+    const o3 = e2.batches[m2];
+    o3.batched.events.push(a2.event), d(a2.data) && o3.batched.data.push(a2.data), o3.batchFn();
+  }
+  return true;
+}
+function N(n) {
+  return { ok: !n?.failed, ...n };
+}
+function W(n) {
+  const { code: e2, config: t2 = {}, env: o2 = {} } = n, { config: s2 } = E(n, "before"), r2 = { ...e2.config, ...t2, ...s2 }, i2 = L(e2.env, o2);
+  return { ...e2, config: r2, env: i2 };
+}
+async function z(n, e2 = {}) {
+  const t2 = {};
+  for (const [o2, s2] of Object.entries(e2)) s2.config?.require?.length ? n.pending.destinations[o2] = s2 : t2[o2] = W(s2);
+  return t2;
+}
+function L(n, e2) {
+  return n || e2 ? e2 ? n && m(n) && m(e2) ? { ...n, ...e2 } : e2 : n : {};
+}
+async function Y(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 executeInNode(bundlePath, destinations, event, tracker, envs, timeout = 3e4, context = {}) {
-  const start = Date.now();
-  const globalMocks = buildGlobalMocksFromEnvs(envs, destinations, tracker);
-  const cleanupMocks = injectGlobalMocks(globalMocks);
-  try {
-    const executeWithTimeout = async () => {
-      const importUrl = process.env.JEST_WORKER_ID ? bundlePath : `${pathToFileURL(bundlePath).href}?t=${Date.now()}`;
-      const module = await import(importUrl);
-      if (!module.default || typeof module.default !== "function") {
-        throw new Error("Bundle does not export default factory function");
-      }
-      const result = await module.default(context);
-      if (!result || !result.collector || typeof result.collector.push !== "function") {
-        throw new Error(
-          "Factory function did not return valid result with collector"
-        );
+async function Z(n, e2, o2, r2) {
+  let i2, a2, c2 = false, u2 = false;
+  switch (e2) {
+    case t.Commands.Config:
+      X(o2) && (M(n.config, o2, { shallow: false }), a2 = o2, c2 = true);
+      break;
+    case t.Commands.Consent:
+      if (X(o2)) {
+        const { update: e3, runQueue: t2 } = s(n, o2);
+        a2 = e3, c2 = true, u2 = t2;
       }
-      const { collector, elb } = result;
-      let elbResult;
-      try {
-        elbResult = await collector.push({
-          name: event.name,
-          data: event.data
-        });
-      } catch (error) {
-        throw new Error(`Event execution failed: ${getErrorMessage(error)}`);
+      break;
+    case t.Commands.Custom:
+      X(o2) && (n.custom = M(n.custom, o2), a2 = o2, c2 = true);
+      break;
+    case t.Commands.Destination:
+      X(o2) && ("code" in o2 && X(o2.code) ? i2 = await U(n, o2, r2) : V(o2.push) && (i2 = await U(n, { code: o2 }, r2)));
+      break;
+    case t.Commands.Globals:
+      X(o2) && (n.globals = M(n.globals, o2), a2 = o2, c2 = true);
+      break;
+    case t.Commands.On:
+      K(o2) && await B(n, o2, r2);
+      break;
+    case t.Commands.Ready:
+      c2 = true;
+      break;
+    case t.Commands.Run:
+      i2 = await en(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 Y(n2.sources, "source", e3), await Y(n2.destinations, "destination", e3), await Y(n2.transformers, "transformer", e3);
+      })(n);
+      break;
+    case t.Commands.User:
+      X(o2) && (M(n.user, o2, { shallow: false }), a2 = o2, c2 = true);
+  }
+  return c2 && await H(n, e2, void 0, a2), u2 && (i2 = await _(n)), i2 || N({ ok: true });
+}
+function nn(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: d2 = n.user, nested: g2 = [], consent: m2 = n.consent, id: p2 = `${s2}-${r2}-${i2}`, trigger: h2 = "", entity: w2 = t2, action: y2 = o2, timing: b2 = 0, version: v2 = { source: n.version, tagging: n.config.tagging || 0 }, source: k2 = { type: "collector", id: "", previous_id: "" } } = e2;
+  return { name: a2, data: c2, context: u2, globals: f2, custom: l2, user: d2, nested: g2, consent: m2, id: p2, trigger: h2, entity: w2, action: y2, timestamp: s2, timing: b2, group: r2, count: i2, version: v2, source: k2 };
+}
+async function en(n, e2) {
+  n.allowed = true, n.count = 0, n.group = Q(), n.timing = Date.now(), e2 && (e2.consent && (n.consent = M(n.consent, e2.consent)), e2.user && (n.user = M(n.user, e2.user)), e2.globals && (n.globals = M(n.config.globalsStatic || {}, e2.globals)), e2.custom && (n.custom = M(n.custom, e2.custom))), Object.values(n.destinations).forEach((n2) => {
+    n2.queuePush = [];
+  }), n.queue = [], n.round++;
+  return await _(n);
+}
+function an(n, e2) {
+  return rn(async (t2, o2 = {}) => await sn(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 on(f2, c2, n);
+      if (e3.ignore) return N({ ok: true });
+      if (c2.consent) {
+        if (!tn(c2.consent, n.consent, e3.event.consent)) return N({ ok: true });
       }
-      return {
-        collector,
-        elb,
-        elbResult,
-        usage: tracker.getCalls(),
-        duration: Date.now() - start
-      };
-    };
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(
-        () => reject(new Error(`Server simulation timeout after ${timeout}ms`)),
-        timeout
-      );
+      f2 = e3.event;
+    }
+    if (u2?.length && n.transformers && Object.keys(n.transformers).length > 0) {
+      const e3 = await $(n, n.transformers, u2, f2, l2, a2);
+      if (null === e3) return N({ ok: true });
+      f2 = e3;
+    }
+    const d2 = e2(f2), g2 = nn(n, d2), m2 = await _(n, g2, { id: r2, ingest: l2, respond: a2 });
+    if (r2) {
+      n.status.sources[r2] || (n.status.sources[r2] = { count: 0, duration: 0 });
+      const e3 = n.status.sources[r2];
+      e3.count++, e3.lastAt = Date.now(), e3.duration += Date.now() - s2;
+    }
+    return m2;
+  }, () => N({ ok: false }))(), "Push", n.hooks);
+}
+async function fn(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: {}, globals: s2, group: "", hooks: {}, logger: o2, on: {}, queue: [], round: 0, session: void 0, status: { startedAt: Date.now(), in: 0, out: 0, failed: 0, sources: {}, destinations: {} }, timing: Date.now(), user: n.user || {}, version: "2.0.1", sources: {}, pending: { sources: {}, destinations: {} }, push: void 0, command: void 0 };
+  return a2.push = an(a2, (n2) => ({ timing: Math.round((Date.now() - a2.timing) / 10) / 100, source: { type: "collector", id: "", previous_id: "" }, ...n2 })), a2.command = (function(n2, e3) {
+    return cn(async (t3, o3, s3) => await un(async () => await e3(n2, t3, o3, s3), () => N({ ok: false }))(), "Command", n2.hooks);
+  })(a2, Z), a2.destinations = await z(a2, n.destinations || {}), a2.transformers = await (async function(n2, e3 = {}) {
+    const t3 = {};
+    for (const [o3, s3] of Object.entries(e3)) {
+      const { code: e4, env: r2 = {} } = s3, { config: i2 } = E(s3, "next"), a3 = n2.logger.scope("transformer").scope(o3), c2 = { collector: n2, logger: a3, id: o3, config: i2, env: r2 }, u2 = await e4(c2);
+      t3[o3] = u2;
+    }
+    return t3;
+  })(a2, n.transformers || {}), a2;
+}
+async function ln(n) {
+  n = n || {};
+  const e2 = await fn(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 N({ ok: false });
+      a3 = n2, e3 && "object" == typeof e3 && !Array.isArray(e3) && (a3.data = { ...a3.data || {}, ...e3 });
+    }
+    return s3 && "object" == typeof s3 && (a3.context = s3), 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 I(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 dn(n) {
+  if (null === n || "object" != typeof n) return n;
+  if (Array.isArray(n)) return n.map(dn);
+  const e2 = {};
+  for (const [t2, o2] of Object.entries(n)) e2[t2] = "function" == typeof o2 ? o2 : dn(o2);
+  return e2;
+}
+function gn(n) {
+  const e2 = [], { simulation: t2, ...o2 } = n, s2 = dn(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]];
+    const i2 = o3[o3.length - 1];
+    if (null == r2 || !(i2 in r2)) continue;
+    const a2 = r2[i2];
+    "function" == typeof a2 && (r2[i2] = function(...n3) {
+      return e2.push({ fn: t3, args: n3, ts: Date.now() }), a2.apply(this, n3);
     });
-    return await Promise.race([executeWithTimeout(), timeoutPromise]);
-  } catch (error) {
-    throw new Error(`Node execution failed: ${getErrorMessage(error)}`);
-  } finally {
-    cleanupMocks();
+  }
+  return { wrappedEnv: s2, calls: e2 };
+}
+async function mn(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 ln({ 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];
+          return { step: "transformer", name: n2.name, events: c2, calls: [], duration: Date.now() - e3 };
+        })(n, e2);
+      case "source":
+        return await (async function(n2, e3) {
+          const { code: t2, config: o2 = {}, setup: s2, input: r2, env: i2, consent: a2 } = n2, c2 = { functional: true, marketing: true, analytics: true };
+          let u2;
+          if (s2) {
+            const n3 = s2(r2, i2);
+            "function" == typeof n3 && (u2 = n3);
+          }
+          const f2 = [], { collector: l2 } = await ln({ consent: a2 || c2, sources: { sim: { code: t2, config: o2, env: i2, next: "spy" } }, transformers: { spy: { code: () => ({ type: "spy", config: {}, push: (n3) => (f2.push(JSON.parse(JSON.stringify(n3))), n3) }) } } });
+          u2 && u2();
+          return { step: "source", name: n2.name, events: f2, calls: [], duration: Date.now() - e3 };
+        })(n, e2);
+      case "destination":
+        return await (async function(n2, e3) {
+          const { code: t2, config: o2 = {}, event: s2, consent: r2, env: i2, track: a2 } = n2, c2 = { functional: true, marketing: true, analytics: true };
+          let u2 = [], f2 = i2;
+          if (i2 && a2 && a2.length > 0) {
+            const n3 = gn({ ...i2, simulation: a2 });
+            f2 = n3.wrappedEnv, u2 = n3.calls;
+          }
+          const l2 = { ...o2 };
+          f2 && (l2.env = f2);
+          const { collector: d2 } = await ln({ consent: r2 || c2, destinations: { sim: { code: t2, config: l2 } } });
+          return await d2.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)) };
   }
 }
 
+// src/commands/simulate/simulator.ts
+init_cli_logger();
+
 // src/commands/simulate/env-loader.ts
 async function loadDestinationEnvs(destinations) {
   const envs = {};
@@ -2201,11 +2708,34 @@ async function loadDestinationEnvs(destinations) {
 }
 
 // src/commands/simulate/simulator.ts
-function generateId() {
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+function createCollectorLoggerConfigInline(logger2, verbose) {
+  return {
+    level: verbose ? Level2.DEBUG : Level2.ERROR,
+    handler: (level, message, context, scope) => {
+      const scopePath = scope.length > 0 ? `[${scope.join(":")}] ` : "";
+      const hasContext = Object.keys(context).length > 0;
+      const contextStr = hasContext ? ` ${JSON.stringify(context)}` : "";
+      if (level === Level2.ERROR) {
+        logger2.error(`${scopePath}${message}${contextStr}`);
+      } else {
+        logger2.debug(`${scopePath}${message}${contextStr}`);
+      }
+    }
+  };
+}
+function callsToUsage(destName, calls) {
+  if (!calls.length) return {};
+  return {
+    [destName]: calls.map((c2) => ({
+      type: "call",
+      path: c2.fn,
+      args: c2.args,
+      timestamp: c2.ts
+    }))
+  };
 }
 async function simulateCore(inputPath, event, options = {}) {
-  const logger2 = createLogger({
+  const logger2 = createCLILogger({
     verbose: options.verbose || false,
     silent: options.silent || false,
     json: options.json || false
@@ -2214,6 +2744,7 @@ async function simulateCore(inputPath, event, options = {}) {
     logger2.debug(`Simulating event: ${JSON.stringify(event)}`);
     const result = await executeSimulation(event, inputPath, options.platform, {
       flow: options.flow,
+      step: options.step,
       logger: logger2,
       verbose: options.verbose
     });
@@ -2233,18 +2764,43 @@ function formatSimulationResult(result, options = {}) {
       usage: result.usage,
       duration: result.duration
     };
+    if (result.capturedEvents) {
+      output.capturedEvents = result.capturedEvents;
+    }
+    if (result.exampleMatch) {
+      output.exampleMatch = result.exampleMatch;
+    }
     return JSON.stringify(output, null, 2);
   }
+  const lines = [];
   if (result.success) {
-    return "Simulation completed";
+    lines.push("Simulation completed");
   } else {
-    return `Simulation failed: ${result.error}`;
+    lines.push(`Simulation failed: ${result.error}`);
+  }
+  if (result.capturedEvents) {
+    lines.push(`Captured ${result.capturedEvents.length} event(s)`);
+    for (const evt of result.capturedEvents) {
+      lines.push(`  - ${evt.name || "unknown"}`);
+    }
   }
+  if (result.exampleMatch) {
+    const em = result.exampleMatch;
+    if (em.match) {
+      lines.push(`Example "${em.name}" (${em.step}): PASS`);
+    } else {
+      lines.push(`Example "${em.name}" (${em.step}): FAIL`);
+      if (em.diff) {
+        lines.push(em.diff);
+      }
+    }
+  }
+  return lines.join("\n");
 }
 async function executeSimulation(event, inputPath, platformOverride, options = {}) {
-  const startTime2 = Date.now();
+  const startTime = Date.now();
   const tempDir = getTmpPath();
-  const collectorLoggerConfig = options.logger ? createCollectorLoggerConfig(options.logger, options.verbose) : void 0;
+  const collectorLoggerConfig = options.logger ? createCollectorLoggerConfigInline(options.logger, options.verbose) : void 0;
   try {
     await fs11.ensureDir(tempDir);
     const detected = await detectInput(inputPath, platformOverride);
@@ -2254,176 +2810,436 @@ async function executeSimulation(event, inputPath, platformOverride, options = {
       );
     }
     const typedEvent = event;
-    if (detected.type === "config") {
-      return await executeConfigSimulation(
-        detected.content,
-        inputPath,
-        typedEvent,
-        tempDir,
-        startTime2,
-        collectorLoggerConfig,
-        options.flow
+    if (detected.type !== "config") {
+      throw new Error(
+        `Input "${inputPath}" is not valid JSON config. simulate only accepts Flow.Setup config files.`
       );
-    } else {
-      return await executeBundleSimulation(
-        detected.content,
-        detected.platform,
-        typedEvent,
-        tempDir,
-        startTime2,
-        collectorLoggerConfig
+    }
+    return await executeConfigSimulation(
+      detected.content,
+      inputPath,
+      typedEvent,
+      tempDir,
+      startTime,
+      collectorLoggerConfig,
+      options.flow,
+      options.step
+    );
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    return {
+      success: false,
+      error: getErrorMessage(error),
+      duration
+    };
+  } finally {
+    if (tempDir) {
+      await fs11.remove(tempDir).catch(() => {
+      });
+    }
+  }
+}
+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`);
+      }
+      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");
+}
+async function executeConfigSimulation(_content, configPath, typedEvent, tempDir, startTime, loggerConfig2, flowName, stepTarget) {
+  const { flowConfig } = await loadFlowConfig(configPath, {
+    flowName
+  });
+  const step = parseStepTarget(
+    stepTarget,
+    flowConfig
+  );
+  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 = flowConfig.destinations;
+    const envs = await loadDestinationEnvs(destinations || {});
+    const destEnv = envs[step.name];
+    const result = await mn({
+      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 mn({
+      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: []
+    };
+  }
+  throw new Error(`Unknown step type: ${step.type}`);
+}
+
+// src/commands/simulate/source-simulator.ts
+import { JSDOM, VirtualConsole } from "jsdom";
+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`);
+  }
+  let setup;
+  try {
+    const devModule = await import(`${packageName}/dev`);
+    const examples = devModule.examples || devModule.default?.examples;
+    if (examples?.setup && typeof examples.setup === "function") {
+      setup = examples.setup;
+    }
+  } catch {
+  }
+  return { code, setup };
+}
+async function simulateSourceCLI(flowConfig, setupInput, 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(", ");
+      throw new Error(
+        `Source "${options.sourceStep}" not found. Available: ${available}`
       );
     }
+    if (!sourceConfig.package) {
+      throw new Error(`Source "${options.sourceStep}" has no package field`);
+    }
+    const { code, setup } = await loadSourcePackage(sourceConfig.package);
+    const virtualConsole = new VirtualConsole();
+    const dom = new JSDOM(
+      "<!DOCTYPE html><html><head></head><body></body></html>",
+      {
+        url: "http://localhost",
+        runScripts: "dangerously",
+        pretendToBeVisual: true,
+        virtualConsole
+      }
+    );
+    const env = {
+      window: dom.window,
+      document: dom.window.document,
+      localStorage: dom.window.localStorage
+    };
+    const result = await mn({
+      step: "source",
+      name: options.sourceStep,
+      code,
+      config: sourceConfig.config || {},
+      setup,
+      input: setupInput,
+      env
+    });
+    dom.window.close();
+    return {
+      success: !result.error,
+      error: result.error?.message,
+      capturedEvents: result.events,
+      duration: Date.now() - startTime
+    };
   } catch (error) {
-    const duration = Date.now() - startTime2;
     return {
       success: false,
       error: getErrorMessage(error),
-      duration
+      duration: Date.now() - startTime
     };
-  } finally {
-    if (tempDir) {
-      await fs11.remove(tempDir).catch(() => {
-      });
-    }
   }
 }
-async function executeConfigSimulation(_content, configPath, typedEvent, tempDir, startTime2, loggerConfig2, flowName) {
-  const { flowConfig, buildOptions } = await loadFlowConfig(configPath, {
-    flowName
-  });
-  const platform = getPlatform3(flowConfig);
-  const tracker = new CallTracker();
-  const tempOutput = path11.join(
-    tempDir,
-    `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
-  );
-  const destinations = flowConfig.destinations;
-  const simulationBuildOptions = {
-    ...buildOptions,
-    code: buildOptions.code || "",
-    output: tempOutput,
-    tempDir,
-    ...platform === "web" ? {
-      format: "iife",
-      platform: "browser",
-      windowCollector: "collector",
-      windowElb: "elb"
-    } : {
-      format: "esm",
-      platform: "node"
-    }
-  };
-  await bundleCore(
-    flowConfig,
-    simulationBuildOptions,
-    createLogger({ silent: true }),
-    false
-  );
-  const envs = await loadDestinationEnvs(destinations || {});
-  let result;
-  if (platform === "web") {
-    result = await executeInJSDOM(
-      tempOutput,
-      destinations || {},
-      typedEvent,
-      tracker,
-      envs,
-      1e4
+
+// src/commands/simulate/index.ts
+init_cli_logger();
+
+// 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")`
     );
-  } else {
-    result = await executeInNode(
-      tempOutput,
-      destinations || {},
-      typedEvent,
-      tracker,
-      envs,
-      3e4,
-      loggerConfig2 ? { logger: loggerConfig2 } : {}
+  }
+  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}`
     );
   }
-  const duration = Date.now() - startTime2;
   return {
-    success: true,
-    elbResult: result.elbResult,
-    usage: result.usage,
-    duration,
-    logs: []
+    stepType: type,
+    stepName: name,
+    exampleName,
+    example: examples[exampleName]
   };
 }
-async function executeBundleSimulation(bundleContent, platform, typedEvent, tempDir, startTime2, loggerConfig2) {
-  const tempOutput = path11.join(
-    tempDir,
-    `bundle-${generateId()}.${platform === "server" ? "mjs" : "js"}`
-  );
-  await fs11.writeFile(tempOutput, bundleContent, "utf8");
-  const tracker = new CallTracker();
-  let result;
-  if (platform === "web") {
-    result = await executeInJSDOM(
-      tempOutput,
-      {},
-      typedEvent,
-      tracker,
-      {},
-      1e4
-    );
-  } else {
-    result = await executeInNode(
-      tempOutput,
-      {},
-      typedEvent,
-      tracker,
-      {},
-      3e4,
-      loggerConfig2 ? { logger: loggerConfig2 } : {}
+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.`
     );
   }
-  const duration = Date.now() - startTime2;
+  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 {
-    success: true,
-    elbResult: result.elbResult,
-    usage: result.usage,
-    duration,
-    logs: []
+    expected,
+    actual,
+    match: false,
+    diff: `Expected:
+${expectedStr}
+
+Actual:
+${actualStr}`
   };
 }
 
 // src/commands/simulate/index.ts
 async function simulateCommand(options) {
-  const logger2 = createCommandLogger({ ...options, stderr: true });
-  const startTime2 = Date.now();
+  const logger2 = createCLILogger({ ...options, stderr: true });
+  const startTime = Date.now();
   try {
     let config;
     if (isStdinPiped() && !options.config) {
       const stdinContent = await readStdin();
       const fs14 = await import("fs-extra");
-      const path15 = await import("path");
+      const path14 = await import("path");
       const tmpPath = getTmpPath(void 0, "stdin-simulate.json");
-      await fs14.default.ensureDir(path15.default.dirname(tmpPath));
+      await fs14.default.ensureDir(path14.default.dirname(tmpPath));
       await fs14.default.writeFile(tmpPath, stdinContent, "utf-8");
       config = tmpPath;
     } else {
       config = options.config || "bundle.config.json";
     }
-    const event = await loadJsonFromSource(options.event, {
-      name: "event"
-    });
-    const result = await simulateCore(config, event, {
-      flow: options.flow,
-      json: options.json,
-      verbose: options.verbose,
-      silent: options.silent
-    });
+    let event;
+    let exampleContext;
+    if (options.example) {
+      const rawConfig = await loadJsonConfig(config);
+      const setup = validateFlowSetup(rawConfig);
+      const flowNames = Object.keys(setup.flows);
+      let flowName = options.flow;
+      if (!flowName) {
+        if (flowNames.length === 1) {
+          flowName = flowNames[0];
+        } else {
+          throw new Error(
+            `Multiple flows found. Use --flow to specify which flow contains the example.
+Available flows: ${flowNames.join(", ")}`
+          );
+        }
+      }
+      const flowConfig = setup.flows[flowName];
+      if (!flowConfig) {
+        throw new Error(
+          `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
+        );
+      }
+      const found = findExample(flowConfig, options.example, options.step);
+      if (found.example.in === void 0) {
+        throw new Error(
+          `Example "${options.example}" in ${found.stepType}.${found.stepName} has no "in" value`
+        );
+      }
+      event = found.example.in;
+      exampleContext = {
+        stepType: found.stepType,
+        stepName: found.stepName,
+        expected: found.example.out
+      };
+    } else {
+      event = await loadJsonFromSource(options.event, {
+        name: "event"
+      });
+    }
+    const isSourceSimulation = exampleContext?.stepType === "source" || options.step?.startsWith("source.");
+    let result;
+    if (isSourceSimulation) {
+      const rawConfig = await loadJsonConfig(config);
+      const setup = validateFlowSetup(rawConfig);
+      const flowNames = Object.keys(setup.flows);
+      const flowName = options.flow || (flowNames.length === 1 ? flowNames[0] : void 0);
+      if (!flowName) {
+        throw new Error(
+          `Multiple flows found. Use --flow to specify which flow.
+Available: ${flowNames.join(", ")}`
+        );
+      }
+      const flowConfig = setup.flows[flowName];
+      if (!flowConfig) {
+        throw new Error(
+          `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
+        );
+      }
+      const sourceStep = exampleContext?.stepName || options.step.substring("source.".length);
+      result = await simulateSourceCLI(
+        flowConfig,
+        event,
+        {
+          flow: options.flow,
+          sourceStep,
+          json: options.json,
+          verbose: options.verbose,
+          silent: options.silent
+        }
+      );
+    } else {
+      const stepTarget = exampleContext ? `${exampleContext.stepType}.${exampleContext.stepName}` : options.step;
+      result = await simulateCore(config, event, {
+        flow: options.flow,
+        json: options.json,
+        verbose: options.verbose,
+        silent: options.silent,
+        step: stepTarget
+      });
+    }
+    let exampleMatch;
+    if (exampleContext && result.success) {
+      const stepKey = `${exampleContext.stepType}.${exampleContext.stepName}`;
+      if (exampleContext.expected === false) {
+        const calls = result.usage?.[exampleContext.stepName];
+        const wasFiltered = !calls || calls.length === 0;
+        exampleMatch = {
+          name: options.example,
+          step: stepKey,
+          expected: false,
+          actual: wasFiltered ? false : calls,
+          match: wasFiltered,
+          diff: wasFiltered ? void 0 : `Expected event to be filtered, but ${calls.length} API call(s) were made`
+        };
+      } else if (exampleContext.expected !== void 0) {
+        const actual = result.usage?.[exampleContext.stepName] ?? [];
+        exampleMatch = {
+          name: options.example,
+          step: stepKey,
+          ...compareOutput(exampleContext.expected, actual)
+        };
+      }
+    }
     const resultWithDuration = {
       ...result,
-      duration: (Date.now() - startTime2) / 1e3
+      duration: (Date.now() - startTime) / 1e3,
+      ...exampleMatch ? { exampleMatch } : {}
     };
     const formatted = formatSimulationResult(resultWithDuration, {
       json: options.json
     });
     await writeResult(formatted + "\n", { output: options.output });
-    process.exit(result.success ? 0 : 1);
+    const exitCode = !result.success || exampleMatch && !exampleMatch.match ? 1 : 0;
+    process.exit(exitCode);
   } catch (error) {
     const errorMessage = getErrorMessage(error);
     if (options.json) {
@@ -2431,7 +3247,7 @@ async function simulateCommand(options) {
         {
           success: false,
           error: errorMessage,
-          duration: (Date.now() - startTime2) / 1e3
+          duration: (Date.now() - startTime) / 1e3
         },
         null,
         2
@@ -2449,28 +3265,102 @@ async function simulate(configOrPath, event, options = {}) {
       "simulate() currently only supports config file paths. Config object support will be added in a future version. Please provide a path to a configuration file."
     );
   }
-  return await simulateCore(configOrPath, event, {
+  let resolvedEvent = event;
+  let exampleContext;
+  if (options.example) {
+    const rawConfig = await loadJsonConfig(configOrPath);
+    const setup = validateFlowSetup(rawConfig);
+    const flowNames = Object.keys(setup.flows);
+    let flowName = options.flow;
+    if (!flowName) {
+      if (flowNames.length === 1) {
+        flowName = flowNames[0];
+      } else {
+        throw new Error(
+          `Multiple flows found. Use --flow to specify which flow contains the example.
+Available flows: ${flowNames.join(", ")}`
+        );
+      }
+    }
+    const flowConfig = setup.flows[flowName];
+    if (!flowConfig) {
+      throw new Error(
+        `Flow "${flowName}" not found. Available: ${flowNames.join(", ")}`
+      );
+    }
+    const found = findExample(flowConfig, options.example, options.step);
+    if (found.example.in === void 0) {
+      throw new Error(
+        `Example "${options.example}" in ${found.stepType}.${found.stepName} has no "in" value`
+      );
+    }
+    resolvedEvent = found.example.in;
+    exampleContext = {
+      stepType: found.stepType,
+      stepName: found.stepName,
+      expected: found.example.out
+    };
+  }
+  const result = await simulateCore(configOrPath, resolvedEvent, {
     json: options.json ?? false,
     verbose: options.verbose ?? false,
     flow: options.flow,
     platform: options.platform
   });
+  if (exampleContext && result.success) {
+    const stepKey = `${exampleContext.stepType}.${exampleContext.stepName}`;
+    if (exampleContext.expected === false) {
+      const calls = result.usage?.[exampleContext.stepName];
+      const wasFiltered = !calls || calls.length === 0;
+      result.exampleMatch = {
+        name: options.example,
+        step: stepKey,
+        expected: false,
+        actual: wasFiltered ? false : calls,
+        match: wasFiltered,
+        diff: wasFiltered ? void 0 : `Expected event to be filtered, but ${calls.length} API call(s) were made`
+      };
+    } else if (exampleContext.expected !== void 0) {
+      const actual = result.usage?.[exampleContext.stepName] ?? [];
+      result.exampleMatch = {
+        name: options.example,
+        step: stepKey,
+        ...compareOutput(exampleContext.expected, actual)
+      };
+    }
+  }
+  return result;
 }
 
 // src/commands/push/index.ts
-import path12 from "path";
+init_cli_logger();
+import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
 import fs12 from "fs-extra";
-import {
-  getPlatform as getPlatform4
-} from "@walkeros/core";
+import { getPlatform as getPlatform3 } from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
+import { Level as Level3 } from "@walkeros/core";
+function createCollectorLoggerConfig(logger2, verbose) {
+  return {
+    level: verbose ? Level3.DEBUG : Level3.ERROR,
+    handler: (level, message, context, scope) => {
+      const scopePath = scope.length > 0 ? `[${scope.join(":")}] ` : "";
+      const hasContext = Object.keys(context).length > 0;
+      const contextStr = hasContext ? ` ${JSON.stringify(context)}` : "";
+      if (level === Level3.ERROR) {
+        logger2.error(`${scopePath}${message}${contextStr}`);
+      } else {
+        logger2.debug(`${scopePath}${message}${contextStr}`);
+      }
+    }
+  };
+}
 async function pushCore(inputPath, event, options = {}) {
-  const logger2 = createCommandLogger({
+  const logger2 = createCLILogger({
     silent: options.silent,
     verbose: options.verbose
   });
-  const startTime2 = Date.now();
+  const startTime = Date.now();
   let tempDir;
   try {
     let loadedEvent = event;
@@ -2491,7 +3381,7 @@ async function pushCore(inputPath, event, options = {}) {
       data: parsedEvent.data || {}
     };
     if (!validatedEvent.name.includes(" ")) {
-      logger2.log(
+      logger2.info(
         `Warning: Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
       );
     }
@@ -2515,10 +3405,6 @@ async function pushCore(inputPath, event, options = {}) {
         }
       );
     } else {
-      const collectorLoggerConfig = createCollectorLoggerConfig(
-        logger2,
-        options.verbose
-      );
       result = await executeBundlePush(
         detected.content,
         detected.platform,
@@ -2527,14 +3413,14 @@ async function pushCore(inputPath, event, options = {}) {
         (dir) => {
           tempDir = dir;
         },
-        { logger: collectorLoggerConfig }
+        { logger: createCollectorLoggerConfig(logger2, options.verbose) }
       );
     }
     return result;
   } catch (error) {
     return {
       success: false,
-      duration: Date.now() - startTime2,
+      duration: Date.now() - startTime,
       error: getErrorMessage(error)
     };
   } finally {
@@ -2545,14 +3431,14 @@ async function pushCore(inputPath, event, options = {}) {
   }
 }
 async function pushCommand(options) {
-  const logger2 = createCommandLogger({ ...options, stderr: true });
-  const startTime2 = Date.now();
+  const logger2 = createCLILogger({ ...options, stderr: true });
+  const startTime = Date.now();
   try {
     let config;
     if (isStdinPiped() && !options.config) {
       const stdinContent = await readStdin();
       const tmpPath = getTmpPath(void 0, "stdin-push.json");
-      await fs12.ensureDir(path12.dirname(tmpPath));
+      await fs12.ensureDir(path11.dirname(tmpPath));
       await fs12.writeFile(tmpPath, stdinContent, "utf-8");
       config = tmpPath;
     } else {
@@ -2566,7 +3452,7 @@ async function pushCommand(options) {
       silent: options.silent,
       platform: options.platform
     });
-    const duration = Date.now() - startTime2;
+    const duration = Date.now() - startTime;
     let output;
     if (options.json) {
       output = JSON.stringify(
@@ -2600,7 +3486,7 @@ async function pushCommand(options) {
     await writeResult(output + "\n", { output: options.output });
     process.exit(result.success ? 0 : 1);
   } catch (error) {
-    const duration = Date.now() - startTime2;
+    const duration = Date.now() - startTime;
     const errorMessage = getErrorMessage(error);
     if (options.json) {
       const errorOutput = JSON.stringify(
@@ -2634,7 +3520,7 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
     flowName: options.flow,
     logger: logger2
   });
-  const platform = getPlatform4(flowConfig);
+  const platform = getPlatform3(flowConfig);
   logger2.debug("Bundling flow configuration");
   const configDir = buildOptions.configDir || process.cwd();
   const tempDir = getTmpPath(
@@ -2643,7 +3529,7 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
   );
   setTempDir(tempDir);
   await fs12.ensureDir(tempDir);
-  const tempPath = path12.join(
+  const tempPath = path11.join(
     tempDir,
     `bundle.${platform === "web" ? "js" : "mjs"}`
   );
@@ -2664,12 +3550,8 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
     return executeWebPush(tempPath, validatedEvent, logger2);
   } else if (platform === "server") {
     logger2.debug("Executing in server environment (Node.js)");
-    const collectorLoggerConfig = createCollectorLoggerConfig(
-      logger2,
-      options.verbose
-    );
     return executeServerPush(tempPath, validatedEvent, logger2, 6e4, {
-      logger: collectorLoggerConfig
+      logger: createCollectorLoggerConfig(logger2, options.verbose)
     });
   } else {
     throw new Error(`Unsupported platform: ${platform}`);
@@ -2682,7 +3564,7 @@ async function executeBundlePush(bundleContent, platform, validatedEvent, logger
   );
   setTempDir(tempDir);
   await fs12.ensureDir(tempDir);
-  const tempPath = path12.join(
+  const tempPath = path11.join(
     tempDir,
     `bundle.${platform === "server" ? "mjs" : "js"}`
   );
@@ -2697,7 +3579,7 @@ async function executeBundlePush(bundleContent, platform, validatedEvent, logger
   }
 }
 async function executeWebPush(bundlePath, event, logger2) {
-  const startTime2 = Date.now();
+  const startTime = Date.now();
   try {
     const virtualConsole = new VirtualConsole2();
     const dom = new JSDOM2("<!DOCTYPE html><html><body></body></html>", {
@@ -2711,14 +3593,14 @@ async function executeWebPush(bundlePath, event, logger2) {
     const bundleCode = await fs12.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
     logger2.debug("Waiting for collector...");
-    await waitForWindowProperty2(
+    await waitForWindowProperty(
       window,
       "collector",
       5e3
     );
     const windowObj = window;
     const collector = windowObj.collector;
-    logger2.log(`Pushing event: ${event.name}`);
+    logger2.info(`Pushing event: ${event.name}`);
     const elbResult = await collector.push({
       name: event.name,
       data: event.data
@@ -2726,21 +3608,22 @@ async function executeWebPush(bundlePath, event, logger2) {
     return {
       success: true,
       elbResult,
-      duration: Date.now() - startTime2
+      duration: Date.now() - startTime
     };
   } catch (error) {
     return {
       success: false,
-      duration: Date.now() - startTime2,
+      duration: Date.now() - startTime,
       error: getErrorMessage(error)
     };
   }
 }
 async function executeServerPush(bundlePath, event, logger2, timeout = 6e4, context = {}) {
-  const startTime2 = Date.now();
+  const startTime = Date.now();
+  let timer;
   try {
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(
+    const timeoutPromise = new Promise((_2, reject) => {
+      timer = setTimeout(
         () => reject(new Error(`Server push timeout after ${timeout}ms`)),
         timeout
       );
@@ -2759,7 +3642,7 @@ async function executeServerPush(bundlePath, event, logger2, timeout = 6e4, cont
         );
       }
       const { collector } = result;
-      logger2.log(`Pushing event: ${event.name}`);
+      logger2.info(`Pushing event: ${event.name}`);
       const elbResult = await collector.push({
         name: event.name,
         data: event.data
@@ -2767,24 +3650,26 @@ async function executeServerPush(bundlePath, event, logger2, timeout = 6e4, cont
       return {
         success: true,
         elbResult,
-        duration: Date.now() - startTime2
+        duration: Date.now() - startTime
       };
     })();
     return await Promise.race([executePromise, timeoutPromise]);
   } catch (error) {
     return {
       success: false,
-      duration: Date.now() - startTime2,
+      duration: Date.now() - startTime,
       error: getErrorMessage(error)
     };
+  } finally {
+    clearTimeout(timer);
   }
 }
-function waitForWindowProperty2(window, prop, timeout = 5e3) {
-  return new Promise((resolve3, reject) => {
+function waitForWindowProperty(window, prop, timeout = 5e3) {
+  return new Promise((resolve2, reject) => {
     const start = Date.now();
     const check = () => {
       if (window[prop] !== void 0) {
-        resolve3();
+        resolve2();
       } else if (Date.now() - start > timeout) {
         reject(
           new Error(
@@ -2800,105 +3685,103 @@ function waitForWindowProperty2(window, prop, timeout = 5e3) {
 }
 
 // src/commands/run/index.ts
-import path14 from "path";
+init_cli_logger();
+import path13 from "path";
 
 // src/commands/run/validators.ts
 import { existsSync as existsSync3 } from "fs";
 
 // src/schemas/primitives.ts
-import { z } from "@walkeros/core/dev";
-var RunModeSchema = z.enum(["collect", "serve"]).describe("CLI run mode: collect events or serve HTTP");
-var PortSchema = z.number().int("Port must be an integer").min(1, "Port must be at least 1").max(65535, "Port must be at most 65535").describe("HTTP server port number");
-var FilePathSchema = z.string().min(1, "File path cannot be empty").describe("Path to configuration file");
+import { z as z2 } from "@walkeros/core/dev";
+var PortSchema = z2.number().int("Port must be an integer").min(1, "Port must be at least 1").max(65535, "Port must be at most 65535").describe("HTTP server port number");
+var FilePathSchema = z2.string().min(1, "File path cannot be empty").describe("Path to configuration file");
 
 // src/schemas/run.ts
-import { z as z2 } from "@walkeros/core/dev";
-var RunOptionsSchema = z2.object({
-  mode: RunModeSchema,
+import { z as z3 } from "@walkeros/core/dev";
+var RunOptionsSchema = z3.object({
   flow: FilePathSchema,
   port: PortSchema.default(8080),
-  flowName: z2.string().optional().describe("Specific flow name to run")
+  flowName: z3.string().optional().describe("Specific flow name to run")
 });
 
 // src/schemas/validate.ts
-import { z as z3 } from "@walkeros/core/dev";
-var ValidationTypeSchema = z3.union([
-  z3.enum(["event", "flow", "mapping"]),
-  z3.string().regex(/^(destinations|sources|transformers)\.\w+$|^\w+$/)
-]).describe(
-  'Validation type: "event", "flow", "mapping", or dot-notation path (e.g., "destinations.snowplow") to validate a specific entry against its package schema'
-);
-var ValidateOptionsSchema = z3.object({
-  flow: z3.string().optional().describe("Flow name for multi-flow configs")
+import { z as z4 } from "@walkeros/core/dev";
+var ValidationTypeSchema = z4.enum(["contract", "event", "flow", "mapping"]).describe('Validation type: "event", "flow", "mapping", or "contract"');
+var ValidateOptionsSchema = z4.object({
+  flow: z4.string().optional().describe("Flow name for multi-flow configs"),
+  path: z4.string().optional().describe(
+    'Entry path for package schema validation (e.g., "destinations.snowplow", "sources.browser")'
+  )
 });
 var ValidateInputShape = {
   type: ValidationTypeSchema,
-  input: z3.string().min(1).describe("JSON string, file path, or URL to validate"),
-  flow: z3.string().optional().describe("Flow name for multi-flow configs")
+  input: z4.string().min(1).describe("JSON string, file path, or URL to validate"),
+  flow: z4.string().optional().describe("Flow name for multi-flow configs"),
+  path: z4.string().optional().describe(
+    'Entry path for package schema validation (e.g., "destinations.snowplow"). When provided, validates the entry against its package JSON Schema instead of using --type.'
+  )
 };
-var ValidateInputSchema = z3.object(ValidateInputShape);
+var ValidateInputSchema = z4.object(ValidateInputShape);
 
 // src/schemas/bundle.ts
-import { z as z4 } from "@walkeros/core/dev";
-var BundleOptionsSchema = z4.object({
-  silent: z4.boolean().optional().describe("Suppress all output"),
-  verbose: z4.boolean().optional().describe("Enable verbose logging"),
-  stats: z4.boolean().optional().default(true).describe("Return bundle statistics"),
-  cache: z4.boolean().optional().default(true).describe("Enable package caching"),
-  flowName: z4.string().optional().describe("Flow name for multi-flow configs")
+import { z as z5 } from "@walkeros/core/dev";
+var BundleOptionsSchema = z5.object({
+  silent: z5.boolean().optional().describe("Suppress all output"),
+  verbose: z5.boolean().optional().describe("Enable verbose logging"),
+  stats: z5.boolean().optional().default(true).describe("Return bundle statistics"),
+  cache: z5.boolean().optional().default(true).describe("Enable package caching"),
+  flowName: z5.string().optional().describe("Flow name for multi-flow configs")
 });
 var BundleInputShape = {
   configPath: FilePathSchema.describe(
     "Path to flow configuration file (JSON or JavaScript)"
   ),
-  flow: z4.string().optional().describe("Flow name for multi-flow configs"),
-  stats: z4.boolean().optional().default(true).describe("Return bundle statistics"),
-  output: z4.string().optional().describe("Output file path (defaults to config-defined)")
+  flow: z5.string().optional().describe("Flow name for multi-flow configs"),
+  stats: z5.boolean().optional().default(true).describe("Return bundle statistics"),
+  output: z5.string().optional().describe("Output file path (defaults to config-defined)")
 };
-var BundleInputSchema = z4.object(BundleInputShape);
+var BundleInputSchema = z5.object(BundleInputShape);
 
 // src/schemas/simulate.ts
-import { z as z5 } from "@walkeros/core/dev";
-var PlatformSchema = z5.enum(["web", "server"]).describe("Platform type for event processing");
-var SimulateOptionsSchema = z5.object({
-  silent: z5.boolean().optional().describe("Suppress all output"),
-  verbose: z5.boolean().optional().describe("Enable verbose logging"),
-  json: z5.boolean().optional().describe("Format output as JSON")
+import { z as z6 } from "@walkeros/core/dev";
+var PlatformSchema = z6.enum(["web", "server"]).describe("Platform type for event processing");
+var SimulateOptionsSchema = z6.object({
+  silent: z6.boolean().optional().describe("Suppress all output"),
+  verbose: z6.boolean().optional().describe("Enable verbose logging"),
+  json: z6.boolean().optional().describe("Format output as JSON")
 });
 var SimulateInputShape = {
   configPath: FilePathSchema.describe("Path to flow configuration file"),
-  event: z5.string().min(1).describe("Event as JSON string, file path, or URL"),
-  flow: z5.string().optional().describe("Flow name for multi-flow configs"),
-  platform: PlatformSchema.optional().describe("Override platform detection")
+  event: z6.string().min(1).optional().describe(
+    "Event as JSON string, file path, or URL. Optional when example is provided."
+  ),
+  flow: z6.string().optional().describe("Flow name for multi-flow configs"),
+  platform: PlatformSchema.optional().describe("Override platform detection"),
+  example: z6.string().optional().describe(
+    'Name of a step example to use as event input (uses its "in" value)'
+  ),
+  step: z6.string().optional().describe(
+    'Step target in type.name format (e.g. "destination.gtag") to narrow example lookup'
+  )
 };
-var SimulateInputSchema = z5.object(SimulateInputShape);
+var SimulateInputSchema = z6.object(SimulateInputShape);
 
 // src/schemas/push.ts
-import { z as z6 } from "@walkeros/core/dev";
-var PushOptionsSchema = z6.object({
-  silent: z6.boolean().optional().describe("Suppress all output"),
-  verbose: z6.boolean().optional().describe("Enable verbose logging"),
-  json: z6.boolean().optional().describe("Format output as JSON")
+import { z as z7 } from "@walkeros/core/dev";
+var PushOptionsSchema = z7.object({
+  silent: z7.boolean().optional().describe("Suppress all output"),
+  verbose: z7.boolean().optional().describe("Enable verbose logging"),
+  json: z7.boolean().optional().describe("Format output as JSON")
 });
 var PushInputShape = {
   configPath: FilePathSchema.describe("Path to flow configuration file"),
-  event: z6.string().min(1).describe("Event as JSON string, file path, or URL"),
-  flow: z6.string().optional().describe("Flow name for multi-flow configs"),
+  event: z7.string().min(1).describe("Event as JSON string, file path, or URL"),
+  flow: z7.string().optional().describe("Flow name for multi-flow configs"),
   platform: PlatformSchema.optional().describe("Override platform detection")
 };
-var PushInputSchema = z6.object(PushInputShape);
+var PushInputSchema = z7.object(PushInputShape);
 
 // src/commands/run/validators.ts
-function validateMode(mode) {
-  const result = RunModeSchema.safeParse(mode);
-  if (!result.success) {
-    throw new Error(
-      `Invalid mode: "${mode}"
-   Valid modes: collect, serve
-   Example: walkeros run collect ./flow.json`
-    );
-  }
-}
 function validateFlowFile(filePath) {
   const absolutePath = resolveAsset(filePath, "bundle");
   if (!existsSync3(absolutePath)) {
@@ -2922,7 +3805,7 @@ function validatePort(port) {
 }
 
 // src/commands/run/utils.ts
-import path13 from "path";
+import path12 from "path";
 import fs13 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
   const tempDir = getTmpPath(
@@ -2930,11 +3813,12 @@ async function prepareBundleForRun(configPath, options) {
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   await fs13.ensureDir(tempDir);
-  const tempPath = path13.join(tempDir, "bundle.mjs");
+  const tempPath = path12.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
     verbose: options.verbose,
     silent: options.silent,
+    flowName: options.flowName,
     buildOverrides: {
       output: tempPath,
       format: "esm",
@@ -2948,28 +3832,42 @@ function isPreBuiltConfig(configPath) {
 }
 
 // src/commands/run/execution.ts
-import { createLogger as createLogger2, Level } from "@walkeros/core";
+import { createLogger as createLogger2, Level as Level4 } from "@walkeros/core";
 
 // src/runtime/runner.ts
-import { pathToFileURL as pathToFileURL2 } from "url";
+import { pathToFileURL } from "url";
 import { resolve, dirname } from "path";
-async function loadFlow(file, config, logger2, loggerConfig2) {
+async function loadFlow(file, config, logger2, loggerConfig2, healthServer) {
   const absolutePath = resolve(file);
   const flowDir = dirname(absolutePath);
   process.chdir(flowDir);
-  const fileUrl = pathToFileURL2(absolutePath).href;
+  const fileUrl = pathToFileURL(absolutePath).href;
   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`
     );
   }
-  const flowContext = loggerConfig2 ? { ...config, logger: loggerConfig2 } : config;
+  const flowContext = {
+    ...config,
+    ...loggerConfig2 ? { logger: loggerConfig2 } : {},
+    ...healthServer ? { externalServer: true } : {}
+  };
   const result = await module.default(flowContext);
   if (!result || !result.collector) {
     throw new Error(`Invalid flow bundle: ${file} must return { collector }`);
   }
-  return { collector: result.collector, file };
+  if (healthServer && typeof result.httpHandler === "function") {
+    healthServer.setFlowHandler(result.httpHandler);
+  }
+  return {
+    collector: {
+      command: result.collector.command,
+      status: result.collector.status
+    },
+    file,
+    httpHandler: result.httpHandler
+  };
 }
 async function runFlow(file, config, logger2, loggerConfig2) {
   logger2.info(`Loading flow from ${file}`);
@@ -2981,13 +3879,19 @@ async function runFlow(file, config, logger2, loggerConfig2) {
     }
     const shutdown = async (signal) => {
       logger2.info(`Received ${signal}, shutting down gracefully...`);
+      const forceTimer = setTimeout(() => {
+        logger2.error("Shutdown timed out, forcing exit");
+        process.exit(1);
+      }, 15e3);
       try {
         if (handle.collector.command) {
           await handle.collector.command("shutdown");
         }
         logger2.info("Shutdown complete");
+        clearTimeout(forceTimer);
         process.exit(0);
       } catch (error) {
+        clearTimeout(forceTimer);
         const message = error instanceof Error ? error.message : String(error);
         logger2.error(`Error during shutdown: ${message}`);
         process.exit(1);
@@ -3007,198 +3911,73 @@ async function runFlow(file, config, logger2, loggerConfig2) {
   }
 }
 
-// src/runtime/serve.ts
-import express from "express";
-import { resolve as resolve2 } from "path";
-
-// src/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join2 } from "path";
-var versionFilename = fileURLToPath2(import.meta.url);
-var versionDirname = dirname2(versionFilename);
-function findPackageJson() {
-  const paths = [
-    join2(versionDirname, "../package.json"),
-    // dist/ or src/
-    join2(versionDirname, "../../package.json")
-    // src/core/ (not used, but safe)
-  ];
-  for (const p of paths) {
-    try {
-      return readFileSync2(p, "utf-8");
-    } catch {
-    }
-  }
-  return JSON.stringify({ version: "0.0.0" });
-}
-var VERSION = JSON.parse(findPackageJson()).version;
-
 // src/runtime/heartbeat.ts
+init_version();
 import { randomBytes } from "crypto";
 var instanceId = randomBytes(8).toString("hex");
-function getInstanceId() {
-  return instanceId;
-}
-
-// src/runtime/status.ts
-var state = null;
-var startTime = Date.now();
-var currentStatus = "starting";
-var lastPollTime;
-var lastHeartbeatTime;
-function getStatus() {
-  return {
-    status: currentStatus,
-    version: VERSION,
-    mode: state?.mode ?? "collect",
-    instanceId: getInstanceId(),
-    configVersion: state?.configVersion,
-    configSource: state?.configSource ?? "local",
-    apiEnabled: state?.apiEnabled ?? false,
-    lastPoll: lastPollTime,
-    lastHeartbeat: lastHeartbeatTime,
-    uptime: Math.floor((Date.now() - startTime) / 1e3),
-    port: state?.port ?? 8080
-  };
-}
-
-// src/runtime/serve.ts
-async function runServeMode(config, logger2) {
-  const port = process.env.PORT ? parseInt(process.env.PORT, 10) : config?.port || 8080;
-  const host = process.env.HOST || config?.host || "0.0.0.0";
-  const file = resolve2(
-    process.env.BUNDLE || config?.file || "./dist/walker.js"
-  );
-  const serveName = process.env.SERVE_NAME || config?.serveName || "walker.js";
-  const servePath = process.env.SERVE_PATH || config?.servePath || "";
-  const urlPath = servePath ? `/${servePath}/${serveName}` : `/${serveName}`;
-  logger2.info("Starting single-file server...");
-  logger2.info(`File: ${file}`);
-  logger2.info(`URL: http://${host}:${port}${urlPath}`);
-  try {
-    const app = express();
-    app.get("/health", (req, res) => {
-      res.json({
-        status: "ok",
-        version: VERSION,
-        timestamp: Date.now(),
-        mode: "serve",
-        file,
-        url: urlPath
-      });
-    });
-    app.get("/status", (req, res) => {
-      res.json(getStatus());
-    });
-    app.get(urlPath, (req, res) => {
-      res.type("application/javascript");
-      res.sendFile(file, { dotfiles: "allow" }, (err) => {
-        if (err && !res.headersSent) {
-          const errCode = err.code;
-          const errStatus = err.status || err.statusCode;
-          if (errCode !== "ECONNABORTED") {
-            logger2.error(
-              `sendFile error for ${file}: ${err.message} (code: ${errCode}, status: ${errStatus})`
-            );
-          }
-          if (errStatus === 404 || errCode === "ENOENT" || errCode === "EISDIR" || errCode === "ENOTDIR") {
-            res.status(404).send("File not found");
-          } else if (errCode !== "ECONNABORTED") {
-            res.status(500).send("Internal server error");
-          }
-        }
-      });
-    });
-    const server = app.listen(port, host, () => {
-      logger2.info(`Server listening on http://${host}:${port}`);
-      logger2.info(`GET ${urlPath} - Bundle file`);
-      logger2.info(`GET /health - Health check`);
-    });
-    const shutdownHandler = (signal) => {
-      logger2.info(`Received ${signal}, shutting down...`);
-      server.close(() => {
-        logger2.info("Server closed");
-        process.exit(0);
-      });
-    };
-    process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
-    process.on("SIGINT", () => shutdownHandler("SIGINT"));
-    await new Promise(() => {
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger2.error(`Server failed: ${message}`);
-    process.exit(1);
-  }
-}
 
 // src/commands/run/execution.ts
-var logLevel = process.env.VERBOSE === "true" ? Level.DEBUG : Level.INFO;
+var logLevel = process.env.VERBOSE === "true" ? Level4.DEBUG : Level4.INFO;
 var loggerConfig = { level: logLevel };
 var logger = createLogger2(loggerConfig);
-async function executeRunLocal(mode, flowPath, options) {
-  switch (mode) {
-    case "collect": {
-      if (!flowPath) {
-        throw new Error("Flow path is required for collect mode");
-      }
-      const config = {
-        port: options.port,
-        host: options.host
-      };
-      await runFlow(flowPath, config, logger.scope("runner"), loggerConfig);
-      break;
-    }
-    case "serve": {
-      const config = {
-        port: options.port,
-        host: options.host,
-        serveName: options.serveName,
-        servePath: options.servePath,
-        file: flowPath || void 0
-      };
-      await runServeMode(config, logger.scope("serve"));
-      break;
-    }
-    default:
-      throw new Error(`Unknown mode: ${mode}`);
-  }
+async function executeRunLocal(flowPath, options) {
+  const config = {
+    port: options.port,
+    host: options.host
+  };
+  await runFlow(flowPath, config, logger.scope("runner"), loggerConfig);
 }
 
 // src/commands/run/index.ts
-async function runCommand(mode, options) {
+async function runCommand(options) {
   const timer = createTimer();
   timer.start();
-  const logger2 = createCommandLogger(options);
+  const logger2 = createCLILogger(options);
   try {
-    validateMode(mode);
     const configPath = validateFlowFile(options.config);
     if (options.port !== void 0) {
       validatePort(options.port);
     }
-    const isPreBuilt = isPreBuiltConfig(configPath);
-    let flowPath = null;
-    if (mode === "collect") {
-      if (isPreBuilt) {
-        flowPath = path14.resolve(configPath);
-        logger2.debug(`Using pre-built flow: ${path14.basename(flowPath)}`);
-      } else {
-        logger2.debug("Building flow bundle");
-        flowPath = await prepareBundleForRun(configPath, {
-          verbose: options.verbose,
-          silent: options.json || options.silent
-        });
-        logger2.debug("Bundle ready");
+    const runtimeDeps = ["express", "cors"];
+    for (const dep of runtimeDeps) {
+      try {
+        __require.resolve(dep);
+      } catch {
+        logger2.error(
+          `Missing runtime dependency "${dep}"
+Server flows require express and cors when running outside Docker.
+Run: npm install express cors`
+        );
+        process.exit(1);
       }
     }
-    const modeLabel = mode === "collect" ? "Collector" : "Server";
-    logger2.log(`Starting ${modeLabel}...`);
-    await executeRunLocal(mode, flowPath, {
+    const isPreBuilt = isPreBuiltConfig(configPath);
+    let flowPath;
+    if (isPreBuilt) {
+      flowPath = path13.resolve(configPath);
+      logger2.debug(`Using pre-built flow: ${path13.basename(flowPath)}`);
+    } else {
+      logger2.debug("Building flow bundle");
+      flowPath = await prepareBundleForRun(configPath, {
+        verbose: options.verbose,
+        silent: options.json || options.silent
+      });
+      logger2.debug("Bundle ready");
+    }
+    if (options.deployment) {
+      const { startHeartbeat: startHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+      await startHeartbeat2({
+        deployment: options.deployment,
+        projectId: options.project,
+        url: options.url || `http://localhost:${options.port || 8080}`,
+        healthEndpoint: options.healthEndpoint,
+        heartbeatInterval: options.heartbeatInterval
+      });
+    }
+    logger2.info("Starting flow...");
+    await executeRunLocal(flowPath, {
       port: options.port,
-      host: options.host,
-      serveName: options.serveName,
-      servePath: options.servePath
+      host: options.host
     });
   } catch (error) {
     const duration = timer.getElapsed() / 1e3;
@@ -3206,7 +3985,6 @@ async function runCommand(mode, options) {
     if (options.json) {
       logger2.json({
         success: false,
-        mode,
         error: errorMessage,
         duration
       });
@@ -3216,10 +3994,9 @@ async function runCommand(mode, options) {
     process.exit(1);
   }
 }
-async function run(mode, options) {
-  const startTime2 = Date.now();
+async function run(options) {
+  const startTime = Date.now();
   try {
-    validateMode(mode);
     let flowFile;
     if (typeof options.config === "string") {
       flowFile = validateFlowFile(options.config);
@@ -3229,40 +4006,131 @@ async function run(mode, options) {
     if (options.port !== void 0) {
       validatePort(options.port);
     }
+    const runtimeDeps = ["express", "cors"];
+    for (const dep of runtimeDeps) {
+      try {
+        __require.resolve(dep);
+      } catch {
+        throw new Error(
+          `Missing runtime dependency "${dep}". Server flows require express and cors when running outside Docker. Run: npm install express cors`
+        );
+      }
+    }
     const isPreBuilt = isPreBuiltConfig(flowFile);
     let flowPath;
     if (isPreBuilt) {
-      flowPath = path14.resolve(flowFile);
+      flowPath = path13.resolve(flowFile);
     } else {
       flowPath = await prepareBundleForRun(flowFile, {
         verbose: options.verbose,
         silent: true
       });
     }
-    await executeRunLocal(mode, flowPath, {
+    await executeRunLocal(flowPath, {
       port: options.port,
-      host: options.host,
-      serveName: options.serveName,
-      servePath: options.servePath
+      host: options.host
     });
     return {
       success: true,
       exitCode: 0,
-      duration: Date.now() - startTime2
+      duration: Date.now() - startTime
     };
   } catch (error) {
     return {
       success: false,
       exitCode: 1,
-      duration: Date.now() - startTime2,
+      duration: Date.now() - startTime,
       error: getErrorMessage(error)
     };
   }
 }
 
 // src/commands/validate/index.ts
+init_cli_logger();
 import chalk2 from "chalk";
 
+// src/commands/validate/validators/contract.ts
+function validateContract(input) {
+  const errors = [];
+  const warnings = [];
+  const details = {};
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    errors.push({
+      path: "root",
+      message: "Contract must be an object",
+      code: "INVALID_CONTRACT"
+    });
+    return { valid: false, type: "contract", errors, warnings, details };
+  }
+  const contract = input;
+  let entityCount = 0;
+  let actionCount = 0;
+  if ("$tagging" in contract) {
+    const tagging = contract.$tagging;
+    if (typeof tagging !== "number" || !Number.isInteger(tagging) || tagging < 0) {
+      errors.push({
+        path: "$tagging",
+        message: "$tagging must be a non-negative integer",
+        value: tagging,
+        code: "INVALID_TAGGING"
+      });
+    } else {
+      details.tagging = tagging;
+    }
+  }
+  for (const [entityKey, entityValue] of Object.entries(contract)) {
+    if (entityKey.startsWith("$")) continue;
+    if (entityKey.trim() === "") {
+      errors.push({
+        path: entityKey,
+        message: "Entity key cannot be empty",
+        code: "INVALID_ENTITY_KEY"
+      });
+      continue;
+    }
+    if (typeof entityValue !== "object" || entityValue === null) {
+      errors.push({
+        path: entityKey,
+        message: `Entity "${entityKey}" must be an object of action entries`,
+        value: entityValue,
+        code: "INVALID_ENTITY"
+      });
+      continue;
+    }
+    entityCount++;
+    const actions = entityValue;
+    for (const [actionKey, actionValue] of Object.entries(actions)) {
+      if (actionKey.trim() === "") {
+        errors.push({
+          path: `${entityKey}.${actionKey}`,
+          message: "Action key cannot be empty",
+          code: "INVALID_ACTION_KEY"
+        });
+        continue;
+      }
+      if (typeof actionValue !== "object" || actionValue === null || Array.isArray(actionValue)) {
+        errors.push({
+          path: `${entityKey}.${actionKey}`,
+          message: `Contract entry must be a JSON Schema object`,
+          value: typeof actionValue,
+          code: "INVALID_SCHEMA_ENTRY"
+        });
+        continue;
+      }
+      actionCount++;
+    }
+  }
+  details.entityCount = entityCount;
+  details.actionCount = actionCount;
+  return {
+    valid: errors.length === 0,
+    type: "contract",
+    errors,
+    warnings,
+    details
+  };
+}
+
 // src/commands/validate/validators/event.ts
 import { schemas as schemas3 } from "@walkeros/core/dev";
 var { PartialEventSchema } = schemas3;
@@ -3306,10 +4174,10 @@ function validateEvent(input) {
   const zodResult = PartialEventSchema.safeParse(input);
   if (!zodResult.success) {
     for (const issue of zodResult.error.issues) {
-      const path15 = issue.path.join(".");
-      if (path15 === "name") continue;
+      const path14 = issue.path.join(".");
+      if (path14 === "name") continue;
       errors.push({
-        path: path15 || "root",
+        path: path14 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -3336,23 +4204,37 @@ function validateEvent(input) {
 
 // src/commands/validate/validators/flow.ts
 import { schemas as schemas4 } from "@walkeros/core/dev";
-var { SetupSchema } = schemas4;
+var { validateFlowSetup: validateFlowSetup2 } = schemas4;
 function validateFlow(input, options = {}) {
   const errors = [];
   const warnings = [];
   const details = {};
-  const config = typeof input === "object" && input !== null ? input : {};
-  const zodResult = SetupSchema.safeParse(input);
-  if (!zodResult.success) {
-    for (const issue of zodResult.error.issues) {
-      const path15 = issue.path.join(".");
-      errors.push({
-        path: path15 || "root",
-        message: issue.message,
-        code: "SCHEMA_VALIDATION"
-      });
-    }
+  let json;
+  try {
+    json = JSON.stringify(input, null, 2);
+  } catch {
+    errors.push({
+      path: "root",
+      message: "Input cannot be serialized to JSON",
+      code: "SERIALIZATION_ERROR"
+    });
+    return { valid: false, type: "flow", errors, warnings, details };
+  }
+  const coreResult = validateFlowSetup2(json);
+  for (const issue of coreResult.errors) {
+    errors.push({
+      path: issue.path || "root",
+      message: issue.message,
+      code: "SCHEMA_VALIDATION"
+    });
+  }
+  for (const issue of coreResult.warnings) {
+    warnings.push({
+      path: issue.path || "root",
+      message: issue.message
+    });
   }
+  const config = typeof input === "object" && input !== null ? input : {};
   const flows = config.flows;
   if (flows && typeof flows === "object" && Object.keys(flows).length === 0) {
     errors.push({
@@ -3390,6 +4272,34 @@ function validateFlow(input, options = {}) {
     }
     details.packageCount = Object.keys(packages).length;
   }
+  if (coreResult.context) {
+    details.context = coreResult.context;
+  }
+  if (flows && typeof flows === "object" && errors.length === 0) {
+    const flowNames = Object.keys(flows);
+    const flowsToCheck = options.flow ? [options.flow] : flowNames;
+    let totalConnections = 0;
+    for (const name of flowsToCheck) {
+      const flowConfig = flows[name];
+      if (!flowConfig) continue;
+      checkExampleCoverage(flowConfig, warnings);
+      const connections = buildConnectionGraph(flowConfig);
+      for (const conn of connections) {
+        checkCompatibility(conn, errors, warnings);
+      }
+      totalConnections += connections.length;
+      const setupContract = config.contract;
+      if (setupContract || flowConfig.contract) {
+        checkContractCompliance(
+          flowConfig,
+          setupContract,
+          flowConfig.contract,
+          warnings
+        );
+      }
+    }
+    details.connectionsChecked = totalConnections;
+  }
   return {
     valid: errors.length === 0,
     type: "flow",
@@ -3398,6 +4308,147 @@ function validateFlow(input, options = {}) {
     details
   };
 }
+function checkExampleCoverage(config, warnings) {
+  const stepTypes = [
+    { key: "sources", type: "source" },
+    { key: "transformers", type: "transformer" },
+    { key: "destinations", type: "destination" }
+  ];
+  for (const { key, type } of stepTypes) {
+    const refs = config[key];
+    if (!refs) continue;
+    for (const [name, ref] of Object.entries(refs)) {
+      if (!ref.examples || Object.keys(ref.examples).length === 0) {
+        warnings.push({
+          path: `${type}.${name}`,
+          message: `Step has no examples`,
+          suggestion: `Add examples to ${type}.${name} for testing and documentation`
+        });
+      }
+    }
+  }
+}
+function buildConnectionGraph(config) {
+  const connections = [];
+  for (const [name, source] of Object.entries(config.sources || {})) {
+    if (!source.next || !source.examples) continue;
+    const nextNames = Array.isArray(source.next) ? source.next : [source.next];
+    for (const nextName of nextNames) {
+      const transformer = config.transformers?.[nextName];
+      if (transformer?.examples) {
+        connections.push({
+          from: { type: "source", name, examples: source.examples },
+          to: {
+            type: "transformer",
+            name: nextName,
+            examples: transformer.examples
+          }
+        });
+      }
+    }
+  }
+  for (const [name, transformer] of Object.entries(config.transformers || {})) {
+    if (!transformer.next || !transformer.examples) continue;
+    const nextNames = Array.isArray(transformer.next) ? transformer.next : [transformer.next];
+    for (const nextName of nextNames) {
+      const nextTransformer = config.transformers?.[nextName];
+      if (nextTransformer?.examples) {
+        connections.push({
+          from: {
+            type: "transformer",
+            name,
+            examples: transformer.examples
+          },
+          to: {
+            type: "transformer",
+            name: nextName,
+            examples: nextTransformer.examples
+          }
+        });
+      }
+    }
+  }
+  for (const [name, dest] of Object.entries(config.destinations || {})) {
+    if (!dest.before || !dest.examples) continue;
+    const beforeNames = Array.isArray(dest.before) ? dest.before : [dest.before];
+    for (const beforeName of beforeNames) {
+      const transformer = config.transformers?.[beforeName];
+      if (transformer?.examples) {
+        connections.push({
+          from: {
+            type: "transformer",
+            name: beforeName,
+            examples: transformer.examples
+          },
+          to: { type: "destination", name, examples: dest.examples }
+        });
+      }
+    }
+  }
+  return connections;
+}
+function checkCompatibility(conn, errors, warnings) {
+  const fromOuts = Object.entries(conn.from.examples).filter(([, ex]) => ex.out !== void 0 && ex.out !== false).map(([name, ex]) => ({ name, value: ex.out }));
+  const toIns = Object.entries(conn.to.examples).filter(([, ex]) => ex.in !== void 0).map(([name, ex]) => ({ name, value: ex.in }));
+  const path14 = `${conn.from.type}.${conn.from.name} \u2192 ${conn.to.type}.${conn.to.name}`;
+  if (fromOuts.length === 0 || toIns.length === 0) {
+    warnings.push({
+      path: path14,
+      message: "Cannot check compatibility: missing out or in examples",
+      suggestion: "Add out examples to the source step or in examples to the target step"
+    });
+    return;
+  }
+  let hasMatch = false;
+  for (const out of fromOuts) {
+    for (const inp of toIns) {
+      if (isStructurallyCompatible(out.value, inp.value)) {
+        hasMatch = true;
+        break;
+      }
+    }
+    if (hasMatch) break;
+  }
+  if (!hasMatch) {
+    errors.push({
+      path: path14,
+      message: "No compatible out/in pair found between connected steps",
+      code: "INCOMPATIBLE_EXAMPLES"
+    });
+  }
+}
+function isStructurallyCompatible(a2, b2) {
+  if (typeof a2 !== typeof b2) return false;
+  if (a2 === null || b2 === null) return a2 === b2;
+  if (Array.isArray(a2) && Array.isArray(b2)) return true;
+  if (typeof a2 === "object" && typeof b2 === "object") {
+    const keysA = Object.keys(a2);
+    const keysB = Object.keys(b2);
+    const shared = keysA.filter((k2) => keysB.includes(k2));
+    return shared.length >= Math.min(keysA.length, keysB.length) * 0.5;
+  }
+  return true;
+}
+function checkContractCompliance(config, setupContract, flowContract, warnings) {
+  for (const [name, dest] of Object.entries(config.destinations || {})) {
+    if (!dest.examples) continue;
+    for (const [exName, example] of Object.entries(dest.examples)) {
+      if (!example.in || typeof example.in !== "object") continue;
+      const event = example.in;
+      if (!event.entity || !event.action) continue;
+      const contract = flowContract?.[event.entity] || setupContract?.[event.entity];
+      if (!contract || typeof contract !== "object") continue;
+      const actionSchema = contract[event.action] || contract["*"];
+      if (actionSchema) {
+        warnings.push({
+          path: `destination.${name}.examples.${exName}`,
+          message: `Example has contract for ${event.entity}.${event.action}`,
+          suggestion: "Verify example data matches contract schema"
+        });
+      }
+    }
+  }
+}
 
 // src/commands/validate/validators/mapping.ts
 function validateMapping(input) {
@@ -3434,7 +4485,7 @@ function validateMapping(input) {
       });
     }
     const rule = mapping[pattern];
-    const isValidRule = Array.isArray(rule) ? rule.every((r) => typeof r === "object" && r !== null) : typeof rule === "object" && rule !== null;
+    const isValidRule = Array.isArray(rule) ? rule.every((r2) => typeof r2 === "object" && r2 !== null) : typeof rule === "object" && rule !== null;
     if (!isValidRule) {
       errors.push({
         path: pattern,
@@ -3456,13 +4507,13 @@ function validateMapping(input) {
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
 var SECTIONS = ["destinations", "sources", "transformers"];
-function resolveEntry(path15, flowConfig) {
+function resolveEntry(path14, 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 = path14.split(".");
   if (parts.length === 2) {
     const [section, key] = parts;
     if (!SECTIONS.includes(section)) {
@@ -3494,20 +4545,20 @@ function resolveEntry(path15, flowConfig) {
       return `Entry "${key}" not found in any section`;
     }
     if (matches.length > 1) {
-      const sections = matches.map((m) => m.section).join(", ");
+      const sections = matches.map((m2) => m2.section).join(", ");
       return `Ambiguous key "${key}" found in multiple sections: ${sections}. Use dot-notation (e.g., destinations.${key})`;
     }
     return { section: matches[0].section, key, entry: matches[0].entry };
   }
-  return `Invalid path "${path15}". Use "section.key" or just "key"`;
+  return `Invalid path "${path14}". Use "section.key" or just "key"`;
 }
-async function validateEntry(path15, flowConfig) {
-  const resolved = resolveEntry(path15, flowConfig);
+async function validateEntry(path14, flowConfig) {
+  const resolved = resolveEntry(path14, flowConfig);
   if (typeof resolved === "string") {
     return {
       valid: false,
       type: "entry",
-      errors: [{ path: path15, message: resolved, code: "ENTRY_VALIDATION" }],
+      errors: [{ path: path14, message: resolved, code: "ENTRY_VALIDATION" }],
       warnings: [],
       details: {}
     };
@@ -3538,7 +4589,7 @@ async function validateEntry(path15, flowConfig) {
       type: "entry",
       errors: [
         {
-          path: path15,
+          path: path14,
           message: error instanceof Error ? error.message : "Unknown error",
           code: "ENTRY_VALIDATION"
         }
@@ -3563,10 +4614,10 @@ async function validateEntry(path15, flowConfig) {
   const validate2 = ajv.compile(settingsSchema);
   const isValid = validate2(settings || {});
   if (!isValid) {
-    const errors = (validate2.errors || []).map((e) => ({
-      path: e.instancePath || "/",
-      message: e.message || "Unknown error",
-      code: e.keyword
+    const errors = (validate2.errors || []).map((e2) => ({
+      path: e2.instancePath || "/",
+      message: e2.message || "Unknown error",
+      code: e2.keyword
     }));
     return {
       valid: false,
@@ -3587,10 +4638,12 @@ async function validateEntry(path15, flowConfig) {
 
 // src/commands/validate/index.ts
 async function validate(type, input, options = {}) {
-  if (type.includes(".") || !["event", "flow", "mapping"].includes(type)) {
-    return validateEntry(type, input);
+  if (options.path) {
+    return validateEntry(options.path, input);
   }
   switch (type) {
+    case "contract":
+      return validateContract(input);
     case "event":
       return validateEvent(input);
     case "flow":
@@ -3636,7 +4689,7 @@ function formatResult(result, options) {
   return lines.join("\n");
 }
 async function validateCommand(options) {
-  const logger2 = createCommandLogger({ ...options, stderr: true });
+  const logger2 = createCLILogger({ ...options, stderr: true });
   try {
     let input;
     if (isStdinPiped() && !options.input) {
@@ -3653,7 +4706,8 @@ async function validateCommand(options) {
       });
     }
     const result = await validate(options.type, input, {
-      flow: options.flow
+      flow: options.flow,
+      path: options.path
     });
     const formatted = formatResult(result, {
       json: options.json,
@@ -3692,6 +4746,8 @@ async function validateCommand(options) {
 }
 
 // src/commands/login/index.ts
+init_cli_logger();
+init_config_file();
 import { hostname } from "os";
 var POLL_TIMEOUT_BUFFER_MS = 5e3;
 async function openInBrowser(url) {
@@ -3699,18 +4755,14 @@ async function openInBrowser(url) {
   await open(url);
 }
 async function loginCommand(options) {
-  const logger2 = createLogger({
-    verbose: options.verbose,
-    silent: options.silent,
-    json: options.json
-  });
+  const logger2 = createCLILogger(options);
   try {
     const result = await login({ url: options.url });
     if (options.json) {
       logger2.json(result);
     } else if (result.success) {
-      logger2.success(`Logged in as ${result.email}`);
-      logger2.log(`Token stored in ${result.configPath}`);
+      logger2.info(`Logged in as ${result.email}`);
+      logger2.info(`Token stored in ${result.configPath}`);
     }
     process.exit(result.success ? 0 : 1);
   } catch (error) {
@@ -3725,8 +4777,8 @@ async function loginCommand(options) {
 }
 async function login(options = {}) {
   const appUrl = options.url || resolveAppUrl();
-  const f = options.fetch ?? globalThis.fetch;
-  const codeResponse = await f(`${appUrl}/api/auth/device/code`, {
+  const f2 = options.fetch ?? globalThis.fetch;
+  const codeResponse = await f2(`${appUrl}/api/auth/device/code`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({})
@@ -3745,7 +4797,7 @@ async function login(options = {}) {
   const prompt = (msg) => process.stderr.write(msg + "\n");
   prompt(`
 ! Your one-time code: ${userCode}`);
-  prompt(`  Authorize here: ${verificationUri}
+  prompt(`  Authorize here: ${verificationUriComplete || verificationUri}
 `);
   const opener = options.openUrl ?? openInBrowser;
   try {
@@ -3761,8 +4813,8 @@ async function login(options = {}) {
   let attempts = 0;
   while (Date.now() < deadline && attempts < maxAttempts) {
     attempts++;
-    await new Promise((r) => setTimeout(r, pollInterval));
-    const tokenResponse = await f(`${appUrl}/api/auth/device/token`, {
+    await new Promise((r2) => setTimeout(r2, pollInterval));
+    const tokenResponse = await f2(`${appUrl}/api/auth/device/token`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ deviceCode, hostname: hostname() })
@@ -3787,25 +4839,24 @@ async function login(options = {}) {
 }
 
 // src/commands/logout/index.ts
+init_cli_logger();
+init_config_file();
 async function logoutCommand(options) {
-  const logger2 = createLogger({
-    verbose: options.verbose,
-    silent: options.silent,
-    json: options.json
-  });
+  const logger2 = createCLILogger(options);
   const deleted = deleteConfig();
   const configPath = getConfigPath();
   if (options.json) {
     logger2.json({ success: true, deleted });
   } else if (deleted) {
-    logger2.success(`Logged out. Token removed from ${configPath}`);
+    logger2.info(`Logged out. Token removed from ${configPath}`);
   } else {
-    logger2.log("No stored credentials found.");
+    logger2.info("No stored credentials found.");
   }
   process.exit(0);
 }
 
 // src/commands/auth/index.ts
+init_cli_logger();
 async function whoami() {
   const client = createApiClient();
   const { data, error } = await client.GET("/api/auth/whoami");
@@ -3813,16 +4864,16 @@ async function whoami() {
   return data;
 }
 async function whoamiCommand(options) {
-  const logger2 = createCommandLogger(options);
+  const logger2 = createCLILogger(options);
   try {
     const result = await whoami();
     if (options.json) {
       await writeResult(JSON.stringify(result, null, 2), options);
     } else {
       const data = result;
-      if (data.email) logger2.log(`${data.email}`);
-      if (data.userId) logger2.log(`User: ${data.userId}`);
-      if (data.projectId) logger2.log(`Project: ${data.projectId}`);
+      if (data.email) logger2.info(`${data.email}`);
+      if (data.userId) logger2.info(`User: ${data.userId}`);
+      if (data.projectId) logger2.info(`Project: ${data.projectId}`);
     }
   } catch (error) {
     logger2.error(error instanceof Error ? error.message : String(error));
@@ -3831,6 +4882,8 @@ async function whoamiCommand(options) {
 }
 
 // src/commands/projects/index.ts
+init_auth();
+init_cli_logger();
 async function listProjects() {
   const client = createApiClient();
   const { data, error } = await client.GET("/api/projects");
@@ -3876,10 +4929,10 @@ async function deleteProject(options = {}) {
     throw new Error(error.error?.message || "Failed to delete project");
   return data ?? { success: true };
 }
-async function handleResult(fn, options) {
-  const logger2 = createCommandLogger(options);
+async function handleResult(fn2, options) {
+  const logger2 = createCLILogger(options);
   try {
-    const result = await fn();
+    const result = await fn2();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
     logger2.error(error instanceof Error ? error.message : String(error));
@@ -3919,6 +4972,8 @@ async function deleteProjectCommand(projectId, options) {
 }
 
 // src/commands/flows/index.ts
+init_auth();
+init_cli_logger();
 async function listFlows(options = {}) {
   const id = options.projectId ?? requireProjectId();
   const client = createApiClient();
@@ -4001,10 +5056,10 @@ async function duplicateFlow(options) {
     throw new Error(error.error?.message || "Failed to duplicate flow");
   return data;
 }
-async function handleResult2(fn, options) {
-  const logger2 = createCommandLogger(options);
+async function handleResult2(fn2, options) {
+  const logger2 = createCLILogger(options);
   try {
-    const result = await fn();
+    const result = await fn2();
     await writeResult(JSON.stringify(result, null, 2), options);
   } catch (error) {
     logger2.error(error instanceof Error ? error.message : String(error));
@@ -4067,27 +5122,73 @@ async function readFlowStdin() {
 }
 
 // src/commands/deploy/index.ts
+init_auth();
+init_cli_logger();
 async function resolveConfigId(options) {
   const flow = await getFlow({
     flowId: options.flowId,
     projectId: options.projectId
   });
-  const content = flow.content;
-  const flowNames = Object.keys(content.flows ?? {});
-  if (!flowNames.includes(options.flowName)) {
+  const configs = flow.configs;
+  if (!configs?.length) {
+    throw new Error("Flow has no configs.");
+  }
+  const match = configs.find((c2) => c2.name === options.flowName);
+  if (!match) {
     throw new Error(
-      `Flow "${options.flowName}" not found. Available: ${flowNames.join(", ")}`
+      `Flow "${options.flowName}" not found. Available: ${configs.map((c2) => c2.name).join(", ")}`
     );
   }
-  return options.flowName;
+  return match.id;
 }
 async function getAvailableFlowNames(options) {
   const flow = await getFlow({
     flowId: options.flowId,
     projectId: options.projectId
   });
-  const content = flow.content;
-  return Object.keys(content.flows ?? {});
+  const configs = flow.configs;
+  return configs?.map((c2) => c2.name) ?? [];
+}
+async function streamDeploymentStatus(projectId, deploymentId, options) {
+  const base = resolveBaseUrl();
+  const timeoutMs = options.timeout ?? 12e4;
+  const response = await authenticatedFetch(
+    `${base}/api/projects/${projectId}/deployments/${deploymentId}/stream`,
+    {
+      headers: { Accept: "text/event-stream" },
+      signal: options.signal ?? AbortSignal.timeout(timeoutMs)
+    }
+  );
+  if (!response.ok) throw new Error(`Stream failed: ${response.status}`);
+  if (!response.body) throw new Error("No response body");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let result = null;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const { parsed, remainder } = parseSSEEvents(buffer);
+      buffer = remainder;
+      for (const event of parsed) {
+        if (event.type === "status") {
+          const data = JSON.parse(event.data);
+          result = data;
+          options.onStatus?.(data.status, data.substatus ?? null);
+        }
+        if (event.type === "done") {
+          return result;
+        }
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => {
+    });
+  }
+  if (!result) throw new Error("Stream ended without terminal status");
+  return result;
 }
 async function deploy(options) {
   const projectId = options.projectId ?? requireProjectId();
@@ -4098,7 +5199,14 @@ async function deploy(options) {
       projectId,
       flowName: options.flowName
     });
-    return deployConfig({ ...options, projectId, configId });
+    return deployConfig({
+      ...options,
+      projectId,
+      configId,
+      timeout: options.timeout,
+      signal: options.signal,
+      onStatus: options.onStatus
+    });
   }
   const { data, error } = await client.POST(
     "/api/projects/{projectId}/flows/{flowId}/deploy",
@@ -4120,33 +5228,12 @@ Available: ${names.join(", ")}`
     throw new Error(msg);
   }
   if (!options.wait) return data;
-  const terminalStatuses = ["active", "published", "failed", "deleted"];
-  let status = data.status;
-  let result = { ...data };
-  while (!terminalStatuses.includes(status)) {
-    await new Promise((r) => setTimeout(r, 3e3));
-    const { data: advanced, error: advanceError } = await client.POST(
-      "/api/projects/{projectId}/flows/{flowId}/deploy/{deploymentId}/advance",
-      {
-        params: {
-          path: {
-            projectId,
-            flowId: options.flowId,
-            deploymentId: data.deploymentId
-          }
-        }
-      }
-    );
-    if (advanceError)
-      throw new Error(
-        advanceError.error?.message || "Failed to advance deployment"
-      );
-    if (advanced) {
-      status = advanced.status;
-      result = { ...advanced };
-    }
-  }
-  return result;
+  const result = await streamDeploymentStatus(projectId, data.deploymentId, {
+    timeout: options.timeout,
+    signal: options.signal,
+    onStatus: options.onStatus
+  });
+  return { ...data, ...result };
 }
 async function deployConfig(options) {
   const { flowId, projectId, configId } = options;
@@ -4163,24 +5250,12 @@ async function deployConfig(options) {
   }
   const data = await response.json();
   if (!options.wait) return data;
-  const terminalStatuses = ["active", "published", "failed", "deleted"];
-  let status = data.status;
-  let result = { ...data };
-  while (!terminalStatuses.includes(status)) {
-    await new Promise((r) => setTimeout(r, 3e3));
-    const advResponse = await authenticatedFetch(
-      `${base}/api/projects/${projectId}/flows/${flowId}/configs/${configId}/deployments/${data.deploymentId}/advance`,
-      { method: "POST" }
-    );
-    if (!advResponse.ok) {
-      const body = await advResponse.json().catch(() => ({}));
-      throw new Error(body.error?.message || "Failed to advance deployment");
-    }
-    const advanced = await advResponse.json();
-    status = advanced.status;
-    result = { ...advanced };
-  }
-  return result;
+  const result = await streamDeploymentStatus(projectId, data.deploymentId, {
+    timeout: options.timeout,
+    signal: options.signal,
+    onStatus: options.onStatus
+  });
+  return { ...data, ...result };
 }
 async function getDeployment(options) {
   const projectId = options.projectId ?? requireProjectId();
@@ -4209,32 +5284,50 @@ async function getDeployment(options) {
     throw new Error(error.error?.message || "Failed to get deployment");
   return data;
 }
+var statusLabels = {
+  bundling: "Building bundle...",
+  "bundling:building": "Building bundle...",
+  "bundling:publishing": "Publishing to web...",
+  deploying: "Deploying container...",
+  "deploying:provisioning": "Provisioning container...",
+  "deploying:starting": "Starting container...",
+  active: "Container is live",
+  published: "Published",
+  failed: "Deployment failed"
+};
 async function deployCommand(flowId, options) {
-  const log = createCommandLogger(options);
+  const log = createCLILogger(options);
+  const timeoutMs = options.timeout ? parseInt(options.timeout, 10) * 1e3 : void 0;
   try {
     const result = await deploy({
       flowId,
       projectId: options.project,
       flowName: options.flow,
-      wait: options.wait !== false
+      wait: options.wait !== false,
+      timeout: timeoutMs,
+      onStatus: options.json ? void 0 : (status, substatus) => {
+        const key = substatus ? `${status}:${substatus}` : status;
+        log.info(
+          statusLabels[key] || statusLabels[status] || `Status: ${status}`
+        );
+      }
     });
     if (options.json) {
       await writeResult(JSON.stringify(result, null, 2), options);
       return;
     }
-    const r = result;
-    if (r.status === "published") {
-      log.success(`Published: ${r.publicUrl}`);
-      if (r.scriptTag) log.info(`Script tag: ${r.scriptTag}`);
-    } else if (r.status === "active") {
-      log.success(`Active: ${r.containerUrl}`);
-    } else if (r.status === "failed") {
-      log.error(`Failed: ${r.errorMessage || "Unknown error"}`);
+    const r2 = result;
+    if (r2.status === "published") {
+      log.info(`Published: ${r2.publicUrl}`);
+    } else if (r2.status === "active") {
+      log.info(`Active: ${r2.containerUrl}`);
+    } else if (r2.status === "failed") {
+      log.error(`Failed: ${r2.errorMessage || "Unknown error"}`);
       process.exit(1);
-    } else if (r.status === "bundling") {
-      log.info(`Deployment started: ${r.deploymentId} (${r.type})`);
+    } else if (r2.status === "bundling") {
+      log.info(`Deployment started: ${r2.deploymentId} (${r2.type})`);
     } else {
-      log.info(`Status: ${r.status}`);
+      log.info(`Status: ${r2.status}`);
     }
   } catch (err) {
     log.error(err instanceof Error ? err.message : "Deploy failed");
@@ -4242,7 +5335,7 @@ async function deployCommand(flowId, options) {
   }
 }
 async function getDeploymentCommand(flowId, options) {
-  const log = createCommandLogger(options);
+  const log = createCLILogger(options);
   try {
     const result = await getDeployment({
       flowId,
@@ -4257,50 +5350,258 @@ async function getDeploymentCommand(flowId, options) {
       log.info("No deployment found");
       return;
     }
-    const r = result;
-    log.info(`Deployment: ${r.id}`);
-    log.info(`Type: ${r.type}`);
-    log.info(`Status: ${r.status}`);
-    if (r.containerUrl) log.info(`Endpoint: ${r.containerUrl}`);
-    if (r.publicUrl) log.info(`URL: ${r.publicUrl}`);
-    if (r.scriptTag) log.info(`Script tag: ${r.scriptTag}`);
-    if (r.errorMessage) log.error(`Error: ${r.errorMessage}`);
+    const r2 = result;
+    log.info(`Deployment: ${r2.id}`);
+    log.info(`Type: ${r2.type}`);
+    log.info(`Status: ${r2.status}`);
+    if (r2.containerUrl) log.info(`Endpoint: ${r2.containerUrl}`);
+    if (r2.publicUrl) log.info(`URL: ${r2.publicUrl}`);
+    if (r2.errorMessage) log.error(`Error: ${r2.errorMessage}`);
   } catch (err) {
     log.error(err instanceof Error ? err.message : "Failed to get deployment");
     process.exit(1);
   }
 }
+
+// src/commands/deployments/index.ts
+init_auth();
+init_cli_logger();
+import { getPlatform as getPlatform4 } from "@walkeros/core";
+async function listDeployments(options = {}) {
+  const id = options.projectId ?? requireProjectId();
+  const base = resolveBaseUrl();
+  const params = new URLSearchParams();
+  if (options.type) params.set("type", options.type);
+  if (options.status) params.set("status", options.status);
+  const qs = params.toString();
+  const response = await authenticatedFetch(
+    `${base}/api/projects/${id}/deployments${qs ? `?${qs}` : ""}`
+  );
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new Error(
+      body.error?.message || "Failed to list deployments"
+    );
+  }
+  return response.json();
+}
+async function getDeploymentBySlug(options) {
+  const id = options.projectId ?? requireProjectId();
+  const base = resolveBaseUrl();
+  const response = await authenticatedFetch(
+    `${base}/api/projects/${id}/deployments/${options.slug}`
+  );
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new Error(
+      body.error?.message || "Failed to get deployment"
+    );
+  }
+  return response.json();
+}
+async function createDeployment(options) {
+  const id = options.projectId ?? requireProjectId();
+  const base = resolveBaseUrl();
+  const response = await authenticatedFetch(
+    `${base}/api/projects/${id}/deployments`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: options.type, label: options.label })
+    }
+  );
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new Error(
+      body.error?.message || "Failed to create deployment"
+    );
+  }
+  return response.json();
+}
+async function deleteDeployment(options) {
+  const id = options.projectId ?? requireProjectId();
+  const base = resolveBaseUrl();
+  const response = await authenticatedFetch(
+    `${base}/api/projects/${id}/deployments/${options.slug}`,
+    { method: "DELETE" }
+  );
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new Error(
+      body.error?.message || "Failed to delete deployment"
+    );
+  }
+  const data = await response.json().catch(() => null);
+  return data ?? { success: true };
+}
+async function handleResult3(fn2, options) {
+  const logger2 = createCLILogger(options);
+  try {
+    const result = await fn2();
+    await writeResult(JSON.stringify(result, null, 2), options);
+  } catch (error) {
+    logger2.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function listDeploymentsCommand(options) {
+  await handleResult3(
+    () => listDeployments({
+      projectId: options.project,
+      type: options.type,
+      status: options.status
+    }),
+    options
+  );
+}
+async function getDeploymentBySlugCommand(slug, options) {
+  await handleResult3(
+    () => getDeploymentBySlug({ slug, projectId: options.project }),
+    options
+  );
+}
+async function createDeploymentCommand(options) {
+  await handleResult3(
+    () => createDeployment({
+      type: options.type,
+      label: options.label,
+      projectId: options.project
+    }),
+    options
+  );
+}
+async function deleteDeploymentCommand(slug, options) {
+  await handleResult3(
+    () => deleteDeployment({ slug, projectId: options.project }),
+    options
+  );
+}
+async function createDeployCommand(config, options) {
+  const log = createCLILogger(options);
+  try {
+    let type;
+    if (!config) {
+      log.error(
+        "Config required. Provide a flow config file or remote flow ID (cfg_xxx)."
+      );
+      process.exit(1);
+    }
+    const isRemoteFlow = config.startsWith("cfg_");
+    if (isRemoteFlow) {
+      const id = options.project ?? requireProjectId();
+      const base = resolveBaseUrl();
+      const resp = await authenticatedFetch(
+        `${base}/api/projects/${id}/flows/${config}`
+      );
+      if (!resp.ok) {
+        const body = await resp.json().catch(() => ({}));
+        throw new Error(
+          body.error?.message || `Failed to fetch flow ${config}`
+        );
+      }
+      const flow = await resp.json();
+      if (!flow.content) throw new Error("Flow has no content");
+      const content = flow.content;
+      const flows = content.flows;
+      if (!flows) throw new Error("Invalid flow content: missing flows");
+      const flowName = options.flow ?? Object.keys(flows)[0];
+      if (!flowName) throw new Error("No flows found in config");
+      const flowConfig = flows[flowName];
+      if (!flowConfig || typeof flowConfig !== "object")
+        throw new Error("Invalid flow config");
+      if ("web" in flowConfig) type = "web";
+      else if ("server" in flowConfig) type = "server";
+      else throw new Error('Flow must have "web" or "server" key');
+    } else {
+      const result2 = await loadFlowConfig(config, {
+        flowName: options.flow
+      });
+      type = getPlatform4(result2.flowConfig);
+    }
+    const deployment = await createDeployment({
+      type,
+      label: options.label,
+      projectId: options.project
+    });
+    const result = deployment;
+    if (options.json) {
+      await writeResult(JSON.stringify(result, null, 2), options);
+      return;
+    }
+    log.info(`Deployment created: ${result.id}`);
+    log.info(`  Slug:  ${result.slug}`);
+    log.info(`  Type:  ${result.type}`);
+    if (result.deployToken) {
+      log.info(`  Token: ${result.deployToken}`);
+      log.warn("  Save this token \u2014 it will not be shown again.");
+    }
+    log.info("");
+    log.info("Run locally:");
+    log.info(
+      `  walkeros run ${isRemoteFlow ? "flow.json" : config} --deploy ${result.id}`
+    );
+    log.info("");
+    log.info("Docker:");
+    log.info(
+      `  docker run -e WALKEROS_DEPLOY_TOKEN=${result.deployToken ?? "<token>"} \\`
+    );
+    log.info("             -e WALKEROS_APP_URL=https://app.walkeros.io \\");
+    log.info("             walkeros/flow:latest");
+  } catch (err) {
+    log.error(
+      err instanceof Error ? err.message : "Failed to create deployment"
+    );
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+init_auth();
 export {
   bundle,
   bundleCommand,
   bundleRemote,
+  compareOutput,
   createApiClient,
+  createDeployCommand,
+  createDeployment,
+  createDeploymentCommand,
   createFlow,
   createFlowCommand,
   createProject,
   createProjectCommand,
+  deleteDeployment,
+  deleteDeploymentCommand,
   deleteFlow,
   deleteFlowCommand,
   deleteProject,
   deleteProjectCommand,
   deploy,
+  deployAuthenticatedFetch,
   deployCommand,
   duplicateFlow,
   duplicateFlowCommand,
+  findExample,
   getAuthHeaders,
   getDeployment,
+  getDeploymentBySlug,
+  getDeploymentBySlugCommand,
   getDeploymentCommand,
   getFlow,
   getFlowCommand,
   getProject,
   getProjectCommand,
   getToken,
+  listDeployments,
+  listDeploymentsCommand,
   listFlows,
   listFlowsCommand,
   listProjects,
   listProjectsCommand,
+  loadJsonConfig,
   loginCommand,
   logoutCommand,
+  parseSSEEvents,
   push,
   pushCommand,
   requireProjectId,