@walkeros/cli 0.0.0-next-20251219153324

package/dist/index.js

@@ -0,0 +1,2629 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/version.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var versionFilename = fileURLToPath(import.meta.url);
+var versionDirname = dirname(versionFilename);
+function findPackageJson() {
+  const paths = [
+    join(versionDirname, "../package.json"),
+    // dist/ or src/
+    join(versionDirname, "../../package.json")
+    // src/core/ (not used, but safe)
+  ];
+  for (const p of paths) {
+    try {
+      return readFileSync(p, "utf-8");
+    } catch {
+    }
+  }
+  return JSON.stringify({ version: "0.0.0" });
+}
+var VERSION = JSON.parse(findPackageJson()).version;
+
+// src/commands/bundle/index.ts
+import path9 from "path";
+
+// src/core/logger.ts
+import chalk from "chalk";
+function createLogger(options = {}) {
+  const { verbose = false, silent = false, json = false } = options;
+  const shouldLog = !silent && !json;
+  const shouldDebug = verbose && !silent && !json;
+  return {
+    log: (color, ...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        const colorMap = {
+          red: chalk.red,
+          green: chalk.green,
+          blue: chalk.blue,
+          yellow: chalk.yellow,
+          gray: chalk.gray,
+          grey: chalk.gray,
+          cyan: chalk.cyan,
+          magenta: chalk.magenta,
+          white: chalk.white,
+          black: chalk.black
+        };
+        const colorFn = colorMap[color];
+        const coloredMessage = colorFn ? colorFn(message) : message;
+        console.log(coloredMessage);
+      }
+    },
+    info: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.blue(message));
+      }
+    },
+    success: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.green(message));
+      }
+    },
+    warning: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.yellow(message));
+      }
+    },
+    warn: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.yellow(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(" ");
+        console.log(chalk.gray(message));
+      }
+    },
+    gray: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.gray(message));
+      }
+    }
+  };
+}
+function createCommandLogger(options) {
+  return createLogger({
+    verbose: options.verbose,
+    silent: options.silent ?? false,
+    json: options.json
+  });
+}
+
+// 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
+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 path from "path";
+var DEFAULT_TMP_ROOT = ".tmp";
+function getTmpPath(tmpDir, ...segments) {
+  const root = tmpDir || DEFAULT_TMP_ROOT;
+  const absoluteRoot = path.isAbsolute(root) ? root : path.resolve(root);
+  return path.join(absoluteRoot, ...segments);
+}
+function getDefaultTmpRoot() {
+  return DEFAULT_TMP_ROOT;
+}
+
+// src/core/asset-resolver.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync } from "fs";
+import path3 from "path";
+
+// src/config/utils.ts
+import fs from "fs-extra";
+import path2 from "path";
+function isUrl(str) {
+  try {
+    const url = new URL(str);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function downloadFromUrl(url) {
+  if (!isUrl(url)) {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download ${url}: ${response.status} ${response.statusText}`
+      );
+    }
+    const content = await response.text();
+    const downloadsDir = getTmpPath(void 0, "downloads");
+    await fs.ensureDir(downloadsDir);
+    const tempPath = path2.join(downloadsDir, "flow.json");
+    await fs.writeFile(tempPath, content, "utf-8");
+    return tempPath;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to download from URL: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function loadJsonConfig(configPath) {
+  let absolutePath;
+  let isTemporary = false;
+  if (isUrl(configPath)) {
+    absolutePath = await downloadFromUrl(configPath);
+    isTemporary = true;
+  } else {
+    absolutePath = path2.resolve(configPath);
+    if (!await fs.pathExists(absolutePath)) {
+      throw new Error(`Configuration file not found: ${absolutePath}`);
+    }
+  }
+  try {
+    const rawConfig = await fs.readJson(absolutePath);
+    return rawConfig;
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON in config file: ${configPath}. ${error instanceof Error ? error.message : error}`
+    );
+  } finally {
+    if (isTemporary) {
+      try {
+        await fs.remove(absolutePath);
+      } catch {
+      }
+    }
+  }
+}
+async function loadJsonFromSource(source, options) {
+  const paramName = options?.name || "input";
+  if (!source || source.trim() === "") {
+    if (options?.required) {
+      throw new Error(`${paramName} is required`);
+    }
+    if (options?.fallback !== void 0) {
+      return options.fallback;
+    }
+    return {};
+  }
+  const trimmedSource = source.trim();
+  if (isUrl(trimmedSource)) {
+    try {
+      const tempPath = await downloadFromUrl(trimmedSource);
+      try {
+        const data = await fs.readJson(tempPath);
+        return data;
+      } finally {
+        try {
+          await fs.remove(tempPath);
+        } catch {
+        }
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to load ${paramName} from URL ${trimmedSource}: ${getErrorMessage(error)}`
+      );
+    }
+  }
+  const resolvedPath = path2.resolve(trimmedSource);
+  if (await fs.pathExists(resolvedPath)) {
+    try {
+      const data = await fs.readJson(resolvedPath);
+      return data;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse ${paramName} from file ${trimmedSource}: ${getErrorMessage(error)}`
+      );
+    }
+  }
+  try {
+    const parsed = JSON.parse(trimmedSource);
+    return parsed;
+  } catch (jsonError) {
+    if (!trimmedSource.startsWith("{") && !trimmedSource.startsWith("[")) {
+      return { name: trimmedSource };
+    }
+    throw new Error(
+      `Failed to parse ${paramName}. Input appears to be JSON but contains errors: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`
+    );
+  }
+}
+
+// src/core/asset-resolver.ts
+var cachedAssetDir;
+function getAssetDir() {
+  if (cachedAssetDir) return cachedAssetDir;
+  const currentFile = fileURLToPath2(import.meta.url);
+  let dir = path3.dirname(currentFile);
+  while (dir !== path3.dirname(dir)) {
+    if (existsSync(path3.join(dir, "examples"))) {
+      cachedAssetDir = dir;
+      return dir;
+    }
+    dir = path3.dirname(dir);
+  }
+  cachedAssetDir = path3.dirname(currentFile);
+  return cachedAssetDir;
+}
+function resolveAsset(assetPath, assetType, baseDir) {
+  if (isUrl(assetPath)) {
+    return assetPath;
+  }
+  if (!assetPath.includes("/") && !assetPath.includes("\\")) {
+    const assetDir = getAssetDir();
+    return path3.join(assetDir, "examples", assetPath);
+  }
+  if (path3.isAbsolute(assetPath)) {
+    return assetPath;
+  }
+  return path3.resolve(baseDir || process.cwd(), assetPath);
+}
+
+// src/core/utils.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/core/local-packages.ts
+import path4 from "path";
+import fs2 from "fs-extra";
+async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
+  const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
+  if (!await fs2.pathExists(absolutePath)) {
+    throw new Error(
+      `Local package path not found: ${localPath} (resolved to ${absolutePath})`
+    );
+  }
+  const pkgJsonPath = path4.join(absolutePath, "package.json");
+  if (!await fs2.pathExists(pkgJsonPath)) {
+    throw new Error(
+      `No package.json found at ${absolutePath}. Is this a valid package directory?`
+    );
+  }
+  const distPath = path4.join(absolutePath, "dist");
+  const hasDistFolder = await fs2.pathExists(distPath);
+  if (!hasDistFolder) {
+    logger2.warn(
+      `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
+    );
+  }
+  return {
+    name: packageName,
+    absolutePath,
+    distPath: hasDistFolder ? distPath : absolutePath,
+    hasDistFolder
+  };
+}
+async function copyLocalPackage(localPkg, targetDir, logger2) {
+  const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
+  await fs2.ensureDir(path4.dirname(packageDir));
+  await fs2.copy(
+    path4.join(localPkg.absolutePath, "package.json"),
+    path4.join(packageDir, "package.json")
+  );
+  if (localPkg.hasDistFolder) {
+    await fs2.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+  } else {
+    const entries = await fs2.readdir(localPkg.absolutePath);
+    for (const entry of entries) {
+      if (!["node_modules", ".turbo", ".git"].includes(entry)) {
+        await fs2.copy(
+          path4.join(localPkg.absolutePath, entry),
+          path4.join(packageDir, entry)
+        );
+      }
+    }
+  }
+  logger2.info(`\u{1F4E6} Using local: ${localPkg.name} from ${localPkg.absolutePath}`);
+  return packageDir;
+}
+
+// src/config/validators.ts
+import { schemas } from "@walkeros/core/dev";
+var { safeParseSetup } = schemas;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function validateFlowSetup(data) {
+  const result = safeParseSetup(data);
+  if (!result.success) {
+    const errors = result.error.issues.map((issue) => {
+      const path14 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path14}: ${issue.message}`;
+    }).join("\n");
+    throw new Error(`Invalid configuration:
+${errors}`);
+  }
+  return result.data;
+}
+function getAvailableFlows(setup) {
+  return Object.keys(setup.flows);
+}
+
+// src/config/build-defaults.ts
+var WEB_BUILD_DEFAULTS = {
+  format: "iife",
+  platform: "browser",
+  target: "es2020",
+  minify: true,
+  sourcemap: false,
+  cache: true,
+  windowCollector: "collector",
+  windowElb: "elb"
+};
+var SERVER_BUILD_DEFAULTS = {
+  format: "esm",
+  platform: "node",
+  target: "node20",
+  minify: true,
+  sourcemap: false,
+  cache: true
+};
+var DEFAULT_OUTPUT_PATHS = {
+  web: "./dist/walker.js",
+  server: "./dist/bundle.mjs"
+};
+function getBuildDefaults(platform) {
+  return platform === "web" ? WEB_BUILD_DEFAULTS : SERVER_BUILD_DEFAULTS;
+}
+function getDefaultOutput(platform) {
+  return DEFAULT_OUTPUT_PATHS[platform];
+}
+
+// src/config/loader.ts
+import path5 from "path";
+import fs3 from "fs-extra";
+import { getFlowConfig, getPlatform } from "@walkeros/core";
+var DEFAULT_INCLUDE_FOLDER = "./shared";
+function loadBundleConfig(rawConfig, options) {
+  const setup = validateFlowSetup(rawConfig);
+  const availableFlows = getAvailableFlows(setup);
+  const flowName = resolveFlow(setup, options.flowName, availableFlows);
+  const flowConfig = getFlowConfig(setup, flowName);
+  const platform = getPlatform(flowConfig);
+  if (!platform) {
+    throw new Error(
+      `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
+    );
+  }
+  const buildDefaults = getBuildDefaults(platform);
+  const packages = flowConfig.packages || {};
+  const output = options.buildOverrides?.output || getDefaultOutput(platform);
+  const configDir = isUrl(options.configPath) ? process.cwd() : path5.dirname(options.configPath);
+  let includes = setup.include;
+  if (!includes) {
+    const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
+    if (fs3.pathExistsSync(defaultIncludePath)) {
+      includes = [DEFAULT_INCLUDE_FOLDER];
+    }
+  }
+  const buildOptions = {
+    ...buildDefaults,
+    packages,
+    output,
+    include: includes,
+    configDir,
+    ...options.buildOverrides
+  };
+  const isMultiFlow = availableFlows.length > 1;
+  if (isMultiFlow && options.logger) {
+    options.logger.info(
+      `\u{1F4E6} Using flow: ${flowName} (${availableFlows.length} total)`
+    );
+  }
+  return {
+    flowConfig,
+    buildOptions,
+    flowName,
+    isMultiFlow,
+    availableFlows
+  };
+}
+function resolveFlow(setup, requestedFlow, available) {
+  if (available.length === 1) {
+    return available[0];
+  }
+  if (!requestedFlow) {
+    throw new Error(
+      `Multiple flows found. Please specify a flow using --flow flag.
+Available flows: ${available.join(", ")}`
+    );
+  }
+  if (!available.includes(requestedFlow)) {
+    throw new Error(
+      `Flow "${requestedFlow}" not found in configuration.
+Available flows: ${available.join(", ")}`
+    );
+  }
+  return requestedFlow;
+}
+function loadAllFlows(rawConfig, options) {
+  const setup = validateFlowSetup(rawConfig);
+  const flows = getAvailableFlows(setup);
+  if (options.logger) {
+    options.logger.info(
+      `\u{1F4E6} Loading all ${flows.length} flows: ${flows.join(", ")}`
+    );
+  }
+  return flows.map(
+    (name) => loadBundleConfig(rawConfig, {
+      ...options,
+      flowName: name
+    })
+  );
+}
+
+// src/commands/bundle/bundler.ts
+import esbuild from "esbuild";
+import path8 from "path";
+import fs6 from "fs-extra";
+import { packageNameToVariable } from "@walkeros/core";
+
+// src/commands/bundle/package-manager.ts
+import pacote from "pacote";
+import path6 from "path";
+import fs4 from "fs-extra";
+
+// src/core/cache-utils.ts
+import { getHashServer } from "@walkeros/server-core";
+var HASH_LENGTH = 12;
+function isMutableVersion(version) {
+  return version === "latest" || version.includes("^") || version.includes("~") || version.includes("*") || version.includes("x");
+}
+function getTodayDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+async function getPackageCacheKey(packageName, version, date) {
+  const safeName = packageName.replace(/\//g, "-").replace(/@/g, "");
+  if (isMutableVersion(version)) {
+    const dateStr = date ?? getTodayDate();
+    const input2 = `${safeName}@${version}:${dateStr}`;
+    return getHashServer(input2, HASH_LENGTH);
+  }
+  const input = `${safeName}@${version}`;
+  return getHashServer(input, HASH_LENGTH);
+}
+function normalizeJson(content) {
+  const parsed = JSON.parse(content);
+  return JSON.stringify(parsed);
+}
+async function getFlowConfigCacheKey(content, date) {
+  const dateStr = date ?? getTodayDate();
+  const normalized = normalizeJson(content);
+  const input = `${normalized}:${dateStr}`;
+  return getHashServer(input, HASH_LENGTH);
+}
+
+// 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]);
+}
+function getPackageDirectory(baseDir, packageName, version) {
+  return path6.join(baseDir, "node_modules", packageName);
+}
+async function getCachedPackagePath(pkg, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "packages");
+  const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
+  return path6.join(cacheDir, cacheKey);
+}
+async function isPackageCached(pkg, tmpDir) {
+  const cachedPath = await getCachedPackagePath(pkg, tmpDir);
+  return fs4.pathExists(cachedPath);
+}
+function validateNoDuplicatePackages(packages) {
+  const packageMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (!packageMap.has(pkg.name)) {
+      packageMap.set(pkg.name, []);
+    }
+    packageMap.get(pkg.name).push(pkg.version);
+  }
+  const conflicts = [];
+  for (const [name, versions] of packageMap.entries()) {
+    const uniqueVersions = [...new Set(versions)];
+    if (uniqueVersions.length > 1) {
+      conflicts.push(`${name}: [${uniqueVersions.join(", ")}]`);
+    }
+  }
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Version conflicts detected:
+${conflicts.map((c) => `  - ${c}`).join("\n")}
+
+Each package must use the same version across all declarations. Please update your configuration to use consistent versions.`
+    );
+  }
+}
+async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PURE__ */ new Set()) {
+  const dependencies = [];
+  const pkgKey = `${pkg.name}@${pkg.version}`;
+  if (visited.has(pkgKey)) {
+    return dependencies;
+  }
+  visited.add(pkgKey);
+  try {
+    const packageJsonPath = path6.join(packageDir, "package.json");
+    if (await fs4.pathExists(packageJsonPath)) {
+      const packageJson = await fs4.readJson(packageJsonPath);
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.peerDependencies
+      };
+      for (const [name, versionSpec] of Object.entries(deps)) {
+        if (typeof versionSpec === "string") {
+          dependencies.push({ name, version: versionSpec });
+        }
+      }
+    }
+  } catch (error) {
+    logger2.debug(`Failed to read dependencies for ${pkgKey}: ${error}`);
+  }
+  return dependencies;
+}
+async function downloadPackages(packages, targetDir, logger2, useCache = true, configDir) {
+  const packagePaths = /* @__PURE__ */ new Map();
+  const downloadQueue = [...packages];
+  const processed = /* @__PURE__ */ new Set();
+  const localPackageMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (pkg.path) {
+      localPackageMap.set(pkg.name, pkg.path);
+    }
+  }
+  validateNoDuplicatePackages(packages);
+  await fs4.ensureDir(targetDir);
+  while (downloadQueue.length > 0) {
+    const pkg = downloadQueue.shift();
+    const pkgKey = `${pkg.name}@${pkg.version}`;
+    if (processed.has(pkgKey)) {
+      continue;
+    }
+    processed.add(pkgKey);
+    if (!pkg.path && localPackageMap.has(pkg.name)) {
+      pkg.path = localPackageMap.get(pkg.name);
+    }
+    if (pkg.path) {
+      const localPkg = await resolveLocalPackage(
+        pkg.name,
+        pkg.path,
+        configDir || process.cwd(),
+        logger2
+      );
+      const installedPath = await copyLocalPackage(localPkg, targetDir, logger2);
+      packagePaths.set(pkg.name, installedPath);
+      const deps = await resolveDependencies(pkg, installedPath, logger2);
+      for (const dep of deps) {
+        const depKey = `${dep.name}@${dep.version}`;
+        if (!processed.has(depKey)) {
+          downloadQueue.push(dep);
+        }
+      }
+      continue;
+    }
+    const packageSpec = `${pkg.name}@${pkg.version}`;
+    const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
+    const cachedPath = await getCachedPackagePath(pkg);
+    if (useCache && await isPackageCached(pkg)) {
+      logger2.debug(`Using cached ${packageSpec}...`);
+      try {
+        await fs4.ensureDir(path6.dirname(packageDir));
+        await fs4.copy(cachedPath, packageDir);
+        packagePaths.set(pkg.name, packageDir);
+        const deps = await resolveDependencies(pkg, packageDir, logger2);
+        for (const dep of deps) {
+          const depKey = `${dep.name}@${dep.version}`;
+          if (!processed.has(depKey)) {
+            downloadQueue.push(dep);
+          }
+        }
+        continue;
+      } catch (error) {
+        logger2.debug(
+          `Failed to use cache for ${packageSpec}, downloading fresh: ${error}`
+        );
+      }
+    }
+    logger2.debug(`Downloading ${packageSpec}...`);
+    try {
+      await fs4.ensureDir(path6.dirname(packageDir));
+      const cacheDir = process.env.NPM_CACHE_DIR || path6.join(process.cwd(), ".npm-cache");
+      await withTimeout(
+        pacote.extract(packageSpec, packageDir, {
+          // Force npm registry download, prevent workspace resolution
+          registry: "https://registry.npmjs.org",
+          // Force online fetching from registry (don't use cached workspace packages)
+          preferOnline: true,
+          // Cache for performance
+          cache: cacheDir,
+          // Don't resolve relative to workspace context
+          where: void 0
+        }),
+        PACKAGE_DOWNLOAD_TIMEOUT_MS,
+        `Package download timed out after ${PACKAGE_DOWNLOAD_TIMEOUT_MS / 1e3}s: ${packageSpec}`
+      );
+      if (useCache) {
+        try {
+          await fs4.ensureDir(path6.dirname(cachedPath));
+          await fs4.copy(packageDir, cachedPath);
+          logger2.debug(`Cached ${packageSpec} for future use`);
+        } catch (cacheError) {
+          logger2.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
+        }
+      }
+      packagePaths.set(pkg.name, packageDir);
+      const deps = await resolveDependencies(pkg, packageDir, logger2);
+      for (const dep of deps) {
+        const depKey = `${dep.name}@${dep.version}`;
+        if (!processed.has(depKey)) {
+          downloadQueue.push(dep);
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to download ${packageSpec}: ${error}`);
+    }
+  }
+  return packagePaths;
+}
+
+// src/core/build-cache.ts
+import fs5 from "fs-extra";
+import path7 from "path";
+async function getBuildCachePath(configContent, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "builds");
+  const cacheKey = await getFlowConfigCacheKey(configContent);
+  return path7.join(cacheDir, `${cacheKey}.js`);
+}
+async function isBuildCached(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  return fs5.pathExists(cachePath);
+}
+async function cacheBuild(configContent, buildOutput, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  await fs5.ensureDir(path7.dirname(cachePath));
+  await fs5.writeFile(cachePath, buildOutput, "utf-8");
+}
+async function getCachedBuild(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  if (await fs5.pathExists(cachePath)) {
+    return await fs5.readFile(cachePath, "utf-8");
+  }
+  return null;
+}
+
+// src/commands/bundle/bundler.ts
+async function copyIncludes(includes, sourceDir, outputDir, logger2) {
+  for (const include of includes) {
+    const sourcePath = path8.resolve(sourceDir, include);
+    const folderName = path8.basename(include);
+    const destPath = path8.join(outputDir, folderName);
+    if (await fs6.pathExists(sourcePath)) {
+      await fs6.copy(sourcePath, destPath);
+      logger2.debug(`Copied ${include} to output`);
+    } else {
+      logger2.debug(`Include folder not found: ${include}`);
+    }
+  }
+}
+function generateCacheKeyContent(flowConfig, buildOptions) {
+  const configForCache = {
+    flow: flowConfig,
+    build: {
+      ...buildOptions,
+      // Exclude non-deterministic fields from cache key
+      tempDir: void 0,
+      output: void 0
+    }
+  };
+  return JSON.stringify(configForCache);
+}
+async function bundleCore(flowConfig, buildOptions, logger2, showStats = false) {
+  const bundleStartTime = Date.now();
+  const TEMP_DIR = buildOptions.tempDir || getTmpPath();
+  if (buildOptions.cache !== false) {
+    const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+    const cached = await isBuildCached(configContent);
+    if (cached) {
+      const cachedBuild = await getCachedBuild(configContent);
+      if (cachedBuild) {
+        logger2.info("\u2728 Using cached build");
+        const outputPath = path8.resolve(buildOptions.output);
+        await fs6.ensureDir(path8.dirname(outputPath));
+        await fs6.writeFile(outputPath, cachedBuild);
+        logger2.gray(`Output: ${outputPath}`);
+        logger2.success("\u2705 Build completed (from cache)");
+        if (showStats) {
+          const stats = await fs6.stat(outputPath);
+          const packageStats = Object.entries(buildOptions.packages).map(
+            ([name, pkg]) => ({
+              name: `${name}@${pkg.version || "latest"}`,
+              size: 0
+              // Size estimation not available for cached builds
+            })
+          );
+          return {
+            totalSize: stats.size,
+            packages: packageStats,
+            buildTime: Date.now() - bundleStartTime,
+            treeshakingEffective: true
+          };
+        }
+        return;
+      }
+    }
+  }
+  try {
+    await fs6.ensureDir(TEMP_DIR);
+    logger2.info("\u{1F4E5} Downloading packages...");
+    const packagesArray = Object.entries(buildOptions.packages).map(
+      ([name, packageConfig]) => ({
+        name,
+        version: packageConfig.version || "latest",
+        path: packageConfig.path
+        // Pass local path if defined
+      })
+    );
+    const packagePaths = await downloadPackages(
+      packagesArray,
+      TEMP_DIR,
+      logger2,
+      buildOptions.cache,
+      buildOptions.configDir
+      // For resolving relative local paths
+    );
+    for (const [pkgName, pkgPath] of packagePaths.entries()) {
+      if (pkgName.startsWith("@walkeros/")) {
+        const pkgJsonPath = path8.join(pkgPath, "package.json");
+        const pkgJson = await fs6.readJSON(pkgJsonPath);
+        if (!pkgJson.exports && pkgJson.module) {
+          pkgJson.exports = {
+            ".": {
+              import: pkgJson.module,
+              require: pkgJson.main
+            }
+          };
+          await fs6.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+        }
+      }
+    }
+    const packageJsonPath = path8.join(TEMP_DIR, "package.json");
+    await fs6.writeFile(
+      packageJsonPath,
+      JSON.stringify({ type: "module" }, null, 2)
+    );
+    logger2.info("\u{1F4DD} Creating entry point...");
+    const entryContent = await createEntryPoint(
+      flowConfig,
+      buildOptions,
+      packagePaths
+    );
+    const entryPath = path8.join(TEMP_DIR, "entry.js");
+    await fs6.writeFile(entryPath, entryContent);
+    logger2.info("\u26A1 Bundling with esbuild...");
+    const outputPath = path8.resolve(buildOptions.output);
+    await fs6.ensureDir(path8.dirname(outputPath));
+    const esbuildOptions = createEsbuildOptions(
+      buildOptions,
+      entryPath,
+      outputPath,
+      TEMP_DIR,
+      packagePaths,
+      logger2
+    );
+    try {
+      await esbuild.build(esbuildOptions);
+    } catch (buildError) {
+      throw createBuildError(
+        buildError,
+        buildOptions.code || ""
+      );
+    }
+    logger2.gray(`Output: ${outputPath}`);
+    if (buildOptions.cache !== false) {
+      const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+      const buildOutput = await fs6.readFile(outputPath, "utf-8");
+      await cacheBuild(configContent, buildOutput);
+      logger2.debug("Build cached for future use");
+    }
+    let stats;
+    if (showStats) {
+      stats = await collectBundleStats(
+        outputPath,
+        buildOptions.packages,
+        bundleStartTime,
+        entryContent
+      );
+    }
+    if (buildOptions.include && buildOptions.include.length > 0) {
+      const outputDir = path8.dirname(outputPath);
+      await copyIncludes(
+        buildOptions.include,
+        buildOptions.configDir || process.cwd(),
+        outputDir,
+        logger2
+      );
+    }
+    return stats;
+  } catch (error) {
+    throw error;
+  }
+}
+async function collectBundleStats(outputPath, packages, startTime, entryContent) {
+  const stats = await fs6.stat(outputPath);
+  const totalSize = stats.size;
+  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(
+      `import\\s+\\{[^}]*\\}\\s+from\\s+['"]${name}['"]`,
+      "g"
+    );
+    const hasImports = importPattern.test(entryContent) || namedImportPattern.test(entryContent);
+    const packagesCount = Object.keys(packages).length;
+    const estimatedSize = hasImports ? Math.floor(totalSize / packagesCount) : 0;
+    return {
+      name: `${name}@${pkg.version || "latest"}`,
+      size: estimatedSize
+    };
+  });
+  const hasWildcardImports = /import\s+\*\s+as\s+\w+\s+from/.test(entryContent);
+  const treeshakingEffective = !hasWildcardImports;
+  return {
+    totalSize,
+    packages: packageStats,
+    buildTime,
+    treeshakingEffective
+  };
+}
+function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger2) {
+  const alias = {};
+  const baseOptions = {
+    entryPoints: [entryPath],
+    bundle: true,
+    format: buildOptions.format,
+    platform: buildOptions.platform,
+    outfile: outputPath,
+    absWorkingDir: tempDir,
+    // Resolve modules from temp directory
+    // alias removed - not needed with absWorkingDir
+    mainFields: ["module", "main"],
+    // Prefer ESM over CJS
+    treeShaking: true,
+    logLevel: "error",
+    minify: buildOptions.minify,
+    sourcemap: buildOptions.sourcemap,
+    resolveExtensions: [".mjs", ".js", ".ts", ".json"],
+    // Prefer .mjs
+    // Enhanced minification options when minify is enabled
+    ...buildOptions.minify && {
+      minifyWhitespace: buildOptions.minifyOptions?.whitespace ?? true,
+      minifyIdentifiers: buildOptions.minifyOptions?.identifiers ?? true,
+      minifySyntax: buildOptions.minifyOptions?.syntax ?? true,
+      legalComments: buildOptions.minifyOptions?.legalComments ?? "none",
+      keepNames: buildOptions.minifyOptions?.keepNames ?? false,
+      charset: "utf8"
+    }
+  };
+  if (buildOptions.platform === "browser") {
+    baseOptions.define = {
+      "process.env.NODE_ENV": '"production"',
+      global: "globalThis"
+    };
+    baseOptions.external = buildOptions.external || [];
+  } else if (buildOptions.platform === "node") {
+    const nodeBuiltins = [
+      "crypto",
+      "fs",
+      "path",
+      "os",
+      "util",
+      "stream",
+      "buffer",
+      "events",
+      "http",
+      "https",
+      "url",
+      "querystring",
+      "zlib"
+    ];
+    const npmPackages = ["express", "express/*", "cors", "cors/*"];
+    baseOptions.external = buildOptions.external ? [...nodeBuiltins, ...npmPackages, ...buildOptions.external] : [...nodeBuiltins, ...npmPackages];
+    if (buildOptions.format === "esm") {
+      baseOptions.banner = {
+        js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+      };
+    }
+  }
+  if (buildOptions.target) {
+    baseOptions.target = buildOptions.target;
+  } else if (buildOptions.platform === "node") {
+    baseOptions.target = "node18";
+  } else {
+    baseOptions.target = "es2018";
+  }
+  return baseOptions;
+}
+function detectDestinationPackages(flowConfig) {
+  const destinationPackages = /* @__PURE__ */ new Set();
+  const destinations = flowConfig.destinations;
+  if (destinations) {
+    for (const [destKey, destConfig] of Object.entries(destinations)) {
+      if (typeof destConfig === "object" && destConfig !== null && "package" in destConfig && typeof destConfig.package === "string") {
+        destinationPackages.add(destConfig.package);
+      }
+    }
+  }
+  return destinationPackages;
+}
+function detectSourcePackages(flowConfig) {
+  const sourcePackages = /* @__PURE__ */ new Set();
+  const sources = flowConfig.sources;
+  if (sources) {
+    for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
+      if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string") {
+        sourcePackages.add(sourceConfig.package);
+      }
+    }
+  }
+  return sourcePackages;
+}
+function detectExplicitCodeImports(flowConfig) {
+  const explicitCodeImports = /* @__PURE__ */ new Map();
+  const destinations = flowConfig.destinations;
+  if (destinations) {
+    for (const [destKey, destConfig] of Object.entries(destinations)) {
+      if (typeof destConfig === "object" && destConfig !== null && "package" in destConfig && typeof destConfig.package === "string" && "code" in destConfig && typeof destConfig.code === "string") {
+        const isAutoGenerated = destConfig.code.startsWith("_");
+        if (!isAutoGenerated) {
+          if (!explicitCodeImports.has(destConfig.package)) {
+            explicitCodeImports.set(destConfig.package, /* @__PURE__ */ new Set());
+          }
+          explicitCodeImports.get(destConfig.package).add(destConfig.code);
+        }
+      }
+    }
+  }
+  const sources = flowConfig.sources;
+  if (sources) {
+    for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
+      if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string" && "code" in sourceConfig && typeof sourceConfig.code === "string") {
+        const isAutoGenerated = sourceConfig.code.startsWith("_");
+        if (!isAutoGenerated) {
+          if (!explicitCodeImports.has(sourceConfig.package)) {
+            explicitCodeImports.set(sourceConfig.package, /* @__PURE__ */ new Set());
+          }
+          explicitCodeImports.get(sourceConfig.package).add(sourceConfig.code);
+        }
+      }
+    }
+  }
+  return explicitCodeImports;
+}
+function generateImportStatements(packages, destinationPackages, sourcePackages, explicitCodeImports) {
+  const importStatements = [];
+  const examplesMappings = [];
+  const usedPackages = /* @__PURE__ */ new Set([...destinationPackages, ...sourcePackages]);
+  for (const [packageName, packageConfig] of Object.entries(packages)) {
+    const isUsedByDestOrSource = usedPackages.has(packageName);
+    const hasExplicitCode = explicitCodeImports.has(packageName);
+    if (packageConfig.imports && packageConfig.imports.length > 0) {
+      const uniqueImports = [...new Set(packageConfig.imports)];
+      const defaultImports = [];
+      const namedImports = [];
+      for (const imp of uniqueImports) {
+        if (imp.startsWith("default as ")) {
+          defaultImports.push(imp.replace("default as ", ""));
+        } else {
+          namedImports.push(imp);
+        }
+      }
+      if (defaultImports.length > 0) {
+        for (const defaultImport of defaultImports) {
+          importStatements.push(
+            `import ${defaultImport} from '${packageName}';`
+          );
+        }
+      }
+      if (namedImports.length > 0) {
+        const importList = namedImports.join(", ");
+        importStatements.push(
+          `import { ${importList} } from '${packageName}';`
+        );
+      }
+      const examplesImport = uniqueImports.find(
+        (imp) => imp.includes("examples as ")
+      );
+      if (examplesImport) {
+        const examplesVarName = examplesImport.split(" as ")[1];
+        const destinationMatch = packageName.match(
+          /@walkeros\/web-destination-(.+)$/
+        );
+        if (destinationMatch) {
+          const destinationName = destinationMatch[1];
+          examplesMappings.push(
+            `  ${destinationName}: typeof ${examplesVarName} !== 'undefined' ? ${examplesVarName} : undefined`
+          );
+        }
+      }
+    } else if (hasExplicitCode) {
+      const codes = Array.from(explicitCodeImports.get(packageName));
+      importStatements.push(
+        `import { ${codes.join(", ")} } from '${packageName}';`
+      );
+    } else if (isUsedByDestOrSource) {
+      const varName = packageNameToVariable(packageName);
+      importStatements.push(`import ${varName} from '${packageName}';`);
+    }
+  }
+  return { importStatements, examplesMappings };
+}
+async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
+  const destinationPackages = detectDestinationPackages(flowConfig);
+  const sourcePackages = detectSourcePackages(flowConfig);
+  const explicitCodeImports = detectExplicitCodeImports(flowConfig);
+  const { importStatements } = generateImportStatements(
+    buildOptions.packages,
+    destinationPackages,
+    sourcePackages,
+    explicitCodeImports
+  );
+  const importsCode = importStatements.join("\n");
+  const hasFlow = destinationPackages.size > 0 || sourcePackages.size > 0;
+  if (!hasFlow) {
+    const userCode = buildOptions.code || "";
+    return importsCode ? `${importsCode}
+
+${userCode}` : userCode;
+  }
+  const configObject = buildConfigObject(flowConfig, explicitCodeImports);
+  const wrappedCode = generatePlatformWrapper(
+    configObject,
+    buildOptions.code || "",
+    buildOptions
+  );
+  return importsCode ? `${importsCode}
+
+${wrappedCode}` : wrappedCode;
+}
+function createBuildError(buildError, code) {
+  if (!buildError.errors || buildError.errors.length === 0) {
+    return new Error(`Build failed: ${buildError.message || buildError}`);
+  }
+  const firstError = buildError.errors[0];
+  const location = firstError.location;
+  if (location && location.file && location.file.includes("entry.js")) {
+    const line = location.line;
+    const column = location.column;
+    const codeLines = code.split("\n");
+    const errorLine = codeLines[line - 1] || "";
+    return new Error(
+      `Code syntax error at line ${line}, column ${column}:
+  ${errorLine}
+  ${" ".repeat(column - 1)}^
+${firstError.text}`
+    );
+  }
+  return new Error(
+    `Build error: ${firstError.text}
+` + (location ? `  at ${location.file}:${location.line}:${location.column}` : "")
+  );
+}
+function buildConfigObject(flowConfig, explicitCodeImports) {
+  const flowWithProps = flowConfig;
+  const sources = flowWithProps.sources || {};
+  const destinations = flowWithProps.destinations || {};
+  const sourcesEntries = Object.entries(sources).map(([key, source]) => {
+    const hasExplicitCode = source.code && explicitCodeImports.has(source.package);
+    const codeVar = hasExplicitCode ? source.code : packageNameToVariable(source.package);
+    const configStr = source.config ? processConfigValue(source.config) : "{}";
+    const envStr = source.env ? `,
+      env: ${processConfigValue(source.env)}` : "";
+    return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}
+    }`;
+  });
+  const destinationsEntries = Object.entries(destinations).map(
+    ([key, dest]) => {
+      const hasExplicitCode = dest.code && explicitCodeImports.has(dest.package);
+      const codeVar = hasExplicitCode ? dest.code : packageNameToVariable(dest.package);
+      const configStr = dest.config ? processConfigValue(dest.config) : "{}";
+      const envStr = dest.env ? `,
+      env: ${processConfigValue(dest.env)}` : "";
+      return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}
+    }`;
+    }
+  );
+  const collectorStr = flowWithProps.collector ? `,
+  ...${processConfigValue(flowWithProps.collector)}` : "";
+  return `{
+  sources: {
+${sourcesEntries.join(",\n")}
+  },
+  destinations: {
+${destinationsEntries.join(",\n")}
+  }${collectorStr}
+}`;
+}
+function processConfigValue(value) {
+  return JSON.stringify(value, null, 2);
+}
+function generatePlatformWrapper(configObject, userCode, buildOptions) {
+  if (buildOptions.platform === "browser") {
+    const windowAssignments = [];
+    if (buildOptions.windowCollector) {
+      windowAssignments.push(
+        `  if (typeof window !== 'undefined') window['${buildOptions.windowCollector}'] = collector;`
+      );
+    }
+    if (buildOptions.windowElb) {
+      windowAssignments.push(
+        `  if (typeof window !== 'undefined') window['${buildOptions.windowElb}'] = elb;`
+      );
+    }
+    const assignments = windowAssignments.length > 0 ? "\n" + windowAssignments.join("\n") : "";
+    return `(async () => {
+  const config = ${configObject};
+
+  ${userCode}
+
+  const { collector, elb } = await startFlow(config);${assignments}
+})();`;
+  } else {
+    const codeSection = userCode ? `
+  ${userCode}
+` : "";
+    return `export default async function(context = {}) {
+  const config = ${configObject};${codeSection}
+  return await startFlow(config);
+}`;
+  }
+}
+
+// src/commands/bundle/stats.ts
+function displayStats(stats, logger2) {
+  logger2.info("\n\u{1F4CA} Bundle Statistics");
+  logger2.info("\u2500".repeat(50));
+  const sizeKB = formatBytes(stats.totalSize);
+  logger2.info(`Total Size: ${sizeKB} KB`);
+  const timeSeconds = (stats.buildTime / 1e3).toFixed(2);
+  logger2.info(`Build Time: ${timeSeconds}s`);
+  const treeshakingStatus = stats.treeshakingEffective ? "\u2705 Effective" : "\u26A0\uFE0F  Not optimal (consider using named imports)";
+  logger2.info(`Tree-shaking: ${treeshakingStatus}`);
+  if (stats.packages.length > 0) {
+    logger2.info(`
+Package Breakdown:`);
+    stats.packages.forEach((pkg) => {
+      if (pkg.size > 0) {
+        const pkgSizeKB = formatBytes(pkg.size);
+        logger2.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
+      }
+    });
+  }
+  logger2.info("\u2500".repeat(50));
+}
+
+// src/commands/bundle/index.ts
+async function bundleCommand(options) {
+  const timer = createTimer();
+  timer.start();
+  const logger2 = createCommandLogger(options);
+  if (options.dryRun) {
+    logger2.info(
+      `[DRY-RUN] Would execute bundle with config: ${options.config}`
+    );
+    return;
+  }
+  try {
+    if (options.flow && options.all) {
+      throw new Error("Cannot use both --flow and --all flags together");
+    }
+    logger2.info("\u{1F4E6} Reading configuration...");
+    const configPath = resolveAsset(options.config, "config");
+    const rawConfig = await loadJsonConfig(configPath);
+    const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger: logger2 }) : [
+      loadBundleConfig(rawConfig, {
+        configPath,
+        flowName: options.flow,
+        logger: logger2
+      })
+    ];
+    const results = [];
+    for (const {
+      flowConfig,
+      buildOptions,
+      flowName,
+      isMultiFlow
+    } of configsToBundle) {
+      try {
+        if (options.cache !== void 0) {
+          buildOptions.cache = options.cache;
+        }
+        if (isMultiFlow || options.all) {
+          logger2.info(`
+\u{1F527} Building flow: ${flowName}`);
+        } else {
+          logger2.info("\u{1F527} Starting bundle process...");
+        }
+        const shouldCollectStats = options.stats || options.json;
+        const stats = await bundleCore(
+          flowConfig,
+          buildOptions,
+          logger2,
+          shouldCollectStats
+        );
+        results.push({
+          flowName,
+          success: true,
+          stats
+        });
+        if (!options.json && !options.all && options.stats && stats) {
+          displayStats(stats, logger2);
+        }
+      } catch (error) {
+        const errorMessage = getErrorMessage(error);
+        results.push({
+          flowName,
+          success: false,
+          error: errorMessage
+        });
+        if (!options.all) {
+          throw error;
+        }
+      }
+    }
+    const duration = timer.end() / 1e3;
+    const successCount = results.filter((r) => r.success).length;
+    const failureCount = results.filter((r) => !r.success).length;
+    if (options.json) {
+      const outputLogger = createLogger({ silent: false, json: false });
+      const output = failureCount === 0 ? createSuccessOutput(
+        {
+          flows: results,
+          summary: {
+            total: results.length,
+            success: successCount,
+            failed: failureCount
+          }
+        },
+        duration
+      ) : createErrorOutput(
+        `${failureCount} flow(s) failed to build`,
+        duration
+      );
+      outputLogger.log("white", JSON.stringify(output, null, 2));
+    } else {
+      if (options.all) {
+        logger2.info(`
+\u{1F4CA} Build Summary:`);
+        logger2.info(`   Total: ${results.length}`);
+        logger2.success(`   \u2705 Success: ${successCount}`);
+        if (failureCount > 0) {
+          logger2.error(`   \u274C Failed: ${failureCount}`);
+        }
+      }
+      if (failureCount === 0) {
+        logger2.success(`
+\u2705 Bundle created successfully in ${timer.format()}`);
+      } else {
+        throw new Error(`${failureCount} flow(s) failed to build`);
+      }
+    }
+  } catch (error) {
+    const duration = timer.getElapsed() / 1e3;
+    const errorMessage = getErrorMessage(error);
+    if (options.json) {
+      const outputLogger = createLogger({ silent: false, json: false });
+      const output = createErrorOutput(errorMessage, duration);
+      outputLogger.log("white", JSON.stringify(output, null, 2));
+    } else {
+      logger2.error("\u274C Bundle failed:");
+      logger2.error(errorMessage);
+    }
+    process.exit(1);
+  }
+}
+async function bundle(configOrPath, options = {}) {
+  let rawConfig;
+  let configPath = path9.resolve(process.cwd(), "walkeros.config.json");
+  if (typeof configOrPath === "string") {
+    configPath = resolveAsset(configOrPath, "config");
+    rawConfig = await loadJsonConfig(configPath);
+  } else {
+    rawConfig = configOrPath;
+  }
+  const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+    configPath,
+    flowName: options.flowName,
+    buildOverrides: options.buildOverrides
+  });
+  if (options.cache !== void 0) {
+    buildOptions.cache = options.cache;
+  }
+  const logger2 = createCommandLogger(options);
+  return await bundleCore(
+    flowConfig,
+    buildOptions,
+    logger2,
+    options.stats ?? false
+  );
+}
+
+// src/commands/simulate/simulator.ts
+import path10 from "path";
+import fs8 from "fs-extra";
+import { getPlatform as getPlatform2 } 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 path14 = pathParts.join(":");
+      if (!path14) continue;
+      const cleanPath = path14.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, []);
+    }
+    this.calls.get(destKey).push({
+      type: "call",
+      path: apiPath,
+      args,
+      timestamp: Date.now()
+    });
+  }
+  getCalls() {
+    return Object.fromEntries(this.calls);
+  }
+  reset() {
+    this.calls.clear();
+  }
+};
+
+// src/commands/simulate/jsdom-executor.ts
+import { JSDOM, VirtualConsole } from "jsdom";
+import fs7 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);
+    }
+    if (trackedEnv.document && typeof trackedEnv.document === "object") {
+      Object.assign(sandbox.document, trackedEnv.document);
+    }
+  }
+  return sandbox;
+}
+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 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 fs7.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
+  };
+}
+
+// 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;
+  }
+  return () => {
+    for (const [key, value] of Object.entries(originalValues)) {
+      if (value === void 0) {
+        delete globalThis[key];
+      } else {
+        globalThis[key] = value;
+      }
+    }
+  };
+}
+async function executeInNode(bundlePath, destinations, event, tracker, envs, timeout = 3e4) {
+  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();
+      if (!result || !result.elb || typeof result.elb !== "function") {
+        throw new Error(
+          "Factory function did not return valid result with elb"
+        );
+      }
+      const { collector, elb } = result;
+      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
+      };
+    };
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`Server simulation timeout after ${timeout}ms`)),
+        timeout
+      );
+    });
+    return await Promise.race([executeWithTimeout(), timeoutPromise]);
+  } catch (error) {
+    throw new Error(`Node execution failed: ${getErrorMessage(error)}`);
+  } finally {
+    cleanupMocks();
+  }
+}
+
+// src/commands/simulate/env-loader.ts
+async function loadDestinationEnvs(destinations) {
+  const envs = {};
+  for (const [destKey, destConfig] of Object.entries(destinations)) {
+    const typedConfig = destConfig;
+    if (!typedConfig.package) {
+      continue;
+    }
+    try {
+      const packageName = typedConfig.package;
+      const isDemoPackage = packageName.includes("-demo");
+      const importPath = isDemoPackage ? packageName : `${packageName}/dev`;
+      const module = await import(importPath);
+      const examplesModule = module.examples || module.default?.examples;
+      const envModule = examplesModule?.env;
+      if (envModule?.push) {
+        envs[destKey] = {
+          init: envModule.init,
+          push: envModule.push,
+          simulation: envModule.simulation || []
+        };
+      }
+    } catch (error) {
+      console.warn(
+        `Warning: Could not load env for destination "${destKey}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return envs;
+}
+
+// src/commands/simulate/simulator.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+async function simulateCore(configPath, event, options = {}) {
+  const logger2 = createLogger({
+    verbose: options.verbose || false,
+    silent: options.silent || false,
+    json: options.json || false
+  });
+  try {
+    logger2.info("\u{1F3AF} Starting walkerOS simulation...");
+    logger2.info("\u{1F4E6} Loading bundle configuration...");
+    const fullConfigPath = path10.resolve(configPath);
+    const rawConfig = await loadJsonConfig(fullConfigPath);
+    loadBundleConfig(rawConfig, { configPath: fullConfigPath });
+    logger2.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
+    const result = await executeSimulation(event, fullConfigPath);
+    if (result.success) {
+      logger2.info(`\u2705 Simulation completed successfully`);
+    } else {
+      logger2.error(`\u274C Simulation failed: ${result.error}`);
+    }
+    return result;
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    logger2.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
+    return {
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+function formatSimulationResult(result, options = {}) {
+  if (options.json) {
+    const output = {
+      result: result.elbResult,
+      usage: result.usage,
+      duration: result.duration
+    };
+    return JSON.stringify(output, null, 2);
+  }
+  if (result.success) {
+    return "\u2705 Simulation completed successfully";
+  } else {
+    return `\u274C Simulation failed: ${result.error}`;
+  }
+}
+async function executeSimulation(event, configPath) {
+  const startTime = Date.now();
+  let bundlePath;
+  const tempDir = getTmpPath();
+  try {
+    if (!isObject(event) || !("name" in event) || typeof event.name !== "string") {
+      throw new Error(
+        'Event must be an object with a "name" property of type string'
+      );
+    }
+    const typedEvent = event;
+    await fs8.ensureDir(tempDir);
+    const rawConfig = await loadJsonConfig(configPath);
+    const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+      configPath
+    });
+    const platform = getPlatform2(flowConfig);
+    const tracker = new CallTracker();
+    const tempOutput = path10.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
+    );
+    bundlePath = tempOutput;
+    const envs = await loadDestinationEnvs(destinations || {});
+    let result;
+    if (platform === "web") {
+      result = await executeInJSDOM(
+        tempOutput,
+        destinations || {},
+        typedEvent,
+        tracker,
+        envs,
+        1e4
+      );
+    } else {
+      result = await executeInNode(
+        tempOutput,
+        destinations || {},
+        typedEvent,
+        tracker,
+        envs,
+        3e4
+      );
+    }
+    const elbResult = result.elbResult;
+    const usage = result.usage;
+    const duration = Date.now() - startTime;
+    return {
+      success: true,
+      elbResult,
+      usage,
+      duration,
+      logs: []
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    return {
+      success: false,
+      error: getErrorMessage(error),
+      duration
+    };
+  } finally {
+    if (tempDir) {
+      await fs8.remove(tempDir).catch(() => {
+      });
+    }
+  }
+}
+
+// src/commands/simulate/index.ts
+async function simulateCommand(options) {
+  const logger2 = createCommandLogger(options);
+  if (options.dryRun) {
+    logger2.info(
+      `[DRY-RUN] Would execute simulate with config: ${options.config}`
+    );
+    return;
+  }
+  const startTime = Date.now();
+  try {
+    const event = await loadJsonFromSource(options.event, {
+      name: "event"
+    });
+    const result = await simulateCore(options.config, event, {
+      json: options.json,
+      verbose: options.verbose,
+      silent: options.silent
+    });
+    const resultWithDuration = {
+      ...result,
+      duration: (Date.now() - startTime) / 1e3
+    };
+    const outputLogger = createLogger({ silent: false, json: false });
+    const output = formatSimulationResult(resultWithDuration, {
+      json: options.json
+    });
+    outputLogger.log("white", output);
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    if (options.json) {
+      const outputLogger = createLogger({ silent: false, json: false });
+      const errorOutput = JSON.stringify(
+        {
+          success: false,
+          error: errorMessage,
+          duration: (Date.now() - startTime) / 1e3
+        },
+        null,
+        2
+      );
+      outputLogger.log("white", errorOutput);
+    } else {
+      const errorLogger = createLogger({ silent: false, json: false });
+      errorLogger.error(`\u274C Simulate command failed: ${errorMessage}`);
+    }
+    process.exit(1);
+  }
+}
+async function simulate(configOrPath, event, options = {}) {
+  if (typeof configOrPath !== "string") {
+    throw new Error(
+      "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, {
+    json: options.json ?? false,
+    verbose: options.verbose ?? false
+  });
+}
+
+// src/commands/push/index.ts
+import path11 from "path";
+import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
+import fs9 from "fs-extra";
+import { getPlatform as getPlatform3 } from "@walkeros/core";
+import { schemas as schemas2 } from "@walkeros/core/dev";
+async function pushCommand(options) {
+  const logger2 = createCommandLogger(options);
+  const startTime = Date.now();
+  try {
+    logger2.info("\u{1F4E5} Loading event...");
+    const event = await loadJsonFromSource(options.event, {
+      name: "event"
+    });
+    const eventResult = schemas2.PartialEventSchema.safeParse(event);
+    if (!eventResult.success) {
+      const errors = eventResult.error.issues.map((issue) => `${String(issue.path.join("."))}: ${issue.message}`).join(", ");
+      throw new Error(`Invalid event: ${errors}`);
+    }
+    const parsedEvent = eventResult.data;
+    if (!parsedEvent.name) {
+      throw new Error('Invalid event: Missing required "name" property');
+    }
+    const validatedEvent = {
+      name: parsedEvent.name,
+      data: parsedEvent.data || {}
+    };
+    if (!validatedEvent.name.includes(" ")) {
+      logger2.warn(
+        `Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
+      );
+    }
+    logger2.info("\u{1F4E6} Loading flow configuration...");
+    const configPath = path11.resolve(options.config);
+    const rawConfig = await loadJsonConfig(configPath);
+    const { flowConfig, buildOptions, flowName, isMultiFlow } = loadBundleConfig(rawConfig, {
+      configPath: options.config,
+      flowName: options.flow,
+      logger: logger2
+    });
+    const platform = getPlatform3(flowConfig);
+    logger2.info("\u{1F528} Bundling flow configuration...");
+    const configDir = path11.dirname(configPath);
+    const tempDir = path11.join(
+      configDir,
+      ".tmp",
+      `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+    );
+    await fs9.ensureDir(tempDir);
+    const tempPath = path11.join(
+      tempDir,
+      `bundle.${platform === "web" ? "js" : "mjs"}`
+    );
+    const pushBuildOptions = {
+      ...buildOptions,
+      output: tempPath,
+      // Web uses IIFE for browser-like execution, server uses ESM
+      format: platform === "web" ? "iife" : "esm",
+      platform: platform === "web" ? "browser" : "node",
+      ...platform === "web" && {
+        windowCollector: "collector",
+        windowElb: "elb"
+      }
+    };
+    await bundleCore(flowConfig, pushBuildOptions, logger2, false);
+    logger2.debug(`Bundle created: ${tempPath}`);
+    let result;
+    if (platform === "web") {
+      logger2.info("\u{1F310} Executing in web environment (JSDOM)...");
+      result = await executeWebPush(tempPath, validatedEvent, logger2);
+    } else if (platform === "server") {
+      logger2.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
+      result = await executeServerPush(tempPath, validatedEvent, logger2);
+    } else {
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+    const duration = Date.now() - startTime;
+    if (options.json) {
+      const outputLogger = createLogger({ silent: false, json: false });
+      outputLogger.log(
+        "white",
+        JSON.stringify(
+          {
+            success: result.success,
+            event: result.elbResult,
+            duration
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      if (result.success) {
+        logger2.success("\u2705 Event pushed successfully");
+        if (result.elbResult && typeof result.elbResult === "object") {
+          const pushResult = result.elbResult;
+          if ("id" in pushResult && pushResult.id) {
+            logger2.info(`   Event ID: ${pushResult.id}`);
+          }
+          if ("entity" in pushResult && pushResult.entity) {
+            logger2.info(`   Entity: ${pushResult.entity}`);
+          }
+          if ("action" in pushResult && pushResult.action) {
+            logger2.info(`   Action: ${pushResult.action}`);
+          }
+        }
+        logger2.info(`   Duration: ${duration}ms`);
+      } else {
+        logger2.error(`\u274C Push failed: ${result.error}`);
+        process.exit(1);
+      }
+    }
+    try {
+      await fs9.remove(tempDir);
+    } catch {
+    }
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const errorMessage = getErrorMessage(error);
+    if (options.json) {
+      const outputLogger = createLogger({ silent: false, json: false });
+      outputLogger.log(
+        "white",
+        JSON.stringify(
+          {
+            success: false,
+            error: errorMessage,
+            duration
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      logger2.error(`\u274C Push command failed: ${errorMessage}`);
+    }
+    process.exit(1);
+  }
+}
+async function executeWebPush(bundlePath, event, logger2) {
+  const startTime = Date.now();
+  try {
+    const virtualConsole = new VirtualConsole2();
+    const dom = new JSDOM2("<!DOCTYPE html><html><body></body></html>", {
+      url: "http://localhost",
+      runScripts: "dangerously",
+      resources: "usable",
+      virtualConsole
+    });
+    const { window } = dom;
+    logger2.debug("Loading bundle...");
+    const bundleCode = await fs9.readFile(bundlePath, "utf8");
+    window.eval(bundleCode);
+    logger2.debug("Waiting for elb...");
+    await waitForWindowProperty2(
+      window,
+      "elb",
+      5e3
+    );
+    const windowObj = window;
+    const elb = windowObj.elb;
+    logger2.info(`Pushing event: ${event.name}`);
+    const elbResult = await elb(event.name, event.data);
+    return {
+      success: true,
+      elbResult,
+      duration: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function executeServerPush(bundlePath, event, logger2, timeout = 6e4) {
+  const startTime = Date.now();
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`Server push timeout after ${timeout}ms`)),
+        timeout
+      );
+    });
+    const executePromise = (async () => {
+      logger2.debug("Importing bundle...");
+      const flowModule = await import(bundlePath);
+      if (!flowModule.default || typeof flowModule.default !== "function") {
+        throw new Error("Bundle does not export default factory function");
+      }
+      logger2.debug("Calling factory function...");
+      const result = await flowModule.default();
+      if (!result || !result.elb || typeof result.elb !== "function") {
+        throw new Error(
+          "Factory function did not return valid result with elb"
+        );
+      }
+      const { elb } = result;
+      logger2.info(`Pushing event: ${event.name}`);
+      const elbResult = await elb(event.name, event.data);
+      return {
+        success: true,
+        elbResult,
+        duration: Date.now() - startTime
+      };
+    })();
+    return await Promise.race([executePromise, timeoutPromise]);
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  }
+}
+function waitForWindowProperty2(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.`
+          )
+        );
+      } else {
+        setImmediate(check);
+      }
+    };
+    check();
+  });
+}
+
+// src/commands/run/index.ts
+import path13 from "path";
+
+// src/commands/run/validators.ts
+import { existsSync as existsSync2 } 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");
+
+// src/schemas/run.ts
+import { z as z2 } from "@walkeros/core/dev";
+var RunOptionsSchema = z2.object({
+  mode: RunModeSchema,
+  flow: FilePathSchema,
+  port: PortSchema.default(8080),
+  flowName: z2.string().optional().describe("Specific flow name to run")
+});
+
+// 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 (!existsSync2(absolutePath)) {
+    throw new Error(
+      `Flow file not found: ${filePath}
+   Resolved path: ${absolutePath}
+   Make sure the file exists and the path is correct`
+    );
+  }
+  return absolutePath;
+}
+function validatePort(port) {
+  const result = PortSchema.safeParse(port);
+  if (!result.success) {
+    throw new Error(
+      `Invalid port: ${port}
+   Port must be an integer between 1 and 65535
+   Example: --port 8080`
+    );
+  }
+}
+
+// src/commands/run/utils.ts
+import path12 from "path";
+import fs10 from "fs-extra";
+async function prepareBundleForRun(configPath, options) {
+  const configDir = path12.dirname(path12.resolve(configPath));
+  const tempDir = path12.join(
+    configDir,
+    ".tmp",
+    `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  );
+  await fs10.ensureDir(tempDir);
+  const tempPath = path12.join(tempDir, "bundle.mjs");
+  await bundle(configPath, {
+    cache: true,
+    verbose: options.verbose,
+    silent: options.silent,
+    buildOverrides: {
+      output: tempPath,
+      format: "esm",
+      platform: "node"
+    }
+  });
+  return tempPath;
+}
+function isPreBuiltConfig(configPath) {
+  return configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
+}
+
+// src/commands/run/execution.ts
+import { createLogger as createLogger2, Level } from "@walkeros/core";
+
+// src/runtime/runner.ts
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { resolve, dirname as dirname2 } from "path";
+async function runFlow(file, config, logger2) {
+  logger2.info(`Loading flow from ${file}`);
+  try {
+    const absolutePath = resolve(file);
+    const flowDir = dirname2(absolutePath);
+    process.chdir(flowDir);
+    const fileUrl = pathToFileURL2(absolutePath).href;
+    const module = await import(fileUrl);
+    if (!module.default || typeof module.default !== "function") {
+      logger2.throw(
+        `Invalid flow bundle: ${file} must export a default function`
+      );
+    }
+    const result = await module.default(config);
+    if (!result || !result.collector) {
+      logger2.throw(`Invalid flow bundle: ${file} must return { collector }`);
+    }
+    const { collector } = result;
+    logger2.info("Flow running");
+    if (config?.port) {
+      logger2.info(`Port: ${config.port}`);
+    }
+    const shutdown = async (signal) => {
+      logger2.info(`Received ${signal}, shutting down gracefully...`);
+      try {
+        if (collector.command) {
+          await collector.command("shutdown");
+        }
+        logger2.info("Shutdown complete");
+        process.exit(0);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger2.error(`Error during shutdown: ${message}`);
+        process.exit(1);
+      }
+    };
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    await new Promise(() => {
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger2.error(`Failed to run flow: ${message}`);
+    if (error instanceof Error && error.stack) {
+      logger2.debug("Stack trace:", { stack: error.stack });
+    }
+    throw error;
+  }
+}
+
+// src/runtime/serve.ts
+import express from "express";
+import { resolve as resolve2 } from "path";
+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.FILE || 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(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 logger = createLogger2({ level: logLevel });
+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"));
+      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}`);
+  }
+}
+
+// src/commands/run/index.ts
+async function runCommand(mode, options) {
+  const timer = createTimer();
+  timer.start();
+  const logger2 = createCommandLogger(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 = path13.resolve(configPath);
+        if (!options.json && !options.silent) {
+          logger2.info(`\u{1F4E6} Using pre-built flow: ${path13.basename(flowPath)}`);
+        }
+      } else {
+        if (!options.json && !options.silent) {
+          logger2.info("\u{1F528} Building flow bundle...");
+        }
+        flowPath = await prepareBundleForRun(configPath, {
+          verbose: options.verbose,
+          silent: options.json || options.silent
+        });
+        if (!options.json && !options.silent) {
+          logger2.success("\u2705 Bundle ready");
+        }
+      }
+    }
+    if (options.dryRun) {
+      logger2.info(`[DRY-RUN] Would execute locally: run ${mode}`);
+      return;
+    }
+    if (!options.json && !options.silent) {
+      const modeLabel = mode === "collect" ? "Collector" : "Server";
+      logger2.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
+    }
+    await executeRunLocal(mode, flowPath, {
+      port: options.port,
+      host: options.host,
+      serveName: options.serveName,
+      servePath: options.servePath
+    });
+  } catch (error) {
+    const duration = timer.getElapsed() / 1e3;
+    const errorMessage = getErrorMessage(error);
+    if (options.json) {
+      const output = {
+        success: false,
+        mode,
+        error: errorMessage,
+        duration
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      logger2.error("\u274C Run failed:");
+      logger2.error(errorMessage);
+    }
+    process.exit(1);
+  }
+}
+async function run(mode, options) {
+  const startTime = Date.now();
+  try {
+    validateMode(mode);
+    let flowFile;
+    if (typeof options.config === "string") {
+      flowFile = validateFlowFile(options.config);
+    } else {
+      throw new Error("Programmatic run() requires config file path");
+    }
+    if (options.port !== void 0) {
+      validatePort(options.port);
+    }
+    const isPreBuilt = isPreBuiltConfig(flowFile);
+    let flowPath;
+    if (isPreBuilt) {
+      flowPath = path13.resolve(flowFile);
+    } else {
+      flowPath = await prepareBundleForRun(flowFile, {
+        verbose: options.verbose,
+        silent: true
+      });
+    }
+    await executeRunLocal(mode, flowPath, {
+      port: options.port,
+      host: options.host,
+      serveName: options.serveName,
+      servePath: options.servePath
+    });
+    return {
+      success: true,
+      exitCode: 0,
+      duration: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      exitCode: 1,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  }
+}
+
+// src/commands/cache.ts
+import fs11 from "fs-extra";
+function registerCacheCommand(program2) {
+  const cache = program2.command("cache").description("Manage the CLI cache");
+  cache.command("clear").description("Clear all cached packages and builds").option("--packages", "Clear only package cache").option("--builds", "Clear only build cache").option("--tmp-dir <dir>", "Custom temp directory").action(async (options) => {
+    const tmpDir = options.tmpDir;
+    if (options.packages) {
+      await fs11.remove(getTmpPath(tmpDir, "cache", "packages"));
+      console.log("Package cache cleared");
+    } else if (options.builds) {
+      await fs11.remove(getTmpPath(tmpDir, "cache", "builds"));
+      console.log("Build cache cleared");
+    } else {
+      await fs11.remove(getTmpPath(tmpDir, "cache"));
+      console.log("All caches cleared");
+    }
+  });
+  cache.command("info").description("Show cache statistics").option("--tmp-dir <dir>", "Custom temp directory").action(async (options) => {
+    const tmpDir = options.tmpDir;
+    const packagesDir = getTmpPath(tmpDir, "cache", "packages");
+    const buildsDir = getTmpPath(tmpDir, "cache", "builds");
+    const packageCount = await countEntries(packagesDir);
+    const buildCount = await countEntries(buildsDir);
+    console.log(`Cache directory: ${getTmpPath(tmpDir, "cache")}`);
+    console.log(`Cached packages: ${packageCount}`);
+    console.log(`Cached builds: ${buildCount}`);
+  });
+}
+function registerCleanCommand(program2) {
+  program2.command("clean").description("Clear the entire temp directory (.tmp/)").option("--tmp-dir <dir>", "Custom temp directory").action(async (options) => {
+    const tmpDir = options.tmpDir || getDefaultTmpRoot();
+    await fs11.remove(tmpDir);
+    console.log(`Temp directory cleared: ${tmpDir}`);
+  });
+}
+async function countEntries(dir) {
+  if (!await fs11.pathExists(dir)) return 0;
+  const entries = await fs11.readdir(dir);
+  return entries.length;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version(VERSION);
+program.hook("preAction", (thisCommand, actionCommand) => {
+  const options = actionCommand.opts();
+  if (!options.silent && !options.json) {
+    console.log(`\u{1F680} walkerOS CLI v${VERSION}`);
+  }
+});
+program.command("bundle [file]").description("Bundle NPM packages with custom code").option("-f, --flow <name>", "flow to build (for multi-flow configs)").option("--all", "build all flows (for multi-flow configs)").option("-s, --stats", "show bundle statistics").option("--json", "output statistics in JSON format (implies --stats)").option("--no-cache", "disable package caching and download fresh packages").option("-v, --verbose", "verbose output").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+  await bundleCommand({
+    config: file || "bundle.config.json",
+    flow: options.flow,
+    all: options.all,
+    stats: options.stats,
+    json: options.json,
+    cache: options.cache,
+    verbose: options.verbose,
+    dryRun: options.dryRun,
+    silent: options.silent
+  });
+});
+program.command("simulate [file]").description("Simulate event processing and capture API calls").option(
+  "-e, --event <source>",
+  "Event to simulate (JSON string, file path, or URL)"
+).option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+  await simulateCommand({
+    config: file || "bundle.config.json",
+    event: options.event,
+    json: options.json,
+    verbose: options.verbose,
+    dryRun: options.dryRun,
+    silent: options.silent
+  });
+});
+program.command("push [file]").description("Push an event through the flow with real API execution").requiredOption(
+  "-e, --event <source>",
+  "Event to push (JSON string, file path, or URL)"
+).option("--flow <name>", "Flow name (for multi-flow configs)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("-s, --silent", "Suppress output").action(async (file, options) => {
+  await pushCommand({
+    config: file || "bundle.config.json",
+    event: options.event,
+    flow: options.flow,
+    json: options.json,
+    verbose: options.verbose,
+    silent: options.silent
+  });
+});
+var runCmd = program.command("run").description("Run walkerOS flows in collect or serve mode");
+runCmd.command("collect [file]").description(
+  "Run collector mode (event collection endpoint). Defaults to server-collect.mjs if no file specified."
+).option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+  await runCommand("collect", {
+    config: file || "server-collect.mjs",
+    port: options.port,
+    host: options.host,
+    json: options.json,
+    verbose: options.verbose,
+    dryRun: options.dryRun,
+    silent: options.silent
+  });
+});
+runCmd.command("serve [file]").description(
+  "Run serve mode (single-file server for browser bundles). Defaults to baked-in web-serve.js if no file specified."
+).option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").option("--name <filename>", "Filename in URL (default: walker.js)").option("--path <directory>", "URL directory path (e.g., libs/v1)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+  await runCommand("serve", {
+    config: file || "web-serve.js",
+    port: options.port,
+    host: options.host,
+    serveName: options.name,
+    servePath: options.path,
+    json: options.json,
+    verbose: options.verbose,
+    dryRun: options.dryRun,
+    silent: options.silent
+  });
+});
+registerCacheCommand(program);
+registerCleanCommand(program);
+program.parse();
+export {
+  bundle,
+  bundleCommand,
+  pushCommand,
+  run,
+  runCommand,
+  simulate,
+  simulateCommand
+};
+//# sourceMappingURL=index.js.map