@walkeros/cli 0.4.1 → 0.5.0

package/dist/index.js

@@ -2,9 +2,13 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, join } from "path";
+import { VERSION as DOCKER_VERSION2 } from "@walkeros/docker";
+
+// src/commands/bundle/index.ts
+import path9 from "path";
 
 // src/core/logger.ts
 import chalk from "chalk";
@@ -131,8 +135,6 @@ function formatBytes(bytes) {
 // src/core/docker.ts
 import { spawn } from "child_process";
 import path2 from "path";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
 import { VERSION as DOCKER_VERSION } from "@walkeros/docker";
 
 // src/config/utils.ts
@@ -262,20 +264,7 @@ async function loadJsonFromSource(source, options) {
 }
 
 // src/core/docker.ts
-function readPackageVersion() {
-  const moduleFilename = fileURLToPath(import.meta.url);
-  const moduleDir = path2.dirname(moduleFilename);
-  const prodPath = path2.join(moduleDir, "../package.json");
-  try {
-    const pkg = JSON.parse(readFileSync(prodPath, "utf-8"));
-    return pkg.version;
-  } catch {
-    const devPath = path2.join(moduleDir, "../../package.json");
-    const pkg = JSON.parse(readFileSync(devPath, "utf-8"));
-    return pkg.version;
-  }
-}
-var CLI_VERSION = readPackageVersion();
+var CLI_VERSION = true ? "0.5.0" : "0.0.0";
 var CLI_DOCKER_IMAGE = process.env.WALKEROS_CLI_DOCKER_IMAGE || `walkeros/cli:${CLI_VERSION}`;
 var RUNTIME_DOCKER_IMAGE = process.env.WALKEROS_RUNTIME_DOCKER_IMAGE || `walkeros/docker:${DOCKER_VERSION}`;
 function buildCommonDockerArgs(options) {
@@ -335,7 +324,7 @@ async function executeInDocker(command, args, options = {}, configFile) {
       if (code === 0) {
         resolve();
       } else {
-        reject(new Error(`Docker command exited with code ${code}`));
+        process.exit(code || 1);
       }
     });
   });
@@ -355,8 +344,10 @@ function buildDockerRunCommand(mode, flowPath, options = {}) {
   cmd.push("-e", `MODE=${mode}`);
   if (mode === "collect" && flowPath) {
     const absoluteFlowPath = path2.resolve(cwd, flowPath);
-    cmd.push("-v", `${absoluteFlowPath}:/app/flow.mjs:ro`);
-    cmd.push("-e", "FLOW=/app/flow.mjs");
+    const flowDir = path2.dirname(absoluteFlowPath);
+    const flowFile = path2.basename(absoluteFlowPath);
+    cmd.push("-v", `${flowDir}:/app/dist:ro`);
+    cmd.push("-e", `FLOW=/app/dist/${flowFile}`);
   }
   if (mode === "serve" && flowPath) {
     const absoluteFilePath = path2.resolve(cwd, flowPath);
@@ -402,7 +393,7 @@ async function executeRunInDocker(mode, flowPath, options = {}) {
       if (code === 0) {
         resolve();
       } else {
-        reject(new Error(`Docker command exited with code ${code}`));
+        process.exit(code || 1);
       }
     });
   });
@@ -415,22 +406,22 @@ function getExecutionMode(options) {
   }
   return "docker";
 }
-async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger, configFile) {
+async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger2, configFile) {
   const mode = getExecutionMode(options);
   if (options.dryRun) {
     if (mode === "docker") {
       const cmd = `docker run walkeros/cli:latest ${dockerCommand} ${dockerArgs.join(" ")}`;
-      logger?.info(`[DRY-RUN] Would execute: ${cmd}`);
+      logger2?.info(`[DRY-RUN] Would execute: ${cmd}`);
     } else {
-      logger?.info(
+      logger2?.info(
         `[DRY-RUN] Would execute locally: ${dockerCommand} ${dockerArgs.join(" ")}`
       );
     }
     return;
   }
   if (mode === "local") {
-    if (logger && !options.silent) {
-      logger.info("\u{1F5A5}\uFE0F  Executing locally...");
+    if (logger2 && !options.silent) {
+      logger2.info("\u{1F5A5}\uFE0F  Executing locally...");
     }
     await localHandler();
   } else {
@@ -440,8 +431,8 @@ async function executeCommand(localHandler, dockerCommand, dockerArgs, options,
         "Docker is not available. Please install Docker or use --local flag to execute locally."
       );
     }
-    if (logger && !options.silent) {
-      logger.info("\u{1F433} Executing in Docker container...");
+    if (logger2 && !options.silent) {
+      logger2.info("\u{1F433} Executing in Docker container...");
     }
     await executeInDocker(dockerCommand, dockerArgs, options, configFile);
   }
@@ -452,33 +443,33 @@ import { getHashServer } from "@walkeros/server-core";
 import fs2 from "fs-extra";
 
 // src/core/asset-resolver.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
 import path3 from "path";
-function getPackageRoot() {
-  const currentFile = fileURLToPath2(import.meta.url);
-  if (currentFile.includes("/src/")) {
-    const srcIndex = currentFile.indexOf("/src/");
-    return currentFile.substring(0, srcIndex);
-  }
-  if (currentFile.includes("/dist/")) {
-    const distIndex = currentFile.indexOf("/dist/");
-    return currentFile.substring(0, distIndex);
+var cachedAssetDir;
+function getAssetDir() {
+  if (cachedAssetDir) return cachedAssetDir;
+  const currentFile = fileURLToPath(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);
   }
-  return path3.resolve(currentFile, "../..");
+  cachedAssetDir = path3.dirname(currentFile);
+  return cachedAssetDir;
 }
 function resolveAsset(assetPath, assetType, baseDir) {
-  const packageRoot = getPackageRoot();
   if (!assetPath.includes("/") && !assetPath.includes("\\")) {
-    if (assetType === "template") {
-      return path3.join(packageRoot, "templates", assetPath);
-    }
-    return path3.join(packageRoot, "examples", assetPath);
+    const assetDir = getAssetDir();
+    return path3.join(assetDir, "examples", assetPath);
   }
   if (path3.isAbsolute(assetPath)) {
     return assetPath;
   }
-  const resolveBase = baseDir || process.cwd();
-  return path3.resolve(resolveBase, assetPath);
+  return path3.resolve(baseDir || process.cwd(), assetPath);
 }
 
 // src/core/utils.ts
@@ -486,273 +477,256 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/config/validators.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
-}
-function validatePlatform(platform) {
-  return platform === "web" || platform === "server";
-}
-function isMultiEnvConfig(data) {
-  return isObject(data) && "version" in data && data.version === 1 && "environments" in data && isObject(data.environments);
-}
-function isSingleEnvConfig(data) {
-  return isObject(data) && "flow" in data && "build" in data && isObject(data.flow) && isObject(data.build) && "platform" in data.flow;
-}
-
-// src/config/parser.ts
+// src/core/local-packages.ts
 import path4 from "path";
-function parseConfigStructure(rawConfig, options = {}) {
-  if (isMultiEnvConfig(rawConfig)) {
-    const setup = rawConfig;
-    const availableEnvironments = Object.keys(setup.environments);
-    if (!options.environment) {
-      throw new Error(
-        `Multi-environment configuration detected. Please specify an environment using --env flag.
-Available environments: ${availableEnvironments.join(", ")}`
-      );
-    }
-    const selectedEnv = options.environment;
-    if (!setup.environments[selectedEnv]) {
-      throw new Error(
-        `Environment "${selectedEnv}" not found in configuration.
-Available environments: ${availableEnvironments.join(", ")}`
-      );
-    }
-    const envConfig = setup.environments[selectedEnv];
-    return {
-      flowConfig: envConfig.flow,
-      buildOptions: envConfig.build,
-      metadata: {
-        environment: selectedEnv,
-        isMultiEnvironment: true,
-        availableEnvironments
-      }
-    };
-  }
-  if (isSingleEnvConfig(rawConfig)) {
-    const config = rawConfig;
-    return {
-      flowConfig: config.flow,
-      buildOptions: config.build,
-      metadata: {
-        environment: "default",
-        isMultiEnvironment: false
-      }
-    };
-  }
-  const configPath = options.configPath || "configuration";
-  const configType = isObject(rawConfig) ? "platform" in rawConfig ? `invalid platform value: "${rawConfig.platform}"` : 'missing "flow" and "build" fields' : `not an object (got ${typeof rawConfig})`;
-  throw new Error(
-    `Invalid configuration format at ${configPath}.
-Configuration ${configType}.
-
-Expected either:
-  1. Multi-environment: { version: 1, environments: { prod: { flow: {...}, build: {...} } } }
-  2. Single-environment: { flow: { platform: "web" | "server", ... }, build: { packages: {...}, ... } }`
-  );
-}
-function normalizeAndValidate(flowConfig, buildOptions, configPath) {
-  if (!isObject(flowConfig) || !("platform" in flowConfig)) {
+import fs3 from "fs-extra";
+async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
+  const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
+  if (!await fs3.pathExists(absolutePath)) {
     throw new Error(
-      `Invalid flow config: missing "platform" field. Expected "web" or "server".`
+      `Local package path not found: ${localPath} (resolved to ${absolutePath})`
     );
   }
-  const platform = flowConfig.platform;
-  if (!validatePlatform(platform)) {
+  const pkgJsonPath = path4.join(absolutePath, "package.json");
+  if (!await fs3.pathExists(pkgJsonPath)) {
     throw new Error(
-      `Invalid platform "${platform}". Must be "web" or "server".`
+      `No package.json found at ${absolutePath}. Is this a valid package directory?`
     );
   }
-  if (!isObject(buildOptions)) {
-    throw new Error(
-      `Invalid build options: expected object, got ${typeof buildOptions}`
+  const distPath = path4.join(absolutePath, "dist");
+  const hasDistFolder = await fs3.pathExists(distPath);
+  if (!hasDistFolder) {
+    logger2.warn(
+      `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
     );
   }
-  const platformDefaults = platform === "web" ? {
-    platform: "browser",
-    format: "iife",
-    target: "es2020",
-    minify: false,
-    sourcemap: false,
-    tempDir: ".tmp",
-    cache: true
-  } : {
-    platform: "node",
-    format: "esm",
-    target: "node20",
-    minify: false,
-    sourcemap: false,
-    tempDir: ".tmp",
-    cache: true
-  };
-  const merged = {
-    ...platformDefaults,
-    ...buildOptions
-  };
-  if (merged.template === void 0) {
-    merged.template = platform === "server" ? "server.hbs" : "web.hbs";
-  }
-  if (merged.format === "iife" && merged.platform === "browser") {
-    if (merged.windowCollector === void 0) {
-      merged.windowCollector = "collector";
-    }
-    if (merged.windowElb === void 0) {
-      merged.windowElb = "elb";
-    }
-  }
-  if (configPath && merged.template && !path4.isAbsolute(merged.template) && (merged.template.startsWith("./") || merged.template.startsWith("../"))) {
-    const configDir = path4.dirname(configPath);
-    merged.template = path4.resolve(configDir, merged.template);
-  }
-  if (!merged.output || merged.output === "") {
-    merged.output = platform === "web" ? "./dist/walker.js" : "./dist/bundle.js";
-  }
-  if (configPath && configPath !== "/unknown/path" && merged.output && !path4.isAbsolute(merged.output)) {
-    const configDir = path4.dirname(configPath);
-    merged.output = path4.resolve(configDir, merged.output);
-  }
-  if (!merged.packages) {
-    merged.packages = {};
-  }
-  if (merged.code === void 0 || merged.code === "") {
-    merged.code = "";
-  }
   return {
-    flowConfig,
-    buildOptions: merged
+    name: packageName,
+    absolutePath,
+    distPath: hasDistFolder ? distPath : absolutePath,
+    hasDistFolder
   };
 }
-function parseBundleConfig(data) {
-  if (!isObject(data)) {
-    throw new Error(`Invalid config: expected object, got ${typeof data}`);
-  }
-  if (!("flow" in data) || !isObject(data.flow)) {
-    throw new Error(
-      `Invalid config: missing "flow" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
-  }
-  if (!("build" in data) || !isObject(data.build)) {
-    throw new Error(
-      `Invalid config: missing "build" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
+async function copyLocalPackage(localPkg, targetDir, logger2) {
+  const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
+  await fs3.ensureDir(path4.dirname(packageDir));
+  await fs3.copy(
+    path4.join(localPkg.absolutePath, "package.json"),
+    path4.join(packageDir, "package.json")
+  );
+  if (localPkg.hasDistFolder) {
+    await fs3.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+  } else {
+    const entries = await fs3.readdir(localPkg.absolutePath);
+    for (const entry of entries) {
+      if (!["node_modules", ".turbo", ".git"].includes(entry)) {
+        await fs3.copy(
+          path4.join(localPkg.absolutePath, entry),
+          path4.join(packageDir, entry)
+        );
+      }
+    }
   }
-  const buildData = data.build;
-  if ("packages" in buildData && !isObject(buildData.packages)) {
-    throw new Error(
-      `Invalid config: build.packages must be an object, got ${typeof buildData.packages}`
-    );
+  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 path15 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path15}: ${issue.message}`;
+    }).join("\n");
+    throw new Error(`Invalid configuration:
+${errors}`);
   }
-  return normalizeAndValidate(data.flow, data.build, "/unknown/path");
+  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,
+  tempDir: ".tmp",
+  windowCollector: "collector",
+  windowElb: "elb"
+};
+var SERVER_BUILD_DEFAULTS = {
+  format: "esm",
+  platform: "node",
+  target: "node20",
+  minify: true,
+  sourcemap: false,
+  cache: true,
+  tempDir: ".tmp"
+};
+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 normalizeConfigs(config, configPath) {
-  return normalizeAndValidate(config.flow, config.build, configPath);
+function getDefaultOutput(platform) {
+  return DEFAULT_OUTPUT_PATHS[platform];
 }
 
 // src/config/loader.ts
+import path5 from "path";
+import fs4 from "fs-extra";
+import { getFlowConfig, getPlatform } from "@walkeros/core";
+var DEFAULT_INCLUDE_FOLDER = "./shared";
 function loadBundleConfig(rawConfig, options) {
-  const { flowConfig, buildOptions, metadata } = parseConfigStructure(
-    rawConfig,
-    {
-      configPath: options.configPath,
-      environment: options.environment
-    }
-  );
-  const normalized = normalizeAndValidate(
-    flowConfig,
-    buildOptions,
-    options.configPath
-  );
-  if (metadata.isMultiEnvironment && options.logger) {
-    options.logger.info(
-      `\u{1F4E6} Using environment: ${metadata.environment} (${metadata.availableEnvironments?.length || 0} total)`
-    );
-  }
-  if (!metadata.isMultiEnvironment && options.environment && options.logger) {
-    options.logger.warn(
-      `--env flag specified but configuration is single-environment. Ignoring flag.`
-    );
-  }
-  return {
-    ...normalized,
-    ...metadata
-  };
-}
-function loadMultiEnvironmentConfig(setup, options) {
-  const availableEnvironments = Object.keys(setup.environments);
-  if (!options.environment) {
-    throw new Error(
-      `Multi-environment configuration detected. Please specify an environment using --env flag.
-Available environments: ${availableEnvironments.join(", ")}`
-    );
-  }
-  const selectedEnv = options.environment;
-  if (!setup.environments[selectedEnv]) {
+  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(
-      `Environment "${selectedEnv}" not found in configuration.
-Available environments: ${availableEnvironments.join(", ")}`
+      `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
     );
   }
-  const envConfig = setup.environments[selectedEnv];
-  const { flowConfig, buildOptions } = normalizeConfigs(
-    envConfig,
-    options.configPath
-  );
-  if (options.logger) {
+  const buildDefaults = getBuildDefaults(platform);
+  const packages = flowConfig.packages || {};
+  let output = getDefaultOutput(platform);
+  if (options.buildOverrides?.output) {
+    output = options.buildOverrides.output;
+  }
+  const configDir = path5.dirname(options.configPath);
+  if (!path5.isAbsolute(output)) {
+    output = path5.resolve(configDir, output);
+  }
+  let includes = setup.include;
+  if (!includes) {
+    const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
+    if (fs4.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 environment: ${selectedEnv} (${availableEnvironments.length} total)`
+      `\u{1F4E6} Using flow: ${flowName} (${availableFlows.length} total)`
     );
   }
   return {
     flowConfig,
     buildOptions,
-    environment: selectedEnv,
-    isMultiEnvironment: true,
-    availableEnvironments
+    flowName,
+    isMultiFlow,
+    availableFlows
   };
 }
-function loadAllEnvironments(rawConfig, options) {
-  if (!isMultiEnvConfig(rawConfig)) {
+function resolveFlow(setup, requestedFlow, available) {
+  if (available.length === 1) {
+    return available[0];
+  }
+  if (!requestedFlow) {
     throw new Error(
-      `--all flag requires a multi-environment configuration (Setup format).
-Your configuration appears to be single-environment.`
+      `Multiple flows found. Please specify a flow using --flow flag.
+Available flows: ${available.join(", ")}`
     );
   }
-  const setup = rawConfig;
-  const environments = Object.keys(setup.environments);
+  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 ${environments.length} environments: ${environments.join(", ")}`
+      `\u{1F4E6} Loading all ${flows.length} flows: ${flows.join(", ")}`
     );
   }
-  return environments.map(
-    (envName) => loadMultiEnvironmentConfig(setup, {
+  return flows.map(
+    (name) => loadBundleConfig(rawConfig, {
       ...options,
-      environment: envName
+      flowName: name
     })
   );
 }
 
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
+import path8 from "path";
+import fs7 from "fs-extra";
+import { packageNameToVariable } from "@walkeros/core";
+
+// src/commands/bundle/package-manager.ts
+import pacote from "pacote";
 import path6 from "path";
 import fs5 from "fs-extra";
 
+// src/core/cache-utils.ts
+import { getHashServer as getHashServer2 } 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 getHashServer2(input2, HASH_LENGTH);
+  }
+  const input = `${safeName}@${version}`;
+  return getHashServer2(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 getHashServer2(input, HASH_LENGTH);
+}
+
 // src/commands/bundle/package-manager.ts
-import pacote from "pacote";
-import path5 from "path";
-import fs3 from "fs-extra";
 function getPackageDirectory(baseDir, packageName, version) {
-  return path5.join(baseDir, "node_modules", packageName);
+  return path6.join(baseDir, "node_modules", packageName);
 }
-function getCachedPackagePath(pkg, tempDir) {
-  const cacheDir = path5.join(".tmp", "cache", "packages");
-  const safeName = pkg.name.replace(/\//g, "-").replace(/@/g, "");
-  return path5.join(cacheDir, `${safeName}-${pkg.version}`);
+async function getCachedPackagePath(pkg, tempDir) {
+  const cacheDir = path6.join(".tmp", "cache", "packages");
+  const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
+  return path6.join(cacheDir, cacheKey);
 }
 async function isPackageCached(pkg, tempDir) {
-  const cachedPath = getCachedPackagePath(pkg, tempDir);
-  return fs3.pathExists(cachedPath);
+  const cachedPath = await getCachedPackagePath(pkg, tempDir);
+  return fs5.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -778,7 +752,7 @@ Each package must use the same version across all declarations. Please update yo
     );
   }
 }
-async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE__ */ new Set()) {
+async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PURE__ */ new Set()) {
   const dependencies = [];
   const pkgKey = `${pkg.name}@${pkg.version}`;
   if (visited.has(pkgKey)) {
@@ -786,9 +760,9 @@ async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE
   }
   visited.add(pkgKey);
   try {
-    const packageJsonPath = path5.join(packageDir, "package.json");
-    if (await fs3.pathExists(packageJsonPath)) {
-      const packageJson2 = await fs3.readJson(packageJsonPath);
+    const packageJsonPath = path6.join(packageDir, "package.json");
+    if (await fs5.pathExists(packageJsonPath)) {
+      const packageJson2 = await fs5.readJson(packageJsonPath);
       const deps = {
         ...packageJson2.dependencies,
         ...packageJson2.peerDependencies
@@ -800,16 +774,22 @@ async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE
       }
     }
   } catch (error) {
-    logger.debug(`Failed to read dependencies for ${pkgKey}: ${error}`);
+    logger2.debug(`Failed to read dependencies for ${pkgKey}: ${error}`);
   }
   return dependencies;
 }
-async function downloadPackages(packages, targetDir, logger, useCache = true) {
+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 fs3.ensureDir(targetDir);
+  await fs5.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -817,16 +797,37 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
       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 = getCachedPackagePath(pkg, targetDir);
+    const cachedPath = await getCachedPackagePath(pkg, targetDir);
     if (useCache && await isPackageCached(pkg, targetDir)) {
-      logger.debug(`Using cached ${packageSpec}...`);
+      logger2.debug(`Using cached ${packageSpec}...`);
       try {
-        await fs3.ensureDir(path5.dirname(packageDir));
-        await fs3.copy(cachedPath, packageDir);
+        await fs5.ensureDir(path6.dirname(packageDir));
+        await fs5.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
-        const deps = await resolveDependencies(pkg, packageDir, logger);
+        const deps = await resolveDependencies(pkg, packageDir, logger2);
         for (const dep of deps) {
           const depKey = `${dep.name}@${dep.version}`;
           if (!processed.has(depKey)) {
@@ -835,15 +836,15 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
         }
         continue;
       } catch (error) {
-        logger.debug(
+        logger2.debug(
           `Failed to use cache for ${packageSpec}, downloading fresh: ${error}`
         );
       }
     }
-    logger.debug(`Downloading ${packageSpec}...`);
+    logger2.debug(`Downloading ${packageSpec}...`);
     try {
-      await fs3.ensureDir(path5.dirname(packageDir));
-      const cacheDir = process.env.NPM_CACHE_DIR || path5.join(process.cwd(), ".npm-cache");
+      await fs5.ensureDir(path6.dirname(packageDir));
+      const cacheDir = process.env.NPM_CACHE_DIR || path6.join(process.cwd(), ".npm-cache");
       await pacote.extract(packageSpec, packageDir, {
         // Force npm registry download, prevent workspace resolution
         registry: "https://registry.npmjs.org",
@@ -856,15 +857,15 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
       });
       if (useCache) {
         try {
-          await fs3.ensureDir(path5.dirname(cachedPath));
-          await fs3.copy(packageDir, cachedPath);
-          logger.debug(`Cached ${packageSpec} for future use`);
+          await fs5.ensureDir(path6.dirname(cachedPath));
+          await fs5.copy(packageDir, cachedPath);
+          logger2.debug(`Cached ${packageSpec} for future use`);
         } catch (cacheError) {
-          logger.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
+          logger2.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
         }
       }
       packagePaths.set(pkg.name, packageDir);
-      const deps = await resolveDependencies(pkg, packageDir, logger);
+      const deps = await resolveDependencies(pkg, packageDir, logger2);
       for (const dep of deps) {
         const depKey = `${dep.name}@${dep.version}`;
         if (!processed.has(depKey)) {
@@ -878,188 +879,118 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
   return packagePaths;
 }
 
-// src/commands/bundle/template-engine.ts
-import fs4 from "fs-extra";
-import Handlebars from "handlebars";
-
-// src/commands/bundle/serializer.ts
-function serializeToJS(value, options = {}) {
-  const { indent = 2, singleQuotes = false } = options;
-  const quote = singleQuotes ? "'" : '"';
-  function serialize(val, currentIndent = 0) {
-    if (val === null) return "null";
-    if (val === void 0) return "undefined";
-    if (typeof val === "boolean" || typeof val === "number") {
-      return String(val);
-    }
-    if (typeof val === "string") {
-      if (val.includes("=>")) {
-        const arrowPatterns = [
-          /^\s*\([^)]*\)\s*=>/,
-          // (param) => or () =>
-          /^\s*\w+\s*=>/,
-          // param =>
-          /^\s*\([^)]*\)\s*=>\s*\{/,
-          // (param) => {
-          /^\s*\w+\s*=>\s*\{/
-          // param => {
-        ];
-        if (arrowPatterns.some((pattern) => pattern.test(val))) {
-          return val;
-        }
-      }
-      return quote + val.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"') + quote;
-    }
-    if (Array.isArray(val)) {
-      if (val.length === 0) return "[]";
-      const nextIndent = currentIndent + indent;
-      const spacing = " ".repeat(nextIndent);
-      const items = val.map((item) => spacing + serialize(item, nextIndent)).join(",\n");
-      return `[
-${items}
-${" ".repeat(currentIndent)}]`;
-    }
-    if (isObject(val)) {
-      const entries = Object.entries(val);
-      if (entries.length === 0) return "{}";
-      const nextIndent = currentIndent + indent;
-      const spacing = " ".repeat(nextIndent);
-      const props = entries.map(([key, value2]) => {
-        const needsQuotes = /[^a-zA-Z0-9_$]/.test(key) || /^[0-9]/.test(key);
-        const keyStr = needsQuotes ? quote + key + quote : key;
-        return spacing + keyStr + ": " + serialize(value2, nextIndent);
-      }).join(",\n");
-      return `{
-${props}
-${" ".repeat(currentIndent)}}`;
-    }
-    return String(val);
-  }
-  return serialize(value);
-}
-function serializeConfig(config) {
-  if (!config || Object.keys(config).length === 0) {
-    return "{}";
-  }
-  return serializeToJS(config, { indent: 2, singleQuotes: true });
-}
-function processTemplateVariables(variables) {
-  const processed = { ...variables };
-  if (isObject(processed.sources)) {
-    const sourcesObj = processed.sources;
-    const processedSources = {};
-    for (const [name, source] of Object.entries(sourcesObj)) {
-      const typedSource = source;
-      const { env: _, ...sourceWithoutEnv } = typedSource;
-      processedSources[name] = {
-        ...sourceWithoutEnv,
-        config: isObject(typedSource.config) ? serializeConfig(typedSource.config) : typedSource.config,
-        // Pass through string configs unchanged
-        ...typedSource.env !== void 0 && { env: typedSource.env }
-      };
-    }
-    processed.sources = processedSources;
-  }
-  if (isObject(processed.destinations)) {
-    const destinationsObj = processed.destinations;
-    const processedDestinations = {};
-    for (const [name, dest] of Object.entries(destinationsObj)) {
-      const typedDest = dest;
-      const { env: _, ...destWithoutEnv } = typedDest;
-      processedDestinations[name] = {
-        ...destWithoutEnv,
-        config: isObject(typedDest.config) ? serializeConfig(typedDest.config) : typedDest.config,
-        ...typedDest.env !== void 0 && { env: typedDest.env }
-      };
-    }
-    processed.destinations = processedDestinations;
-  }
-  if (isObject(processed.collector)) {
-    processed.collector = serializeConfig(
-      processed.collector
-    );
+// src/core/build-cache.ts
+import fs6 from "fs-extra";
+import path7 from "path";
+var BUILD_CACHE_DIR = path7.join(".tmp", "cache", "builds");
+async function getBuildCachePath(configContent, cacheDir = BUILD_CACHE_DIR) {
+  const cacheKey = await getFlowConfigCacheKey(configContent);
+  return path7.join(cacheDir, `${cacheKey}.js`);
+}
+async function isBuildCached(configContent, cacheDir = BUILD_CACHE_DIR) {
+  const cachePath = await getBuildCachePath(configContent, cacheDir);
+  return fs6.pathExists(cachePath);
+}
+async function cacheBuild(configContent, buildOutput, cacheDir = BUILD_CACHE_DIR) {
+  const cachePath = await getBuildCachePath(configContent, cacheDir);
+  await fs6.ensureDir(path7.dirname(cachePath));
+  await fs6.writeFile(cachePath, buildOutput, "utf-8");
+}
+async function getCachedBuild(configContent, cacheDir = BUILD_CACHE_DIR) {
+  const cachePath = await getBuildCachePath(configContent, cacheDir);
+  if (await fs6.pathExists(cachePath)) {
+    return await fs6.readFile(cachePath, "utf-8");
   }
-  return processed;
+  return null;
 }
 
-// src/commands/bundle/template-engine.ts
-var TemplateEngine = class {
-  handlebars;
-  constructor() {
-    this.handlebars = Handlebars.create();
-    this.handlebars.registerHelper("eq", (a, b) => a === b);
-  }
-  /**
-   * Load template content from file path
-   *
-   * @param templatePath - Template path (bare name, relative, or absolute)
-   */
-  async loadTemplate(templatePath) {
-    const resolvedPath = resolveAsset(templatePath, "template");
-    if (!await fs4.pathExists(resolvedPath)) {
-      throw new Error(`Template file not found: ${resolvedPath}`);
+// 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 fs7.pathExists(sourcePath)) {
+      await fs7.copy(sourcePath, destPath);
+      logger2.debug(`Copied ${include} to output`);
+    } else {
+      logger2.debug(`Include folder not found: ${include}`);
     }
-    return await fs4.readFile(resolvedPath, "utf-8");
-  }
-  /**
-   * Apply template with user code and variable substitution
-   */
-  applyTemplate(template, userCode, sources, destinations, collector, build) {
-    const processedVariables = processTemplateVariables({
-      sources,
-      destinations,
-      collector
-    });
-    const templateData = {
-      CODE: userCode,
-      build: build || {},
-      ...processedVariables
-    };
-    const compiledTemplate = this.handlebars.compile(template);
-    return compiledTemplate(templateData);
-  }
-  /**
-   * Process template with user code
-   */
-  async process(templatePath, userCode, sources, destinations, collector, build) {
-    const template = await this.loadTemplate(templatePath);
-    return this.applyTemplate(
-      template,
-      userCode,
-      sources,
-      destinations,
-      collector,
-      build
-    );
   }
-};
-
-// src/commands/bundle/bundler.ts
-async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
+}
+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 ? path6.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path6.resolve(buildOptions.tempDir) : getTempDir();
+  const TEMP_DIR = buildOptions.tempDir ? path8.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path8.resolve(buildOptions.tempDir) : getTempDir();
+  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 fs7.ensureDir(path8.dirname(outputPath));
+        await fs7.writeFile(outputPath, cachedBuild);
+        logger2.gray(`Output: ${outputPath}`);
+        logger2.success("\u2705 Build completed (from cache)");
+        if (showStats) {
+          const stats = await fs7.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 {
     if (!buildOptions.tempDir) {
-      await fs5.emptyDir(TEMP_DIR);
+      await fs7.emptyDir(TEMP_DIR);
     }
-    logger.debug("Cleaned temporary directory");
-    logger.info("\u{1F4E5} Downloading packages...");
+    logger2.debug("Cleaned temporary directory");
+    logger2.info("\u{1F4E5} Downloading packages...");
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
         name,
-        version: packageConfig.version || "latest"
+        version: packageConfig.version || "latest",
+        path: packageConfig.path
+        // Pass local path if defined
       })
     );
     const packagePaths = await downloadPackages(
       packagesArray,
       TEMP_DIR,
-      logger,
-      buildOptions.cache
+      logger2,
+      buildOptions.cache,
+      buildOptions.configDir
+      // For resolving relative local paths
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
-        const pkgJsonPath = path6.join(pkgPath, "package.json");
-        const pkgJson = await fs5.readJSON(pkgJsonPath);
+        const pkgJsonPath = path8.join(pkgPath, "package.json");
+        const pkgJson = await fs7.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -1067,33 +998,33 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
               require: pkgJson.main
             }
           };
-          await fs5.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs7.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
-    const packageJsonPath = path6.join(TEMP_DIR, "package.json");
-    await fs5.writeFile(
+    const packageJsonPath = path8.join(TEMP_DIR, "package.json");
+    await fs7.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
-    logger.info("\u{1F4DD} Creating entry point...");
+    logger2.info("\u{1F4DD} Creating entry point...");
     const entryContent = await createEntryPoint(
       flowConfig,
       buildOptions,
       packagePaths
     );
-    const entryPath = path6.join(TEMP_DIR, "entry.js");
-    await fs5.writeFile(entryPath, entryContent);
-    logger.info("\u26A1 Bundling with esbuild...");
-    const outputPath = path6.resolve(buildOptions.output);
-    await fs5.ensureDir(path6.dirname(outputPath));
+    const entryPath = path8.join(TEMP_DIR, "entry.js");
+    await fs7.writeFile(entryPath, entryContent);
+    logger2.info("\u26A1 Bundling with esbuild...");
+    const outputPath = path8.resolve(buildOptions.output);
+    await fs7.ensureDir(path8.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
       outputPath,
       TEMP_DIR,
       packagePaths,
-      logger
+      logger2
     );
     try {
       await esbuild.build(esbuildOptions);
@@ -1103,7 +1034,13 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
         buildOptions.code || ""
       );
     }
-    logger.gray(`Output: ${outputPath}`);
+    logger2.gray(`Output: ${outputPath}`);
+    if (buildOptions.cache !== false) {
+      const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+      const buildOutput = await fs7.readFile(outputPath, "utf-8");
+      await cacheBuild(configContent, buildOutput);
+      logger2.debug("Build cached for future use");
+    }
     let stats;
     if (showStats) {
       stats = await collectBundleStats(
@@ -1113,21 +1050,30 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
         entryContent
       );
     }
+    if (buildOptions.include && buildOptions.include.length > 0) {
+      const outputDir = path8.dirname(outputPath);
+      await copyIncludes(
+        buildOptions.include,
+        buildOptions.configDir || process.cwd(),
+        outputDir,
+        logger2
+      );
+    }
     if (!buildOptions.tempDir) {
-      await fs5.remove(TEMP_DIR);
-      logger.debug("Cleaned up temporary files");
+      await fs7.remove(TEMP_DIR);
+      logger2.debug("Cleaned up temporary files");
     }
     return stats;
   } catch (error) {
     if (!buildOptions.tempDir) {
-      await fs5.remove(TEMP_DIR).catch(() => {
+      await fs7.remove(TEMP_DIR).catch(() => {
       });
     }
     throw error;
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs5.stat(outputPath);
+  const stats = await fs7.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1153,7 +1099,7 @@ async function collectBundleStats(outputPath, packages, startTime, entryContent)
     treeshakingEffective
   };
 }
-function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger) {
+function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger2) {
   const alias = {};
   const baseOptions = {
     entryPoints: [entryPath],
@@ -1206,6 +1152,11 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
     ];
     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;
@@ -1216,11 +1167,6 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
   }
   return baseOptions;
 }
-function packageNameToVariable(packageName) {
-  return packageName.replace("@", "_").replace(/[/-]/g, "_").split("_").map(
-    (part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
-  ).join("");
-}
 function detectDestinationPackages(flowConfig) {
   const destinationPackages = /* @__PURE__ */ new Set();
   const destinations = flowConfig.destinations;
@@ -1233,10 +1179,57 @@ function detectDestinationPackages(flowConfig) {
   }
   return destinationPackages;
 }
-function generateImportStatements(packages, 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 = [];
@@ -1276,76 +1269,45 @@ function generateImportStatements(packages, destinationPackages) {
           );
         }
       }
-    } else {
-      const varName = packageNameToVariable(packageName);
+    } else if (hasExplicitCode) {
+      const codes = Array.from(explicitCodeImports.get(packageName));
       importStatements.push(
-        `import * as ${varName} from '${packageName}'; // Consider specifying explicit imports`
+        `import { ${codes.join(", ")} } from '${packageName}';`
       );
+    } else if (isUsedByDestOrSource) {
+      const varName = packageNameToVariable(packageName);
+      importStatements.push(`import ${varName} from '${packageName}';`);
     }
   }
   return { importStatements, examplesMappings };
 }
-async function processTemplate(flowConfig, buildOptions) {
-  if (buildOptions.template) {
-    const templateEngine = new TemplateEngine();
-    const flowWithProps = flowConfig;
-    return await templateEngine.process(
-      buildOptions.template,
-      buildOptions.code || "",
-      // Pass user code as parameter (empty if undefined)
-      flowWithProps.sources || {},
-      flowWithProps.destinations || {},
-      flowWithProps.collector || {},
-      buildOptions
-      // Pass build config to template
-    );
-  } else {
-    return buildOptions.code || "";
-  }
-}
-function wrapCodeForFormat(code, format, hasTemplate) {
-  if (hasTemplate) {
-    return code;
-  }
-  if (format === "esm") {
-    const hasExport = /^\s*export\s/m.test(code);
-    if (!hasExport) {
-      return `export default ${code}`;
-    }
-  }
-  return code;
-}
-function assembleFinalCode(importStatements, examplesObject, wrappedCode, format) {
-  const importsCode = importStatements.join("\n");
-  let finalCode = importsCode ? `${importsCode}
-
-${examplesObject}${wrappedCode}` : `${examplesObject}${wrappedCode}`;
-  if (examplesObject && format === "esm") {
-    finalCode += `
-
-export { examples };`;
-  }
-  return finalCode;
-}
 async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
   const destinationPackages = detectDestinationPackages(flowConfig);
+  const sourcePackages = detectSourcePackages(flowConfig);
+  const explicitCodeImports = detectExplicitCodeImports(flowConfig);
   const { importStatements } = generateImportStatements(
     buildOptions.packages,
-    destinationPackages
-  );
-  const examplesObject = "";
-  const templatedCode = await processTemplate(flowConfig, buildOptions);
-  const wrappedCode = wrapCodeForFormat(
-    templatedCode,
-    buildOptions.format,
-    !!buildOptions.template
+    destinationPackages,
+    sourcePackages,
+    explicitCodeImports
   );
-  return assembleFinalCode(
-    importStatements,
-    examplesObject,
-    wrappedCode,
-    buildOptions.format
+  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) {
@@ -1370,92 +1332,165 @@ ${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, logger) {
-  logger.info("\n\u{1F4CA} Bundle Statistics");
-  logger.info("\u2500".repeat(50));
+function displayStats(stats, logger2) {
+  logger2.info("\n\u{1F4CA} Bundle Statistics");
+  logger2.info("\u2500".repeat(50));
   const sizeKB = formatBytes(stats.totalSize);
-  logger.info(`Total Size: ${sizeKB} KB`);
+  logger2.info(`Total Size: ${sizeKB} KB`);
   const timeSeconds = (stats.buildTime / 1e3).toFixed(2);
-  logger.info(`Build Time: ${timeSeconds}s`);
+  logger2.info(`Build Time: ${timeSeconds}s`);
   const treeshakingStatus = stats.treeshakingEffective ? "\u2705 Effective" : "\u26A0\uFE0F  Not optimal (consider using named imports)";
-  logger.info(`Tree-shaking: ${treeshakingStatus}`);
+  logger2.info(`Tree-shaking: ${treeshakingStatus}`);
   if (stats.packages.length > 0) {
-    logger.info(`
+    logger2.info(`
 Package Breakdown:`);
     stats.packages.forEach((pkg) => {
       if (pkg.size > 0) {
         const pkgSizeKB = formatBytes(pkg.size);
-        logger.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
+        logger2.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
       }
     });
   }
-  logger.info("\u2500".repeat(50));
+  logger2.info("\u2500".repeat(50));
 }
 
 // src/commands/bundle/index.ts
 async function bundleCommand(options) {
   const timer = createTimer();
   timer.start();
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
-  if (options.env) dockerArgs.push("--env", options.env);
+  if (options.flow) dockerArgs.push("--flow", options.flow);
   if (options.all) dockerArgs.push("--all");
   if (options.stats) dockerArgs.push("--stats");
   if (options.cache === false) dockerArgs.push("--no-cache");
   await executeCommand(
     async () => {
       try {
-        if (options.env && options.all) {
-          throw new Error("Cannot use both --env and --all flags together");
+        if (options.flow && options.all) {
+          throw new Error("Cannot use both --flow and --all flags together");
         }
-        logger.info("\u{1F4E6} Reading configuration...");
-        const configPath = options.config;
+        logger2.info("\u{1F4E6} Reading configuration...");
+        const configPath = resolveAsset(options.config, "config");
         const rawConfig = await loadJsonConfig(configPath);
-        const configsToBundle = options.all ? loadAllEnvironments(rawConfig, { configPath, logger }) : [
+        const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger: logger2 }) : [
           loadBundleConfig(rawConfig, {
             configPath,
-            environment: options.env,
-            logger
+            flowName: options.flow,
+            logger: logger2
           })
         ];
         const results = [];
         for (const {
           flowConfig,
           buildOptions,
-          environment,
-          isMultiEnvironment
+          flowName,
+          isMultiFlow
         } of configsToBundle) {
           try {
             if (options.cache !== void 0) {
               buildOptions.cache = options.cache;
             }
-            if (isMultiEnvironment || options.all) {
-              logger.info(`
-\u{1F527} Building environment: ${environment}`);
+            if (isMultiFlow || options.all) {
+              logger2.info(`
+\u{1F527} Building flow: ${flowName}`);
             } else {
-              logger.info("\u{1F527} Starting bundle process...");
+              logger2.info("\u{1F527} Starting bundle process...");
             }
             const shouldCollectStats = options.stats || options.json;
             const stats = await bundleCore(
               flowConfig,
               buildOptions,
-              logger,
+              logger2,
               shouldCollectStats
             );
             results.push({
-              environment,
+              flowName,
               success: true,
               stats
             });
             if (!options.json && !options.all && options.stats && stats) {
-              displayStats(stats, logger);
+              displayStats(stats, logger2);
             }
           } catch (error) {
             const errorMessage = getErrorMessage(error);
             results.push({
-              environment,
+              flowName,
               success: false,
               error: errorMessage
             });
@@ -1471,7 +1506,7 @@ async function bundleCommand(options) {
           const outputLogger = createLogger({ silent: false, json: false });
           const output = failureCount === 0 ? createSuccessOutput(
             {
-              environments: results,
+              flows: results,
               summary: {
                 total: results.length,
                 success: successCount,
@@ -1480,27 +1515,27 @@ async function bundleCommand(options) {
             },
             duration
           ) : createErrorOutput(
-            `${failureCount} environment(s) failed to build`,
+            `${failureCount} flow(s) failed to build`,
             duration
           );
           outputLogger.log("white", JSON.stringify(output, null, 2));
         } else {
           if (options.all) {
-            logger.info(`
+            logger2.info(`
 \u{1F4CA} Build Summary:`);
-            logger.info(`   Total: ${results.length}`);
-            logger.success(`   \u2705 Success: ${successCount}`);
+            logger2.info(`   Total: ${results.length}`);
+            logger2.success(`   \u2705 Success: ${successCount}`);
             if (failureCount > 0) {
-              logger.error(`   \u274C Failed: ${failureCount}`);
+              logger2.error(`   \u274C Failed: ${failureCount}`);
             }
           }
           if (failureCount === 0) {
-            logger.success(
+            logger2.success(
               `
 \u2705 Bundle created successfully in ${timer.format()}`
             );
           } else {
-            throw new Error(`${failureCount} environment(s) failed to build`);
+            throw new Error(`${failureCount} flow(s) failed to build`);
           }
         }
       } catch (error) {
@@ -1511,8 +1546,8 @@ async function bundleCommand(options) {
           const output = createErrorOutput(errorMessage, duration);
           outputLogger.log("white", JSON.stringify(output, null, 2));
         } else {
-          logger.error("\u274C Bundle failed:");
-          logger.error(errorMessage);
+          logger2.error("\u274C Bundle failed:");
+          logger2.error(errorMessage);
         }
         process.exit(1);
       }
@@ -1520,33 +1555,40 @@ async function bundleCommand(options) {
     "bundle",
     dockerArgs,
     options,
-    logger,
+    logger2,
     options.config
   );
 }
 async function bundle(configOrPath, options = {}) {
   let rawConfig;
+  let configPath = path9.resolve(process.cwd(), "walkeros.config.json");
   if (typeof configOrPath === "string") {
-    rawConfig = await loadJsonConfig(configOrPath);
+    configPath = resolveAsset(configOrPath, "config");
+    rawConfig = await loadJsonConfig(configPath);
   } else {
     rawConfig = configOrPath;
   }
-  const { flowConfig, buildOptions } = parseBundleConfig(rawConfig);
+  const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+    configPath,
+    flowName: options.flowName,
+    buildOverrides: options.buildOverrides
+  });
   if (options.cache !== void 0) {
     buildOptions.cache = options.cache;
   }
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   return await bundleCore(
     flowConfig,
     buildOptions,
-    logger,
+    logger2,
     options.stats ?? false
   );
 }
 
 // src/commands/simulate/simulator.ts
-import path7 from "path";
-import fs7 from "fs-extra";
+import path10 from "path";
+import fs9 from "fs-extra";
+import { getPlatform as getPlatform2 } from "@walkeros/core";
 
 // src/commands/simulate/tracker.ts
 var CallTracker = class {
@@ -1582,9 +1624,9 @@ var CallTracker = class {
     }
     for (const fullPath of paths) {
       const [destKey, ...pathParts] = fullPath.split(":");
-      const path11 = pathParts.join(":");
-      if (!path11) continue;
-      const cleanPath = path11.replace(/^call:/, "");
+      const path15 = pathParts.join(":");
+      if (!path15) continue;
+      const cleanPath = path15.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -1628,7 +1670,7 @@ var CallTracker = class {
 
 // src/commands/simulate/jsdom-executor.ts
 import { JSDOM, VirtualConsole } from "jsdom";
-import fs6 from "fs-extra";
+import fs8 from "fs-extra";
 function buildSandboxFromEnvs(envs, destinations, tracker) {
   const baseBrowserMocks = {
     Image: class MockImage {
@@ -1697,7 +1739,7 @@ async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, ti
   const sandbox = buildSandboxFromEnvs(envs, destinations, tracker);
   Object.assign(window, sandbox.window);
   Object.assign(window.document, sandbox.document);
-  const bundleCode = await fs6.readFile(bundlePath, "utf8");
+  const bundleCode = await fs8.readFile(bundlePath, "utf8");
   try {
     window.eval(bundleCode);
   } catch (error) {
@@ -1735,6 +1777,85 @@ async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, ti
   };
 }
 
+// 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 = {};
@@ -1771,28 +1892,28 @@ function generateId() {
   return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 }
 async function simulateCore(configPath, event, options = {}) {
-  const logger = createLogger({
+  const logger2 = createLogger({
     verbose: options.verbose || false,
     silent: options.silent || false,
     json: options.json || false
   });
   try {
-    logger.info("\u{1F3AF} Starting walkerOS simulation...");
-    logger.info("\u{1F4E6} Loading bundle configuration...");
-    const fullConfigPath = path7.resolve(configPath);
+    logger2.info("\u{1F3AF} Starting walkerOS simulation...");
+    logger2.info("\u{1F4E6} Loading bundle configuration...");
+    const fullConfigPath = path10.resolve(configPath);
     const rawConfig = await loadJsonConfig(fullConfigPath);
-    parseBundleConfig(rawConfig);
-    logger.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
+    loadBundleConfig(rawConfig, { configPath: fullConfigPath });
+    logger2.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
     const result = await executeSimulation(event, fullConfigPath);
     if (result.success) {
-      logger.info(`\u2705 Simulation completed successfully`);
+      logger2.info(`\u2705 Simulation completed successfully`);
     } else {
-      logger.error(`\u274C Simulation failed: ${result.error}`);
+      logger2.error(`\u274C Simulation failed: ${result.error}`);
     }
     return result;
   } catch (error) {
     const errorMessage = getErrorMessage(error);
-    logger.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
+    logger2.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
     return {
       success: false,
       error: errorMessage
@@ -1825,42 +1946,32 @@ async function executeSimulation(event, configPath) {
       );
     }
     const typedEvent = event;
-    await fs7.ensureDir(tempDir);
+    await fs9.ensureDir(tempDir);
     const rawConfig = await loadJsonConfig(configPath);
-    const { flowConfig, buildOptions } = parseBundleConfig(rawConfig);
-    const packagesArray = Object.entries(buildOptions.packages).map(
-      ([name, packageConfig]) => ({
-        name,
-        version: (typeof packageConfig === "object" && packageConfig !== null && "version" in packageConfig && typeof packageConfig.version === "string" ? packageConfig.version : void 0) || "latest"
-      })
-    );
-    const packagePaths = await downloadPackages(
-      packagesArray,
-      tempDir,
-      // downloadPackages will add 'node_modules' subdirectory itself
-      createLogger({ silent: true }),
-      buildOptions.cache
-    );
+    const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+      configPath
+    });
+    const platform = getPlatform2(flowConfig);
     const tracker = new CallTracker();
-    const tempOutput = path7.join(
+    const tempOutput = path10.join(
       tempDir,
-      `simulation-bundle-${generateId()}.js`
+      `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
     );
     const destinations = flowConfig.destinations;
     const simulationBuildOptions = {
       ...buildOptions,
       code: buildOptions.code || "",
-      // No code modification - use original
       output: tempOutput,
       tempDir,
-      // Use same temp dir for bundle
-      format: "iife",
-      // ← Test actual production format!
-      platform: "browser",
-      // ← Browser platform for IIFE
-      windowCollector: "collector",
-      // ← Ensure window assignment
-      windowElb: "elb"
+      ...platform === "web" ? {
+        format: "iife",
+        platform: "browser",
+        windowCollector: "collector",
+        windowElb: "elb"
+      } : {
+        format: "esm",
+        platform: "node"
+      }
     };
     await bundleCore(
       flowConfig,
@@ -1870,16 +1981,26 @@ async function executeSimulation(event, configPath) {
     );
     bundlePath = tempOutput;
     const envs = await loadDestinationEnvs(destinations || {});
-    const result = await executeInJSDOM(
-      tempOutput,
-      destinations || {},
-      typedEvent,
-      tracker,
-      envs,
-      // Pass dynamically loaded envs
-      1e4
-      // 10s timeout
-    );
+    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;
@@ -1899,7 +2020,7 @@ async function executeSimulation(event, configPath) {
     };
   } finally {
     if (tempDir) {
-      await fs7.remove(tempDir).catch(() => {
+      await fs9.remove(tempDir).catch(() => {
       });
     }
   }
@@ -1907,7 +2028,7 @@ async function executeSimulation(event, configPath) {
 
 // src/commands/simulate/index.ts
 async function simulateCommand(options) {
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
   if (options.event) dockerArgs.push("--event", options.event);
   await executeCommand(
@@ -1958,7 +2079,7 @@ async function simulateCommand(options) {
     "simulate",
     dockerArgs,
     options,
-    logger,
+    logger2,
     options.config
   );
 }
@@ -1975,74 +2096,83 @@ async function simulate(configOrPath, event, options = {}) {
 }
 
 // src/commands/push/index.ts
-import path8 from "path";
-import os2 from "os";
+import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs8 from "fs-extra";
+import fs10 from "fs-extra";
+import { getPlatform as getPlatform3 } from "@walkeros/core";
+import { schemas as schemas2 } from "@walkeros/core/dev";
 async function pushCommand(options) {
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
   dockerArgs.push("--event", options.event);
-  if (options.env) dockerArgs.push("--env", options.env);
+  if (options.flow) dockerArgs.push("--flow", options.flow);
   await executeCommand(
     async () => {
       const startTime = Date.now();
       try {
-        logger.info("\u{1F4E5} Loading event...");
+        logger2.info("\u{1F4E5} Loading event...");
         const event = await loadJsonFromSource(options.event, {
           name: "event"
         });
-        if (!event || typeof event !== "object" || !("name" in event) || typeof event.name !== "string") {
-          throw new Error(
-            'Event must be an object with a "name" property (string)'
-          );
+        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');
         }
-        if (!event.name.includes(" ")) {
-          logger.warn(
-            `Event name "${event.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
+        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")`
           );
         }
-        logger.info("\u{1F4E6} Loading flow configuration...");
-        const configPath = path8.resolve(options.config);
+        logger2.info("\u{1F4E6} Loading flow configuration...");
+        const configPath = path11.resolve(options.config);
         const rawConfig = await loadJsonConfig(configPath);
-        const { flowConfig, buildOptions, environment, isMultiEnvironment } = loadBundleConfig(rawConfig, {
+        const { flowConfig, buildOptions, flowName, isMultiFlow } = loadBundleConfig(rawConfig, {
           configPath: options.config,
-          environment: options.env,
-          logger
+          flowName: options.flow,
+          logger: logger2
         });
-        const platform = flowConfig.platform;
-        logger.info("\u{1F528} Bundling flow configuration...");
-        const tempPath = path8.join(
-          os2.tmpdir(),
-          `walkeros-push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.${platform === "web" ? "js" : "mjs"}`
+        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)}`
         );
-        const configWithOutput = {
-          flow: flowConfig,
-          build: {
-            ...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 fs10.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 bundle(configWithOutput, {
-          cache: true,
-          verbose: options.verbose,
-          silent: !options.verbose
-        });
-        logger.debug(`Bundle created: ${tempPath}`);
+        await bundleCore(flowConfig, pushBuildOptions, logger2, false);
+        logger2.debug(`Bundle created: ${tempPath}`);
         let result;
         if (platform === "web") {
-          logger.info("\u{1F310} Executing in web environment (JSDOM)...");
-          result = await executeWebPush(tempPath, event, logger);
+          logger2.info("\u{1F310} Executing in web environment (JSDOM)...");
+          result = await executeWebPush(tempPath, validatedEvent, logger2);
         } else if (platform === "server") {
-          logger.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
-          result = await executeServerPush(tempPath, event, logger);
+          logger2.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
+          result = await executeServerPush(tempPath, validatedEvent, logger2);
         } else {
           throw new Error(`Unsupported platform: ${platform}`);
         }
@@ -2063,27 +2193,27 @@ async function pushCommand(options) {
           );
         } else {
           if (result.success) {
-            logger.success("\u2705 Event pushed successfully");
+            logger2.success("\u2705 Event pushed successfully");
             if (result.elbResult && typeof result.elbResult === "object") {
               const pushResult = result.elbResult;
               if ("id" in pushResult && pushResult.id) {
-                logger.info(`   Event ID: ${pushResult.id}`);
+                logger2.info(`   Event ID: ${pushResult.id}`);
               }
               if ("entity" in pushResult && pushResult.entity) {
-                logger.info(`   Entity: ${pushResult.entity}`);
+                logger2.info(`   Entity: ${pushResult.entity}`);
               }
               if ("action" in pushResult && pushResult.action) {
-                logger.info(`   Action: ${pushResult.action}`);
+                logger2.info(`   Action: ${pushResult.action}`);
               }
             }
-            logger.info(`   Duration: ${duration}ms`);
+            logger2.info(`   Duration: ${duration}ms`);
           } else {
-            logger.error(`\u274C Push failed: ${result.error}`);
+            logger2.error(`\u274C Push failed: ${result.error}`);
             process.exit(1);
           }
         }
         try {
-          await fs8.remove(tempPath);
+          await fs10.remove(tempDir);
         } catch {
         }
       } catch (error) {
@@ -2104,7 +2234,7 @@ async function pushCommand(options) {
             )
           );
         } else {
-          logger.error(`\u274C Push command failed: ${errorMessage}`);
+          logger2.error(`\u274C Push command failed: ${errorMessage}`);
         }
         process.exit(1);
       }
@@ -2112,11 +2242,11 @@ async function pushCommand(options) {
     "push",
     dockerArgs,
     options,
-    logger,
+    logger2,
     options.config
   );
 }
-async function executeWebPush(bundlePath, event, logger) {
+async function executeWebPush(bundlePath, event, logger2) {
   const startTime = Date.now();
   try {
     const virtualConsole = new VirtualConsole2();
@@ -2127,10 +2257,10 @@ async function executeWebPush(bundlePath, event, logger) {
       virtualConsole
     });
     const { window } = dom;
-    logger.debug("Loading bundle...");
-    const bundleCode = await fs8.readFile(bundlePath, "utf8");
+    logger2.debug("Loading bundle...");
+    const bundleCode = await fs10.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
-    logger.debug("Waiting for elb...");
+    logger2.debug("Waiting for elb...");
     await waitForWindowProperty2(
       window,
       "elb",
@@ -2138,9 +2268,8 @@ async function executeWebPush(bundlePath, event, logger) {
     );
     const windowObj = window;
     const elb = windowObj.elb;
-    logger.info(`Pushing event: ${event.name}`);
-    const eventData = event.data || {};
-    const elbResult = await elb(event.name, eventData);
+    logger2.info(`Pushing event: ${event.name}`);
+    const elbResult = await elb(event.name, event.data);
     return {
       success: true,
       elbResult,
@@ -2154,7 +2283,7 @@ async function executeWebPush(bundlePath, event, logger) {
     };
   }
 }
-async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
+async function executeServerPush(bundlePath, event, logger2, timeout = 6e4) {
   const startTime = Date.now();
   try {
     const timeoutPromise = new Promise((_, reject) => {
@@ -2164,12 +2293,12 @@ async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
       );
     });
     const executePromise = (async () => {
-      logger.debug("Importing bundle...");
+      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");
       }
-      logger.debug("Calling factory function...");
+      logger2.debug("Calling factory function...");
       const result = await flowModule.default();
       if (!result || !result.elb || typeof result.elb !== "function") {
         throw new Error(
@@ -2177,9 +2306,8 @@ async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
         );
       }
       const { elb } = result;
-      logger.info(`Pushing event: ${event.name}`);
-      const eventData = event.data || {};
-      const elbResult = await elb(event.name, eventData);
+      logger2.info(`Pushing event: ${event.name}`);
+      const elbResult = await elb(event.name, event.data);
       return {
         success: true,
         elbResult,
@@ -2216,23 +2344,40 @@ function waitForWindowProperty2(window, prop, timeout = 5e3) {
 }
 
 // src/commands/run/index.ts
-import path10 from "path";
+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
-import { existsSync } from "fs";
-var VALID_MODES = ["collect", "serve"];
 function validateMode(mode) {
-  if (!VALID_MODES.includes(mode)) {
+  const result = RunModeSchema.safeParse(mode);
+  if (!result.success) {
     throw new Error(
       `Invalid mode: "${mode}"
-   Valid modes: ${VALID_MODES.join(", ")}
+   Valid modes: collect, serve
    Example: walkeros run collect ./flow.json`
     );
   }
 }
 function validateFlowFile(filePath) {
   const absolutePath = resolveAsset(filePath, "bundle");
-  if (!existsSync(absolutePath)) {
+  if (!existsSync2(absolutePath)) {
     throw new Error(
       `Flow file not found: ${filePath}
    Resolved path: ${absolutePath}
@@ -2242,7 +2387,8 @@ function validateFlowFile(filePath) {
   return absolutePath;
 }
 function validatePort(port) {
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+  const result = PortSchema.safeParse(port);
+  if (!result.success) {
     throw new Error(
       `Invalid port: ${port}
    Port must be an integer between 1 and 65535
@@ -2252,26 +2398,26 @@ function validatePort(port) {
 }
 
 // src/commands/run/utils.ts
-import path9 from "path";
-import os3 from "os";
+import path12 from "path";
+import fs11 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
-  const rawConfig = await loadJsonConfig(configPath);
-  const tempPath = path9.join(
-    os3.tmpdir(),
-    `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
+  const configDir = path12.dirname(path12.resolve(configPath));
+  const tempDir = path12.join(
+    configDir,
+    ".tmp",
+    `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  const existingBuild = typeof rawConfig === "object" && rawConfig !== null && "build" in rawConfig && typeof rawConfig.build === "object" ? rawConfig.build : {};
-  const configWithOutput = {
-    ...rawConfig,
-    build: {
-      ...existingBuild,
-      output: tempPath
-    }
-  };
-  await bundle(configWithOutput, {
+  await fs11.ensureDir(tempDir);
+  const tempPath = path12.join(tempDir, "bundle.mjs");
+  await bundle(configPath, {
     cache: true,
     verbose: options.verbose,
-    silent: options.silent
+    silent: options.silent,
+    buildOverrides: {
+      output: tempPath,
+      format: "esm",
+      platform: "node"
+    }
   });
   return tempPath;
 }
@@ -2280,7 +2426,10 @@ function isPreBuiltConfig(configPath) {
 }
 
 // src/commands/run/execution.ts
+import { createLogger as createLogger2, Level } from "@walkeros/core";
 import { runFlow, runServeMode } from "@walkeros/docker";
+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": {
@@ -2291,7 +2440,7 @@ async function executeRunLocal(mode, flowPath, options) {
         port: options.port,
         host: options.host
       };
-      await runFlow(flowPath, config);
+      await runFlow(flowPath, config, logger.scope("runner"));
       break;
     }
     case "serve": {
@@ -2302,7 +2451,7 @@ async function executeRunLocal(mode, flowPath, options) {
         servePath: options.servePath,
         filePath: flowPath || void 0
       };
-      await runServeMode(config);
+      await runServeMode(config, logger.scope("serve"));
       break;
     }
     default:
@@ -2314,7 +2463,7 @@ async function executeRunLocal(mode, flowPath, options) {
 async function runCommand(mode, options) {
   const timer = createTimer();
   timer.start();
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   try {
     validateMode(mode);
     const configPath = validateFlowFile(options.config);
@@ -2325,31 +2474,31 @@ async function runCommand(mode, options) {
     let flowPath = null;
     if (mode === "collect") {
       if (isPreBuilt) {
-        flowPath = path10.resolve(configPath);
+        flowPath = path13.resolve(configPath);
         if (!options.json && !options.silent) {
-          logger.info(`\u{1F4E6} Using pre-built flow: ${path10.basename(flowPath)}`);
+          logger2.info(`\u{1F4E6} Using pre-built flow: ${path13.basename(flowPath)}`);
         }
       } else {
         if (!options.json && !options.silent) {
-          logger.info("\u{1F528} Building flow bundle...");
+          logger2.info("\u{1F528} Building flow bundle...");
         }
         flowPath = await prepareBundleForRun(configPath, {
           verbose: options.verbose,
           silent: options.json || options.silent
         });
         if (!options.json && !options.silent) {
-          logger.success("\u2705 Bundle ready");
+          logger2.success("\u2705 Bundle ready");
         }
       }
     }
     const executionMode = getExecutionMode(options);
     if (options.dryRun) {
       if (executionMode === "docker") {
-        logger.info(
+        logger2.info(
           `[DRY-RUN] Would execute in Docker: run ${mode} with runtime image`
         );
       } else {
-        logger.info(`[DRY-RUN] Would execute locally: run ${mode}`);
+        logger2.info(`[DRY-RUN] Would execute locally: run ${mode}`);
       }
       return;
     }
@@ -2361,7 +2510,7 @@ async function runCommand(mode, options) {
         );
       }
       if (!options.json && !options.silent) {
-        logger.info("\u{1F433} Executing in production runtime container...");
+        logger2.info("\u{1F433} Executing in production runtime container...");
       }
       await executeRunInDocker(mode, flowPath, {
         port: options.port,
@@ -2373,7 +2522,7 @@ async function runCommand(mode, options) {
     } else {
       if (!options.json && !options.silent) {
         const modeLabel = mode === "collect" ? "Collector" : "Server";
-        logger.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
+        logger2.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
       }
       await executeRunLocal(mode, flowPath, {
         port: options.port,
@@ -2394,8 +2543,8 @@ async function runCommand(mode, options) {
       };
       console.log(JSON.stringify(output, null, 2));
     } else {
-      logger.error("\u274C Run failed:");
-      logger.error(errorMessage);
+      logger2.error("\u274C Run failed:");
+      logger2.error(errorMessage);
     }
     process.exit(1);
   }
@@ -2416,7 +2565,7 @@ async function run(mode, options) {
     const isPreBuilt = isPreBuiltConfig(flowFile);
     let flowPath;
     if (isPreBuilt) {
-      flowPath = path10.resolve(flowFile);
+      flowPath = path13.resolve(flowFile);
     } else {
       flowPath = await prepareBundleForRun(flowFile, {
         verbose: options.verbose,
@@ -2444,22 +2593,60 @@ async function run(mode, options) {
   }
 }
 
+// src/commands/cache.ts
+import fs12 from "fs-extra";
+import path14 from "path";
+var CACHE_DIR = path14.join(".tmp", "cache");
+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").action(async (options) => {
+    if (options.packages) {
+      await fs12.remove(path14.join(CACHE_DIR, "packages"));
+      console.log("Package cache cleared");
+    } else if (options.builds) {
+      await fs12.remove(path14.join(CACHE_DIR, "builds"));
+      console.log("Build cache cleared");
+    } else {
+      await fs12.remove(CACHE_DIR);
+      console.log("All caches cleared");
+    }
+  });
+  cache.command("info").description("Show cache statistics").action(async () => {
+    const packagesDir = path14.join(CACHE_DIR, "packages");
+    const buildsDir = path14.join(CACHE_DIR, "builds");
+    const packageCount = await countEntries(packagesDir);
+    const buildCount = await countEntries(buildsDir);
+    console.log(`Cache directory: ${CACHE_DIR}`);
+    console.log(`Cached packages: ${packageCount}`);
+    console.log(`Cached builds: ${buildCount}`);
+  });
+}
+async function countEntries(dir) {
+  if (!await fs12.pathExists(dir)) return 0;
+  const entries = await fs12.readdir(dir);
+  return entries.length;
+}
+
 // src/index.ts
-var __filename = fileURLToPath3(import.meta.url);
+var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname(__filename);
 var packageJson = JSON.parse(
-  readFileSync2(join(__dirname, "../package.json"), "utf-8")
+  readFileSync(join(__dirname, "../package.json"), "utf-8")
 );
 var VERSION = packageJson.version;
 var program = new Command();
 program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version(VERSION);
-program.command("bundle [file]").description("Bundle NPM packages with custom code").option(
-  "-e, --env <name>",
-  "environment to build (for multi-environment configs)"
-).option("--all", "build all environments (for multi-environment 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("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+program.hook("preAction", (thisCommand, actionCommand) => {
+  const options = actionCommand.opts();
+  if (!options.silent && !options.json) {
+    console.log(`\u{1F680} walkerOS CLI v${VERSION}`);
+    console.log(`\u{1F433} Using Docker runtime: walkeros/docker:${DOCKER_VERSION2}`);
+  }
+});
+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("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
   await bundleCommand({
     config: file || "bundle.config.json",
-    env: options.env,
+    flow: options.flow,
     all: options.all,
     stats: options.stats,
     json: options.json,
@@ -2487,11 +2674,11 @@ program.command("simulate [file]").description("Simulate event processing and ca
 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("--env <name>", "Environment name (for multi-environment configs)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("-s, --silent", "Suppress output").option("--local", "Execute in local Node.js instead of Docker").action(async (file, options) => {
+).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").option("--local", "Execute in local Node.js instead of Docker").action(async (file, options) => {
   await pushCommand({
     config: file || "bundle.config.json",
     event: options.event,
-    env: options.env,
+    flow: options.flow,
     json: options.json,
     verbose: options.verbose,
     silent: options.silent,
@@ -2529,6 +2716,7 @@ runCmd.command("serve [file]").description(
     silent: options.silent
   });
 });
+registerCacheCommand(program);
 program.parse();
 export {
   bundle,