@walkeros/cli 4.0.0 → 4.1.0-next-1778155282668

package/dist/index.js

@@ -422,11 +422,11 @@ import path5 from "path";
 import fs3 from "fs-extra";
 async function resolveLocalPackage(packageName, localPath, configDir, logger) {
   const absolutePath = path5.isAbsolute(localPath) ? localPath : path5.resolve(configDir, localPath);
-  const stat = await fs3.stat(absolutePath).catch(() => null);
-  if (stat?.isFile()) {
+  const stat2 = await fs3.stat(absolutePath).catch(() => null);
+  if (stat2?.isFile()) {
     return { name: packageName, absolutePath, type: "file" };
   }
-  if (!stat) {
+  if (!stat2) {
     for (const ext of [".ts", ".mjs", ".js", ".json"]) {
       const withExt = absolutePath + ext;
       if (await fs3.pathExists(withExt)) {
@@ -437,7 +437,7 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger) {
       `Local package path not found: ${localPath} (resolved to ${absolutePath})`
     );
   }
-  if (stat.isDirectory()) {
+  if (stat2.isDirectory()) {
     const hasPkgJson = await fs3.pathExists(
       path5.join(absolutePath, "package.json")
     );
@@ -745,6 +745,49 @@ var init_package_path = __esm({
   }
 });
 
+// src/core/import-specifier.ts
+var toFileImportSpecifier;
+var init_import_specifier = __esm({
+  "src/core/import-specifier.ts"() {
+    "use strict";
+    toFileImportSpecifier = (absPath) => absPath.replace(/\\/g, "/");
+  }
+});
+
+// src/core/parse-component-ref.ts
+function isAllowedPrefix(value, allowed) {
+  return allowed.includes(value);
+}
+function parseComponentRef(input, options) {
+  const { allowed, messages = {} } = options;
+  const allowedList = allowed.join(" | ");
+  const parts = input.split(".");
+  if (parts.length < 2) {
+    const msg = messages.invalidFormat ? messages.invalidFormat(input) : `Invalid target "${input}". Expected <kind>.<name> where kind is ${allowedList}.`;
+    throw new Error(msg);
+  }
+  const prefix = parts[0];
+  const name = parts[1];
+  if (!name) {
+    const msg = messages.missingName ? messages.missingName(input, prefix) : `Invalid target "${input}". Missing name after "${prefix}."`;
+    throw new Error(msg);
+  }
+  if (!isAllowedPrefix(prefix, allowed)) {
+    const msg = messages.invalidPrefix ? messages.invalidPrefix(prefix) : `Invalid kind "${prefix}". Expected ${allowedList}.`;
+    throw new Error(msg);
+  }
+  return {
+    prefix,
+    name,
+    rest: parts.slice(2)
+  };
+}
+var init_parse_component_ref = __esm({
+  "src/core/parse-component-ref.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/index.ts
 var init_core = __esm({
   "src/core/index.ts"() {
@@ -763,6 +806,8 @@ var init_core = __esm({
     init_sse();
     init_event_validation();
     init_package_path();
+    init_import_specifier();
+    init_parse_component_ref();
   }
 });
 
@@ -828,7 +873,7 @@ var init_build_defaults = __esm({
     };
     DEFAULT_OUTPUT_PATHS = {
       web: "./dist/walker.js",
-      server: "./dist/bundle.mjs"
+      server: "./dist/flow.mjs"
     };
   }
 });
@@ -838,7 +883,8 @@ import path7 from "path";
 import fs6 from "fs-extra";
 import { getFlowSettings, getPlatform } from "@walkeros/core";
 function loadBundleConfig(rawConfig, options) {
-  const config = validateFlowConfig(rawConfig);
+  const sanitized = stripLegacyBundleExternal(rawConfig, options.logger);
+  const config = validateFlowConfig(sanitized);
   const availableFlows = getAvailableFlows(config);
   const flowName = resolveFlow(config, options.flowName, availableFlows);
   let flowSettings = getFlowSettings(config, flowName, { deferred: true });
@@ -852,8 +898,10 @@ function loadBundleConfig(rawConfig, options) {
     flowSettings = getFlowSettings(config, flowName);
   }
   const buildDefaults = getBuildDefaults(platform);
-  const packages = flowSettings.config?.bundle?.packages || {};
-  const overrides = flowSettings.config?.bundle?.overrides || {};
+  const bundle2 = flowSettings.config?.bundle;
+  const packages = bundle2?.packages ?? {};
+  const overrides = bundle2?.overrides ?? {};
+  const traceInclude = bundle2?.traceInclude;
   const output = options.buildOverrides?.output || getDefaultOutput(platform);
   const configDir = isUrl(options.configPath) ? process.cwd() : path7.dirname(options.configPath);
   let includes = config.include;
@@ -867,6 +915,7 @@ function loadBundleConfig(rawConfig, options) {
     ...buildDefaults,
     packages,
     overrides,
+    traceInclude,
     output,
     include: includes,
     configDir,
@@ -923,6 +972,38 @@ async function loadFlowConfig(configPath, options) {
   const rawConfig = await loadJsonConfig(configPath);
   return loadBundleConfig(rawConfig, { configPath, ...options });
 }
+function stripLegacyBundleExternal(rawConfig, logger) {
+  if (!isPlainObject(rawConfig)) return rawConfig;
+  const flows = rawConfig.flows;
+  if (!isPlainObject(flows)) return rawConfig;
+  let mutated = null;
+  for (const [flowName, flowValue] of Object.entries(flows)) {
+    if (!isPlainObject(flowValue)) continue;
+    const flowConfig = flowValue.config;
+    if (!isPlainObject(flowConfig)) continue;
+    const bundle2 = flowConfig.bundle;
+    if (!isPlainObject(bundle2)) continue;
+    if (!("external" in bundle2)) continue;
+    logger?.warn(
+      `flow.config.bundle.external is no longer supported; @walkeros/cli@4.x traces server bundles automatically. Remove it from flows.${flowName}.config.bundle.`
+    );
+    if (!mutated) {
+      mutated = {
+        ...rawConfig,
+        flows: { ...flows }
+      };
+    }
+    const mutatedFlows = mutated.flows;
+    const newBundle = { ...bundle2 };
+    delete newBundle.external;
+    const newConfig = { ...flowConfig, bundle: newBundle };
+    mutatedFlows[flowName] = { ...flowValue, config: newConfig };
+  }
+  return mutated ?? rawConfig;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 var DEFAULT_INCLUDE_FOLDER;
 var init_loader = __esm({
   "src/config/loader.ts"() {
@@ -1024,7 +1105,49 @@ var init_cache_utils = __esm({
 import pacote from "pacote";
 import path8 from "path";
 import fs7 from "fs-extra";
+import { readFile } from "fs/promises";
+import os2 from "os";
 import semver2 from "semver";
+async function loadNpmConfigForPacote(projectDir = process.cwd(), homeDir = os2.homedir()) {
+  const merged = {};
+  const sources = [
+    path8.join(homeDir, ".npmrc"),
+    path8.join(projectDir, ".npmrc")
+  ];
+  for (const file of sources) {
+    let content;
+    try {
+      content = await readFile(file, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+      const eq = line.indexOf("=");
+      if (eq < 0) continue;
+      const key = line.slice(0, eq).trim();
+      let value = line.slice(eq + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      value = value.replace(
+        /\$\{([^}]+)\}/g,
+        (match, v) => process.env[v] ?? match
+      );
+      merged[key] = value;
+    }
+  }
+  let registry = merged["registry"] ?? "https://registry.npmjs.org/";
+  if (!registry.endsWith("/")) registry = `${registry}/`;
+  for (const key of Object.keys(merged)) {
+    if (key.endsWith(":registry") && key.startsWith("@")) {
+      const v = merged[key];
+      if (!v.endsWith("/")) merged[key] = `${v}/`;
+    }
+  }
+  return { ...merged, registry, preferOnline: true };
+}
 async function withTimeout(promise, ms, errorMessage) {
   let timer;
   const timeout = new Promise((_, reject) => {
@@ -1048,7 +1171,7 @@ function getNestedPackageDirectory(baseDir, consumerName, nestedPackageName) {
     nestedPackageName
   );
 }
-async function collectAllSpecs(packages, logger, configDir, overrides = {}) {
+async function collectAllSpecs(packages, logger, configDir, overrides = {}, npmConfig = PACOTE_OPTS) {
   const allSpecs = /* @__PURE__ */ new Map();
   const visited = /* @__PURE__ */ new Set();
   const directLocalNames = new Set(
@@ -1137,7 +1260,7 @@ async function collectAllSpecs(packages, logger, configDir, overrides = {}) {
     let manifest;
     try {
       manifest = await withTimeout(
-        pacote.manifest(`${item.name}@${item.spec}`, PACOTE_OPTS),
+        pacote.manifest(`${item.name}@${item.spec}`, npmConfig),
         PACKAGE_DOWNLOAD_TIMEOUT_MS,
         `Manifest fetch timed out: ${item.name}@${item.spec}`
       );
@@ -1274,7 +1397,19 @@ function resolveVersionConflicts(allSpecs, logger) {
   }
   return { topLevel, nested: [...consolidatedMap.values()] };
 }
-async function downloadPackages(packages, targetDir, logger, useCache = true, configDir, tmpDir, overrides = {}) {
+async function downloadPackagesWithResolution(packages, targetDir, logger, useCache = true, configDir, tmpDir, overrides = {}, npmConfig = PACOTE_OPTS) {
+  return downloadPackagesImpl(
+    packages,
+    targetDir,
+    logger,
+    useCache,
+    configDir,
+    tmpDir,
+    overrides,
+    npmConfig
+  );
+}
+async function downloadPackagesImpl(packages, targetDir, logger, useCache, configDir, tmpDir, overrides, npmConfig) {
   const packagePaths = /* @__PURE__ */ new Map();
   const userSpecifiedPackages = new Set(packages.map((p) => p.name));
   validateNoDuplicatePackages(packages);
@@ -1283,9 +1418,11 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
     packages,
     logger,
     configDir,
-    overrides
+    overrides,
+    npmConfig
   );
-  const { topLevel, nested } = resolveVersionConflicts(allSpecs, logger);
+  const resolution = resolveVersionConflicts(allSpecs, logger);
+  const { topLevel, nested } = resolution;
   await fs7.ensureDir(targetDir);
   const localPackageMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
@@ -1328,7 +1465,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
       await withTimeout(
         pacote.extract(packageSpec, packageDir, {
-          ...PACOTE_OPTS,
+          ...npmConfig,
           cache: cacheDir
         }),
         PACKAGE_DOWNLOAD_TIMEOUT_MS,
@@ -1354,7 +1491,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
     if (!semver2.valid(nestedPkg.version)) {
       try {
         const manifest = await withTimeout(
-          pacote.manifest(resolvedSpec, PACOTE_OPTS),
+          pacote.manifest(resolvedSpec, npmConfig),
           PACKAGE_DOWNLOAD_TIMEOUT_MS,
           `Manifest fetch timed out: ${resolvedSpec}`
         );
@@ -1376,7 +1513,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
         const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
         await withTimeout(
           pacote.extract(resolvedSpec, nestedDir, {
-            ...PACOTE_OPTS,
+            ...npmConfig,
             cache: cacheDir
           }),
           PACKAGE_DOWNLOAD_TIMEOUT_MS,
@@ -1390,7 +1527,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       }
     }
   }
-  return packagePaths;
+  return { packagePaths, resolution };
 }
 async function getCachedPackagePath(pkg, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "packages");
@@ -1432,7 +1569,7 @@ var init_package_manager = __esm({
     init_tmp();
     PACKAGE_DOWNLOAD_TIMEOUT_MS = 6e4;
     PACOTE_OPTS = {
-      registry: "https://registry.npmjs.org",
+      registry: "https://registry.npmjs.org/",
       preferOnline: true,
       where: void 0
     };
@@ -1445,55 +1582,174 @@ var init_package_manager = __esm({
   }
 });
 
+// src/commands/bundle/nft-trace.ts
+import { nodeFileTrace } from "@vercel/nft";
+import * as path9 from "path";
+import * as fs8 from "fs/promises";
+import picomatch from "picomatch";
+async function traceAndCopy(opts) {
+  try {
+    await fs8.stat(opts.entry);
+  } catch {
+    throw new Error(
+      `nft-trace: entry file not found at '${opts.entry}'. Check the path or run 'walkeros bundle' from the directory containing your flow.json.`
+    );
+  }
+  const realBase = await fs8.realpath(opts.base);
+  const expandedExtras = await expandTraceIncludes(
+    opts.extraIncludes ?? [],
+    realBase
+  );
+  const entries = [opts.entry, ...expandedExtras];
+  const { fileList, reasons } = await nodeFileTrace(entries, {
+    base: realBase
+  });
+  const outDirReal = path9.resolve(opts.outDir);
+  let copied = 0;
+  for (const file of fileList) {
+    const reason = reasons.get(file);
+    if (reason?.ignored) continue;
+    const dst = path9.resolve(outDirReal, file);
+    if (!dst.startsWith(outDirReal + path9.sep) && dst !== outDirReal) {
+      throw new Error(
+        `nft-trace: traced file '${file}' resolves outside outDir. This usually means base is too narrow for a hoisted monorepo. Move base up to the workspace root or set traceInclude explicitly.`
+      );
+    }
+    const src = path9.join(realBase, file);
+    await fs8.mkdir(path9.dirname(dst), { recursive: true });
+    await fs8.copyFile(src, dst);
+    const s = await fs8.stat(src);
+    if (s.mode & 73) await fs8.chmod(dst, s.mode);
+    copied++;
+  }
+  return { fileList: Array.from(fileList), copied, reasons };
+}
+function assertDepsTraced(opts) {
+  const missing = opts.expectedPackages.filter((dep) => {
+    const expected = `node_modules/${dep}/package.json`;
+    return !opts.fileList.some((f) => f.endsWith(expected));
+  });
+  if (missing.length > 0) {
+    throw new Error(
+      `nft-trace: resolved packages missing from trace: ${missing.join(", ")}. Possible causes: hoisted monorepo symlinks outside base; nft per-release regression; dynamic require not statically traceable. Add specific paths to flow.<name>.config.bundle.traceInclude as a workaround.`
+    );
+  }
+}
+async function expandTraceIncludes(patterns, base) {
+  if (patterns.length === 0) return [];
+  const literals = [];
+  const globs = [];
+  for (const entry of patterns) {
+    if (GLOB_CHARS.test(entry)) globs.push(entry);
+    else literals.push(entry);
+  }
+  const resolvedLiterals = literals.map(
+    (p) => path9.isAbsolute(p) ? p : path9.resolve(base, p)
+  );
+  if (globs.length === 0) return resolvedLiterals;
+  const matchers = globs.map((g) => picomatch(g));
+  const matchedFiles = [];
+  await walkFiles(base, base, async (absFile, relFile) => {
+    const relPosix = relFile.split(path9.sep).join("/");
+    if (matchers.some((m) => m(relPosix))) {
+      matchedFiles.push(absFile);
+    }
+  });
+  return [...resolvedLiterals, ...matchedFiles];
+}
+async function walkFiles(root, dir, visit) {
+  let entries;
+  try {
+    entries = await fs8.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const abs = path9.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkFiles(root, abs, visit);
+    } else if (entry.isFile()) {
+      await visit(abs, path9.relative(root, abs));
+    }
+  }
+}
+var GLOB_CHARS;
+var init_nft_trace = __esm({
+  "src/commands/bundle/nft-trace.ts"() {
+    "use strict";
+    GLOB_CHARS = /[*?[\]{}]/;
+  }
+});
+
 // src/core/build-cache.ts
-import fs8 from "fs-extra";
-import path9 from "path";
+import fs9 from "fs-extra";
+import path10 from "path";
 import { getHashServer as getHashServer2 } from "@walkeros/server-core";
+function serializeKeyInputs(inputs) {
+  return JSON.stringify({
+    externals: [...inputs.externals].sort(),
+    platform: inputs.platform,
+    target: inputs.target,
+    nodeMajor: inputs.nodeMajor,
+    format: inputs.format,
+    minify: inputs.minify ?? false,
+    minifyOptions: inputs.minifyOptions ?? null,
+    windowCollector: inputs.windowCollector ?? null,
+    windowElb: inputs.windowElb ?? null,
+    versionsHash: inputs.versionsHash
+  });
+}
+async function computeCodeCacheKey(codeContent, inputs) {
+  const keyMaterial = `${codeContent}
+###
+${serializeKeyInputs(inputs)}`;
+  return getHashServer2(keyMaterial, 12);
+}
 async function getBuildCachePath(configContent, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "builds");
   const cacheKey = await getFlowSettingsCacheKey(configContent);
-  return path9.join(cacheDir, `${cacheKey}.js`);
+  return path10.join(cacheDir, `${cacheKey}.js`);
 }
 async function isBuildCached(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  return fs8.pathExists(cachePath);
+  return fs9.pathExists(cachePath);
 }
 async function cacheBuild(configContent, buildOutput, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  await fs8.ensureDir(path9.dirname(cachePath));
-  await fs8.writeFile(cachePath, buildOutput, "utf-8");
+  await fs9.ensureDir(path10.dirname(cachePath));
+  await fs9.writeFile(cachePath, buildOutput, "utf-8");
 }
 async function getCachedBuild(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  if (await fs8.pathExists(cachePath)) {
-    return await fs8.readFile(cachePath, "utf-8");
+  if (await fs9.pathExists(cachePath)) {
+    return await fs9.readFile(cachePath, "utf-8");
   }
   return null;
 }
-async function getCodeCachePath(codeContent, tmpDir) {
+async function getCodeCachePath(codeContent, tmpDir, inputs) {
   const cacheDir = getTmpPath(tmpDir, "cache", "code");
-  const cacheKey = await getHashServer2(codeContent, 12);
-  return path9.join(cacheDir, `${cacheKey}.js`);
+  const cacheKey = await computeCodeCacheKey(codeContent, inputs);
+  return path10.join(cacheDir, `${cacheKey}.js`);
 }
-async function cacheCode(codeContent, codeOutput, tmpDir) {
-  const cachePath = await getCodeCachePath(codeContent, tmpDir);
-  await fs8.ensureDir(path9.dirname(cachePath));
-  await fs8.writeFile(cachePath, codeOutput, "utf-8");
+async function cacheCode(codeContent, codeOutput, tmpDir, inputs) {
+  const cachePath = await getCodeCachePath(codeContent, tmpDir, inputs);
+  await fs9.ensureDir(path10.dirname(cachePath));
+  await fs9.writeFile(cachePath, codeOutput, "utf-8");
 }
-async function getCachedCode(codeContent, tmpDir) {
-  const cachePath = await getCodeCachePath(codeContent, tmpDir);
-  if (await fs8.pathExists(cachePath)) {
-    return fs8.readFile(cachePath, "utf-8");
+async function getCachedCode(codeContent, tmpDir, inputs) {
+  const cachePath = await getCodeCachePath(codeContent, tmpDir, inputs);
+  if (await fs9.pathExists(cachePath)) {
+    return fs9.readFile(cachePath, "utf-8");
   }
   return null;
 }
-async function ensureCodeOnDisk(codeContent, compiledCode, tmpDir) {
+async function ensureCodeOnDisk(codeContent, compiledCode, tmpDir, inputs) {
   const cacheDir = getTmpPath(tmpDir, "cache", "code");
-  const cacheKey = await getHashServer2(codeContent, 12);
-  const cachePath = path9.join(cacheDir, `${cacheKey}.mjs`);
-  if (!await fs8.pathExists(cachePath)) {
-    await fs8.ensureDir(path9.dirname(cachePath));
-    await fs8.writeFile(cachePath, compiledCode, "utf-8");
+  const cacheKey = await computeCodeCacheKey(codeContent, inputs);
+  const cachePath = path10.join(cacheDir, `${cacheKey}.mjs`);
+  if (!await fs9.pathExists(cachePath)) {
+    await fs9.ensureDir(path10.dirname(cachePath));
+    await fs9.writeFile(cachePath, compiledCode, "utf-8");
   }
   return cachePath;
 }
@@ -1509,9 +1765,10 @@ var init_build_cache = __esm({
 import crypto from "crypto";
 import esbuild from "esbuild";
 import { builtinModules } from "module";
-import path10 from "path";
-import fs9 from "fs-extra";
+import path11 from "path";
+import fs10 from "fs-extra";
 import { packageNameToVariable, ENV_MARKER_PREFIX } from "@walkeros/core";
+import { getHashServer as getHashServer3 } from "@walkeros/server-core";
 function isInlineCode(code) {
   return code !== null && typeof code === "object" && !Array.isArray(code) && "push" in code;
 }
@@ -1575,25 +1832,25 @@ function generateInlineCode(inline, config, env, chain, chainPropertyName, isDes
 }
 async function copyIncludes(includes, sourceDir, outputDir, logger) {
   for (const include of includes) {
-    const sourcePath = path10.resolve(sourceDir, include);
-    const folderName = path10.basename(include);
-    const destPath = path10.join(outputDir, folderName);
-    const resolvedOutput = path10.resolve(outputDir);
-    const resolvedSource = path10.resolve(sourcePath);
-    if (resolvedSource === resolvedOutput || resolvedOutput.startsWith(resolvedSource + path10.sep) || resolvedSource.startsWith(resolvedOutput + path10.sep)) {
+    const sourcePath = path11.resolve(sourceDir, include);
+    const folderName = path11.basename(include);
+    const destPath = path11.join(outputDir, folderName);
+    const resolvedOutput = path11.resolve(outputDir);
+    const resolvedSource = path11.resolve(sourcePath);
+    if (resolvedSource === resolvedOutput || resolvedOutput.startsWith(resolvedSource + path11.sep) || resolvedSource.startsWith(resolvedOutput + path11.sep)) {
       throw new Error(
         `Circular include detected: "${include}" resolves to "${resolvedSource}" which overlaps with output directory "${resolvedOutput}"`
       );
     }
-    if (await fs9.pathExists(sourcePath)) {
-      await fs9.copy(sourcePath, destPath);
+    if (await fs10.pathExists(sourcePath)) {
+      await fs10.copy(sourcePath, destPath);
       logger.debug(`Copied ${include} to output`);
     } else {
       logger.warn(`Include folder not found: ${include}`);
     }
   }
 }
-function generateCacheKeyContent(flowSettings, buildOptions) {
+function generateCacheKeyContent(flowSettings, buildOptions, versionsHash) {
   const configForCache = {
     flow: flowSettings,
     build: {
@@ -1601,7 +1858,8 @@ function generateCacheKeyContent(flowSettings, buildOptions) {
       // Exclude non-deterministic fields from cache key
       tempDir: void 0,
       output: void 0
-    }
+    },
+    versionsHash
   };
   return JSON.stringify(configForCache);
 }
@@ -1610,44 +1868,16 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
   const buildId = crypto.randomUUID();
   const TEMP_DIR = buildOptions.tempDir || getTmpPath(void 0, `walkeros-build-${buildId}`);
   const CACHE_DIR = buildOptions.tempDir || getTmpPath();
-  if (buildOptions.cache !== false) {
-    const configContent = generateCacheKeyContent(flowSettings, buildOptions);
-    const cached = await isBuildCached(configContent, CACHE_DIR);
-    if (cached) {
-      const cachedBuild = await getCachedBuild(configContent, CACHE_DIR);
-      if (cachedBuild) {
-        logger.debug("Using cached build");
-        const outputPath = path10.resolve(buildOptions.output);
-        await fs9.ensureDir(path10.dirname(outputPath));
-        await fs9.writeFile(outputPath, cachedBuild);
-        const stats = await fs9.stat(outputPath);
-        const sizeKB = (stats.size / 1024).toFixed(1);
-        logger.info(`Output: ${outputPath} (${sizeKB} KB, cached)`);
-        if (showStats) {
-          const stats2 = await fs9.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
-            })
-          );
-          const hasWildcardImports = /import\s+\*\s+as\s+\w+\s+from/.test(
-            buildOptions.code || ""
-          );
-          return {
-            totalSize: stats2.size,
-            packages: packageStats,
-            buildTime: Date.now() - bundleStartTime,
-            treeshakingEffective: !hasWildcardImports
-          };
-        }
-        return;
-      }
-    }
-  }
+  const npmConfig = await loadNpmConfigForPacote(
+    buildOptions.configDir ?? process.cwd()
+  );
+  const outputPath = path11.resolve(buildOptions.output);
+  const outputDirAbs = path11.dirname(outputPath);
+  await fs10.remove(path11.join(outputDirAbs, "node_modules"));
+  await fs10.remove(path11.join(outputDirAbs, "package.json"));
+  await fs10.remove(path11.join(outputDirAbs, "package-lock.json"));
   try {
-    await fs9.ensureDir(TEMP_DIR);
+    await fs10.ensureDir(TEMP_DIR);
     const hasSourcesOrDests = Object.keys(flowSettings.sources || {}).length > 0 || Object.keys(flowSettings.destinations || {}).length > 0;
     if (hasSourcesOrDests && !buildOptions.packages["@walkeros/collector"]) {
       buildOptions.packages["@walkeros/collector"] = {};
@@ -1691,7 +1921,7 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
         // Pass local path if defined
       })
     );
-    const packagePaths = await downloadPackages(
+    const { packagePaths, resolution: resolutionResult } = await downloadPackagesWithResolution(
       packagesArray,
       TEMP_DIR,
       logger,
@@ -1699,25 +1929,98 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       buildOptions.configDir,
       // For resolving relative local paths
       CACHE_DIR,
-      buildOptions.overrides
+      buildOptions.overrides,
+      npmConfig
     );
+    const warnedBundleFieldPackages = /* @__PURE__ */ new Set();
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
+      const pkgJsonPath = path11.join(pkgPath, "package.json");
+      let pkgJson;
+      try {
+        pkgJson = await fs10.readJSON(pkgJsonPath);
+      } catch {
+        continue;
+      }
+      const walkerOSBlock = pkgJson.walkerOS;
+      if (walkerOSBlock && typeof walkerOSBlock === "object" && !Array.isArray(walkerOSBlock)) {
+        const bundleField = walkerOSBlock.bundle;
+        if (bundleField && typeof bundleField === "object" && !Array.isArray(bundleField) && !warnedBundleFieldPackages.has(pkgName)) {
+          warnedBundleFieldPackages.add(pkgName);
+          const keys = Object.keys(bundleField).sort().join(", ");
+          logger.warn(
+            `walkeros: package ${pkgName} still declares walkerOS.bundle.${keys}; this is ignored in @walkeros/cli@4.x. Tell the package author to remove it.`
+          );
+        }
+      }
       if (pkgName.startsWith("@walkeros/")) {
-        const pkgJsonPath = path10.join(pkgPath, "package.json");
-        const pkgJson = await fs9.readJSON(pkgJsonPath);
-        if (!pkgJson.exports && pkgJson.module) {
+        const exportsField = pkgJson.exports;
+        const moduleField = pkgJson.module;
+        if (!exportsField && typeof moduleField === "string") {
           pkgJson.exports = {
             ".": {
-              import: pkgJson.module,
+              import: moduleField,
               require: pkgJson.main
             }
           };
-          await fs9.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs10.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+        }
+      }
+    }
+    const sortedVersions = [...resolutionResult.topLevel.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, p]) => `${name}@${p.version}`);
+    const versionsHash = await getHashServer3(sortedVersions.join("\n"), 12);
+    const expectedTopLevelPackages = Object.keys(buildOptions.packages).filter(
+      (name) => !name.startsWith(".") && !name.startsWith("/")
+    );
+    if (buildOptions.cache !== false) {
+      const configContent = generateCacheKeyContent(
+        flowSettings,
+        buildOptions,
+        versionsHash
+      );
+      const cached = await isBuildCached(configContent, CACHE_DIR);
+      if (cached) {
+        const cachedBuild = await getCachedBuild(configContent, CACHE_DIR);
+        if (cachedBuild) {
+          logger.debug("Using cached build");
+          await fs10.ensureDir(path11.dirname(outputPath));
+          await fs10.writeFile(outputPath, cachedBuild);
+          if (buildOptions.platform === "node") {
+            await runNftServerPath(
+              outputPath,
+              flowSettings,
+              buildOptions,
+              TEMP_DIR,
+              expectedTopLevelPackages,
+              logger
+            );
+          }
+          const stats2 = await fs10.stat(outputPath);
+          const sizeKB2 = (stats2.size / 1024).toFixed(1);
+          logger.info(`Output: ${outputPath} (${sizeKB2} KB, cached)`);
+          if (showStats) {
+            const packageStats = Object.entries(buildOptions.packages).map(
+              ([name, pkg]) => ({
+                name: `${name}@${pkg.version || "latest"}`,
+                size: 0
+                // Size estimation not available for cached builds
+              })
+            );
+            const hasWildcardImports = /import\s+\*\s+as\s+\w+\s+from/.test(
+              buildOptions.code || ""
+            );
+            return {
+              totalSize: stats2.size,
+              packages: packageStats,
+              buildTime: Date.now() - bundleStartTime,
+              treeshakingEffective: !hasWildcardImports
+            };
+          }
+          return;
         }
       }
     }
-    const packageJsonPath = path10.join(TEMP_DIR, "package.json");
-    await fs9.writeFile(
+    const packageJsonPath = path11.join(TEMP_DIR, "package.json");
+    await fs10.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
@@ -1727,11 +2030,22 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       buildOptions,
       packagePaths
     );
-    const outputPath = path10.resolve(buildOptions.output);
-    await fs9.ensureDir(path10.dirname(outputPath));
+    await fs10.ensureDir(path11.dirname(outputPath));
+    const codeKeyInputs = {
+      externals: /* @__PURE__ */ new Set(),
+      platform: buildOptions.platform === "node" ? "node" : "browser",
+      target: resolveTarget(buildOptions),
+      nodeMajor: parseInt(process.versions.node.split(".")[0], 10),
+      format: buildOptions.format,
+      minify: buildOptions.minify,
+      minifyOptions: buildOptions.minifyOptions,
+      windowCollector: buildOptions.windowCollector,
+      windowElb: buildOptions.windowElb,
+      versionsHash
+    };
     let compiledCode = null;
     if (buildOptions.cache !== false) {
-      compiledCode = await getCachedCode(codeEntry, CACHE_DIR);
+      compiledCode = await getCachedCode(codeEntry, CACHE_DIR, codeKeyInputs);
     }
     if (compiledCode) {
       logger.debug("Using cached compiled code (config-only change)");
@@ -1739,15 +2053,16 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       logger.debug(
         `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
       );
-      const entryPath = path10.join(TEMP_DIR, "entry.js");
-      await fs9.writeFile(entryPath, codeEntry);
+      const entryPath = path11.join(TEMP_DIR, "entry.js");
+      await fs10.writeFile(entryPath, codeEntry);
       const esbuildOptions = createEsbuildOptions(
         { ...buildOptions, minify: false },
         entryPath,
         outputPath,
         TEMP_DIR,
         packagePaths,
-        logger
+        logger,
+        expectedTopLevelPackages
       );
       try {
         await esbuild.build(esbuildOptions);
@@ -1759,15 +2074,16 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       } finally {
         await esbuild.stop();
       }
-      compiledCode = await fs9.readFile(outputPath, "utf-8");
+      compiledCode = await fs10.readFile(outputPath, "utf-8");
       if (buildOptions.cache !== false) {
-        await cacheCode(codeEntry, compiledCode, CACHE_DIR);
+        await cacheCode(codeEntry, compiledCode, CACHE_DIR, codeKeyInputs);
       }
     }
     const stage1Path = await ensureCodeOnDisk(
       codeEntry,
       compiledCode,
-      CACHE_DIR
+      CACHE_DIR,
+      codeKeyInputs
     );
     if (buildOptions.skipWrapper || !hasFlow) {
       const dataDeclaration = `const __configData = ${dataPayload};
@@ -1776,15 +2092,15 @@ export { __configData };`;
 ` : "";
       const esmOutput = `${banner}${compiledCode}
 ${dataDeclaration}`;
-      await fs9.writeFile(outputPath, esmOutput);
+      await fs10.writeFile(outputPath, esmOutput);
     } else {
       const stage2Entry = (buildOptions.platform || "node") === "browser" ? generateWebEntry(stage1Path, dataPayload, {
         windowCollector: buildOptions.windowCollector,
         windowElb: buildOptions.windowElb,
         platform: buildOptions.platform
       }) : generateServerEntry(stage1Path, dataPayload);
-      const stage2EntryPath = path10.join(TEMP_DIR, "stage2.mjs");
-      await fs9.writeFile(stage2EntryPath, stage2Entry);
+      const stage2EntryPath = path11.join(TEMP_DIR, "stage2.mjs");
+      await fs10.writeFile(stage2EntryPath, stage2Entry);
       const stage2Options = {
         entryPoints: [stage2EntryPath],
         bundle: true,
@@ -1807,13 +2123,16 @@ ${dataDeclaration}`;
           "process.env.NODE_ENV": '"production"',
           global: "globalThis"
         };
-        stage2Options.target = buildOptions.target || "es2018";
+        stage2Options.target = resolveTarget(buildOptions);
       } else {
-        stage2Options.external = getNodeExternals();
+        stage2Options.external = [
+          ...getNodeExternals(),
+          ...expectedTopLevelPackages
+        ];
         stage2Options.banner = {
           js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
         };
-        stage2Options.target = buildOptions.target || "node18";
+        stage2Options.target = resolveTarget(buildOptions);
       }
       try {
         await esbuild.build(stage2Options);
@@ -1821,16 +2140,30 @@ ${dataDeclaration}`;
         await esbuild.stop();
       }
     }
-    const outputStats = await fs9.stat(outputPath);
+    const outputStats = await fs10.stat(outputPath);
     const sizeKB = (outputStats.size / 1024).toFixed(1);
     const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
     logger.info(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
     if (buildOptions.cache !== false) {
-      const configContent = generateCacheKeyContent(flowSettings, buildOptions);
-      const buildOutput = await fs9.readFile(outputPath, "utf-8");
+      const configContent = generateCacheKeyContent(
+        flowSettings,
+        buildOptions,
+        versionsHash
+      );
+      const buildOutput = await fs10.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput, CACHE_DIR);
       logger.debug("Build cached for future use");
     }
+    if (buildOptions.platform === "node") {
+      await runNftServerPath(
+        outputPath,
+        flowSettings,
+        buildOptions,
+        TEMP_DIR,
+        expectedTopLevelPackages,
+        logger
+      );
+    }
     let stats;
     if (showStats) {
       stats = await collectBundleStats(
@@ -1841,7 +2174,7 @@ ${dataDeclaration}`;
       );
     }
     if (buildOptions.include && buildOptions.include.length > 0) {
-      const outputDir = path10.dirname(outputPath);
+      const outputDir = path11.dirname(outputPath);
       await copyIncludes(
         buildOptions.include,
         buildOptions.configDir || process.cwd(),
@@ -1854,13 +2187,13 @@ ${dataDeclaration}`;
     throw error;
   } finally {
     if (!buildOptions.tempDir) {
-      fs9.remove(TEMP_DIR).catch(() => {
+      fs10.remove(TEMP_DIR).catch(() => {
       });
     }
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs9.stat(outputPath);
+  const stats = await fs10.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1886,7 +2219,10 @@ async function collectBundleStats(outputPath, packages, startTime, entryContent)
     treeshakingEffective
   };
 }
-function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger) {
+function resolveTarget(buildOptions) {
+  return buildOptions.target ?? (buildOptions.platform === "node" ? "node18" : "es2018");
+}
+function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger, stepPackageExternals = []) {
   const alias = {};
   const baseOptions = {
     entryPoints: [entryPath],
@@ -1924,15 +2260,11 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
     baseOptions.external = buildOptions.external || [];
   } else if (buildOptions.platform === "node") {
     const nodeExternals = getNodeExternals();
-    baseOptions.external = buildOptions.external ? [...nodeExternals, ...buildOptions.external] : nodeExternals;
-  }
-  if (buildOptions.target) {
-    baseOptions.target = buildOptions.target;
-  } else if (buildOptions.platform === "node") {
-    baseOptions.target = "node18";
-  } else {
-    baseOptions.target = "es2018";
+    const externalsParts = [nodeExternals, stepPackageExternals];
+    if (buildOptions.external) externalsParts.push(buildOptions.external);
+    baseOptions.external = externalsParts.flat();
   }
+  baseOptions.target = resolveTarget(buildOptions);
   return baseOptions;
 }
 function detectStepPackages(flowSettings, section) {
@@ -1956,6 +2288,57 @@ function getNodeExternals() {
   }
   return externals;
 }
+async function runNftServerPath(outputPath, flowSettings, buildOptions, tempDir, expectedPackages, logger) {
+  const outDir = path11.dirname(outputPath);
+  const flowExtraIncludes = [
+    ...flowSettings.config?.bundle?.traceInclude ?? [],
+    ...buildOptions.traceInclude ?? []
+  ];
+  const stagedEntry = path11.join(tempDir, "__nft-flow.mjs");
+  await fs10.copyFile(outputPath, stagedEntry);
+  let result;
+  try {
+    result = await traceAndCopy({
+      entry: stagedEntry,
+      base: tempDir,
+      outDir,
+      extraIncludes: flowExtraIncludes
+    });
+  } finally {
+    await fs10.remove(stagedEntry).catch(() => {
+    });
+  }
+  const stagedRel = path11.relative(await fs10.realpath(tempDir), stagedEntry);
+  const trimmedFileList = result.fileList.filter((f) => f !== stagedRel);
+  await fs10.remove(path11.join(outDir, stagedRel)).catch(() => {
+  });
+  if (expectedPackages.length > 0) {
+    assertDepsTraced({
+      fileList: trimmedFileList,
+      expectedPackages
+    });
+  }
+  const stepPackages = collectAllStepPackages(flowSettings);
+  const dependencies = {};
+  for (const name of [...stepPackages].sort()) {
+    if (name.startsWith(".") || name.startsWith("/")) continue;
+    dependencies[name] = "*";
+  }
+  const sidecarPath = path11.join(outDir, "package.json");
+  await fs10.writeJson(
+    sidecarPath,
+    {
+      name: "walkeros-bundle",
+      private: true,
+      type: "module",
+      dependencies
+    },
+    { spaces: 2 }
+  );
+  logger.debug(
+    `nft-trace: copied ${result.copied} file(s); wrote ${sidecarPath}`
+  );
+}
 function collectAllStepPackages(flowSettings) {
   const allPackages = /* @__PURE__ */ new Set();
   const sections = [
@@ -2082,8 +2465,8 @@ async function generateImportStatements(packages, destinationPackages, sourcePac
       const localPath = packagePaths.get(packageName);
       if (!localPath) continue;
       try {
-        const pkgJsonPath = path10.join(localPath, "package.json");
-        const pkgJson = await fs9.readJSON(pkgJsonPath);
+        const pkgJsonPath = path11.join(localPath, "package.json");
+        const pkgJson = await fs10.readJSON(pkgJsonPath);
         const exports = pkgJson.exports;
         if (exports && typeof exports === "object" && "./dev" in exports) {
           const varName = `__dev_${packageNameToVariable(packageName)}`;
@@ -2369,7 +2752,8 @@ ${userCode}
 export { startFlow };`;
 }
 function generateServerEntry(stage1Path, dataPayload) {
-  return `import { startFlow, wireConfig } from '${stage1Path}';
+  const stage1Specifier = toFileImportSpecifier(stage1Path);
+  return `import { startFlow, wireConfig } from '${stage1Specifier}';
 
 const __configData = ${dataPayload};
 
@@ -2418,7 +2802,8 @@ function generateWebEntry(stage1Path, dataPayload, options = {}) {
       env.document = env.document ?? (typeof document !== 'undefined' ? document : undefined);
     }
   }` : "";
-  return `import { startFlow, wireConfig } from '${stage1Path}';
+  const stage1Specifier = toFileImportSpecifier(stage1Path);
+  return `import { startFlow, wireConfig } from '${stage1Specifier}';
 
 const __configData = ${dataPayload};
 
@@ -2505,7 +2890,8 @@ function generateWrapEntry(stage1Path, options = {}) {
       env.document = env.document ?? (typeof document !== 'undefined' ? document : undefined);
     }
   }` : "";
-  return `import { startFlow, wireConfig, __configData } from '${stage1Path}';
+  const stage1Specifier = toFileImportSpecifier(stage1Path);
+  return `import { startFlow, wireConfig, __configData } from '${stage1Specifier}';
 
 (async () => {${preflightBlock}
   const config = wireConfig(__configData);${envBlock}
@@ -2513,7 +2899,8 @@ function generateWrapEntry(stage1Path, options = {}) {
 })();`;
 }
 function generateWrapEntryServer(stage1Path) {
-  return `import { startFlow, wireConfig, __configData } from '${stage1Path}';
+  const stage1Specifier = toFileImportSpecifier(stage1Path);
+  return `import { startFlow, wireConfig, __configData } from '${stage1Specifier}';
 
 export default async function(context = {}) {
   const config = wireConfig(__configData);
@@ -2609,14 +2996,16 @@ var init_bundler = __esm({
     "use strict";
     init_config_classifier();
     init_package_manager();
+    init_nft_trace();
     init_tmp();
+    init_import_specifier();
     init_build_cache();
     VALID_JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
   }
 });
 
 // src/commands/bundle/targets.ts
-function resolveTarget(target) {
+function resolveTarget2(target) {
   const preset = BUNDLE_TARGETS[target];
   if (!preset) {
     throw new Error(
@@ -2665,12 +3054,12 @@ var init_targets = __esm({
 });
 
 // src/commands/bundle/upload.ts
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 function sanitizeUrl(url) {
   return url.split("?")[0];
 }
 async function uploadBundleToUrl(filePath, url, timeoutMs = 3e4) {
-  const bundleContent = await fs10.readFile(filePath);
+  const bundleContent = await fs11.readFile(filePath);
   const doUpload = async (attempt) => {
     const response = await fetch(url, {
       method: "PUT",
@@ -2727,50 +3116,17 @@ var init_stats = __esm({
   }
 });
 
-// src/commands/bundle/dockerfile.ts
-import path11 from "path";
-import fs11 from "fs-extra";
-function buildDockerfileContent(platform, includedFolders) {
-  const bundleFile = platform === "web" ? "walker.js" : "bundle.mjs";
-  const lines = [
-    "# Generated by walkeros CLI",
-    "FROM walkeros/flow:latest",
-    "",
-    `COPY ${bundleFile} /app/flow/${bundleFile}`
-  ];
-  for (const folder of includedFolders) {
-    const name = path11.basename(folder);
-    lines.push(`COPY ${name}/ /app/flow/${name}/`);
-  }
-  lines.push("", `ENV BUNDLE=/app/flow/${bundleFile}`, "", "EXPOSE 8080", "");
-  return lines.join("\n");
-}
-async function generateDockerfile(outputDir, platform, logger, customFile, includedFolders) {
-  const destPath = path11.join(outputDir, "Dockerfile");
-  if (customFile && await fs11.pathExists(customFile)) {
-    await fs11.copy(customFile, destPath);
-    logger.info(`Dockerfile: ${destPath} (copied from ${customFile})`);
-    return;
-  }
-  const dockerfile = buildDockerfileContent(platform, includedFolders || []);
-  await fs11.writeFile(destPath, dockerfile);
-  logger.info(`Dockerfile: ${destPath}`);
-}
-var init_dockerfile = __esm({
-  "src/commands/bundle/dockerfile.ts"() {
-    "use strict";
-  }
-});
-
 // src/commands/bundle/index.ts
 import path12 from "path";
 import fs12 from "fs-extra";
-import { getPlatform as getPlatform2 } from "@walkeros/core";
-function resolveOutputPath(output, buildOptions) {
+function resolveOutputPath(output, buildOptions, flowSubdir) {
   const resolved = path12.resolve(output);
+  const filename = buildOptions.platform === "browser" ? "walker.js" : "flow.mjs";
+  if (flowSubdir) {
+    return path12.join(resolved, flowSubdir, filename);
+  }
   const ext = path12.extname(resolved);
   if (output.endsWith("/") || output.endsWith(path12.sep) || !ext) {
-    const filename = buildOptions.platform === "browser" ? "walker.js" : "bundle.mjs";
     return path12.join(resolved, filename);
   }
   return resolved;
@@ -2834,7 +3190,11 @@ async function bundleCommand(options) {
             `url-bundle-${Date.now()}${ext}`
           );
         } else if (options.output) {
-          buildOptions.output = resolveOutputPath(options.output, buildOptions);
+          buildOptions.output = resolveOutputPath(
+            options.output,
+            buildOptions,
+            options.all ? flowName : void 0
+          );
         } else {
           const ext = buildOptions.platform === "browser" ? ".js" : ".mjs";
           buildOptions.output = getTmpPath(void 0, "stdout-bundle" + ext);
@@ -2864,26 +3224,12 @@ async function bundleCommand(options) {
           const bundleContent = await fs12.readFile(buildOptions.output);
           await writeResult(bundleContent, {});
           if (process.stdout.isTTY) {
-            const defaultPath = buildOptions.platform === "browser" ? "./dist/walker.js" : "./dist/bundle.mjs";
+            const defaultPath = buildOptions.platform === "browser" ? "./dist/walker.js" : "./dist/flow.mjs";
             logger.info(
               `Bundle written to stdout. Use -o ${defaultPath} to write to file.`
             );
           }
         }
-        if (options.dockerfile && options.output) {
-          const platform = getPlatform2(flowSettings);
-          if (platform) {
-            const outputDir = path12.dirname(buildOptions.output);
-            const customFile = typeof options.dockerfile === "string" ? options.dockerfile : void 0;
-            await generateDockerfile(
-              outputDir,
-              platform,
-              logger,
-              customFile,
-              buildOptions.include
-            );
-          }
-        }
       } catch (error) {
         const errorMessage = getErrorMessage(error);
         results.push({ flowName, success: false, error: errorMessage });
@@ -2951,7 +3297,7 @@ async function bundle(configOrPath, options = {}) {
   } else {
     effectiveTarget = "cdn";
   }
-  const preset = resolveTarget(effectiveTarget);
+  const preset = resolveTarget2(effectiveTarget);
   if (options.buildOverrides?.skipWrapper !== void 0 && !options.target && process.env.WALKEROS_SUPPRESS_DEPRECATIONS !== "1") {
     console.warn(
       "[@walkeros/cli] buildOverrides.skipWrapper is deprecated. Pass `target: 'cdn' | 'cdn-skeleton' | 'runner' | 'simulate' | 'push'` instead. Set WALKEROS_SUPPRESS_DEPRECATIONS=1 to silence this warning."
@@ -2997,7 +3343,6 @@ var init_bundle = __esm({
     init_targets();
     init_upload();
     init_stats();
-    init_dockerfile();
   }
 });
 
@@ -3015,18 +3360,18 @@ import {
   writeFileSync as writeFileSync3,
   readFileSync as readFileSync2
 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function writeCache(cacheDir, bundlePath, configContent, version) {
   mkdirSync3(cacheDir, { recursive: true });
-  copyFileSync(bundlePath, join2(cacheDir, "bundle.mjs"));
-  writeFileSync3(join2(cacheDir, "config.json"), configContent, "utf-8");
+  copyFileSync(bundlePath, join3(cacheDir, "flow.mjs"));
+  writeFileSync3(join3(cacheDir, "config.json"), configContent, "utf-8");
   const meta = { version, timestamp: Date.now() };
-  writeFileSync3(join2(cacheDir, "meta.json"), JSON.stringify(meta), "utf-8");
+  writeFileSync3(join3(cacheDir, "meta.json"), JSON.stringify(meta), "utf-8");
 }
 function readCache(cacheDir) {
   try {
-    const metaPath = join2(cacheDir, "meta.json");
-    const bundlePath = join2(cacheDir, "bundle.mjs");
+    const metaPath = join3(cacheDir, "meta.json");
+    const bundlePath = join3(cacheDir, "flow.mjs");
     if (!existsSync3(metaPath) || !existsSync3(bundlePath)) return null;
     const meta = JSON.parse(readFileSync2(metaPath, "utf-8"));
     return { bundlePath, version: meta.version };
@@ -3036,7 +3381,7 @@ function readCache(cacheDir) {
 }
 function readCacheConfig(cacheDir) {
   try {
-    const configPath = join2(cacheDir, "config.json");
+    const configPath = join3(cacheDir, "config.json");
     if (!existsSync3(configPath)) return null;
     return readFileSync2(configPath, "utf-8");
   } catch {
@@ -3063,7 +3408,7 @@ async function prepareBundleForRun(configPath, options) {
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   await fs15.ensureDir(tempDir);
-  const tempPath = path16.join(tempDir, "bundle.mjs");
+  const tempPath = path16.join(tempDir, "flow.mjs");
   await bundle(configPath, {
     cache: true,
     verbose: options.verbose,
@@ -3107,7 +3452,7 @@ import path15 from "path";
 import fs14 from "fs-extra";
 import {
   createIngest,
-  getPlatform as getPlatform4,
+  getPlatform as getPlatform3,
   compileNext,
   resolveNext,
   isRouteArray,
@@ -3123,6 +3468,8 @@ import {
 } from "@walkeros/collector";
 
 // src/commands/push/overrides.ts
+init_parse_component_ref();
+var STEP_KINDS = ["source", "destination", "transformer"];
 function buildOverrides(flags, flowConfig) {
   const simulateFlags = flags.simulate ?? [];
   const mockFlags = flags.mock ?? [];
@@ -3217,32 +3564,22 @@ function buildOverrides(flags, flowConfig) {
   return overrides;
 }
 function parseStep(step) {
-  const parts = step.split(".");
-  if (parts.length < 2) {
-    throw new Error(
-      `Invalid step format: "${step}". Expected "source.NAME" or "destination.NAME"`
-    );
-  }
-  const prefix = parts[0];
-  if (prefix !== "source" && prefix !== "destination" && prefix !== "transformer") {
-    throw new Error(
-      `Unsupported step type: "${prefix}". Use "source", "destination", or "transformer"`
-    );
-  }
-  const name = parts[1];
-  if (!name) {
-    throw new Error(
-      `Invalid step format: "${step}". Missing name after "${prefix}."`
-    );
-  }
-  if (parts.length >= 4) {
-    const chainType = parts[2];
+  const { prefix, name, rest } = parseComponentRef(step, {
+    allowed: STEP_KINDS,
+    messages: {
+      invalidFormat: (input) => `Invalid step format: "${input}". Expected "source.NAME" or "destination.NAME"`,
+      invalidPrefix: (p) => `Unsupported step type: "${p}". Use "source", "destination", or "transformer"`,
+      missingName: (input, p) => `Invalid step format: "${input}". Missing name after "${p}."`
+    }
+  });
+  if (rest.length >= 2) {
+    const chainType = rest[0];
     if (chainType !== "before" && chainType !== "next") {
       throw new Error(
         `Invalid chain type: "${chainType}". Use "before" or "next"`
       );
     }
-    const transformerId = parts[3];
+    const transformerId = rest[1];
     if (!transformerId) {
       throw new Error(
         `Invalid step format: "${step}". Missing transformer name after "${chainType}."`
@@ -3250,7 +3587,7 @@ function parseStep(step) {
     }
     return { type: prefix, name, chainType, transformerId };
   }
-  if (parts.length === 3) {
+  if (rest.length === 1) {
     throw new Error(
       `Invalid step format: "${step}". Specify a transformer: "${step}.TRANSFORMER_NAME"`
     );
@@ -3358,7 +3695,7 @@ function installTimerInterception(options = {}) {
   if (options.domWindow && options.domWindow !== globalThis) {
     patchTarget(options.domWindow);
   }
-  const drainMicrotasks = () => new Promise((resolve4) => realSetTimeout(resolve4, 0));
+  const drainMicrotasks = () => new Promise((resolve5) => realSetTimeout(resolve5, 0));
   async function flush(wallTimeout = 5e3) {
     const deadline = Date.now() + wallTimeout;
     const maxIterations = 100;
@@ -3614,7 +3951,7 @@ init_config();
 init_bundler();
 import path14 from "path";
 import fs13 from "fs-extra";
-import { getPlatform as getPlatform3 } from "@walkeros/core";
+import { getPlatform as getPlatform2 } from "@walkeros/core";
 async function prepareFlow(input) {
   const logger = createCLILogger({
     silent: input.silent,
@@ -3625,7 +3962,7 @@ async function prepareFlow(input) {
     configPath: process.cwd(),
     flowName: input.flow
   });
-  const platform = getPlatform3(flowSettings);
+  const platform = getPlatform2(flowSettings);
   const overrides = buildOverrides(
     { simulate: input.simulate, mock: input.mock },
     flowSettings
@@ -3646,7 +3983,7 @@ async function prepareFlow(input) {
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   await fs13.ensureDir(tempDir);
-  const bundlePath = path14.join(tempDir, "bundle.mjs");
+  const bundlePath = path14.join(tempDir, "flow.mjs");
   const pushBuildOptions = {
     ...buildOptions,
     output: bundlePath,
@@ -3945,7 +4282,7 @@ async function executeConfigPush(options, validatedEvent, logger, setTempDir, sn
     flowName: options.flow,
     logger
   });
-  const platform = getPlatform4(flowSettings);
+  const platform = getPlatform3(flowSettings);
   const overrides = buildOverrides({ mock: options.mock }, flowSettings);
   logger.debug("Bundling flow configuration");
   const tempDir = getTmpPath(
@@ -3954,7 +4291,7 @@ async function executeConfigPush(options, validatedEvent, logger, setTempDir, sn
   );
   setTempDir(tempDir);
   await fs14.ensureDir(tempDir);
-  const tempPath = path15.join(tempDir, "bundle.mjs");
+  const tempPath = path15.join(tempDir, "flow.mjs");
   const pushBuildOptions = {
     ...buildOptions,
     output: tempPath,
@@ -3985,7 +4322,7 @@ async function executeBundlePush(bundleContent, platform, validatedEvent, logger
   );
   setTempDir(tempDir);
   await fs14.ensureDir(tempDir);
-  const tempPath = path15.join(tempDir, "bundle.mjs");
+  const tempPath = path15.join(tempDir, "flow.mjs");
   await fs14.writeFile(tempPath, bundleContent, "utf8");
   logger.debug(`Bundle written to: ${tempPath}`);
   logger.debug(
@@ -4417,21 +4754,21 @@ init_auth();
 import path17 from "path";
 import { writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/runtime/resolve-bundle.ts
 init_stdin();
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 function getDefaultWritePath() {
-  if (existsSync2("/app/flow")) return "/app/flow/bundle.mjs";
-  return "/tmp/walkeros-bundle.mjs";
+  if (existsSync2("/app/flow")) return "/app/flow/flow.mjs";
+  return "/tmp/walkeros-flow.mjs";
 }
 function isUrl2(value) {
   return value.startsWith("http://") || value.startsWith("https://");
 }
 function writeBundleToDisk(writePath, content) {
-  const dir = dirname(writePath);
+  const dir = dirname2(writePath);
   if (!existsSync2(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
@@ -4665,7 +5002,7 @@ import fs16 from "fs-extra";
 // src/runtime/health-server.ts
 import http from "http";
 function createHealthServer(port, logger) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let flowHandler = null;
     const server = http.createServer((req, res) => {
       if (req.url === "/health" && req.method === "GET") {
@@ -4692,7 +5029,7 @@ function createHealthServer(port, logger) {
     server.headersTimeout = 1e4;
     server.listen(port, "0.0.0.0", () => {
       logger.info(`Health server listening on port ${port}`);
-      resolve4({
+      resolve5({
         server,
         setFlowHandler(handler) {
           flowHandler = handler;
@@ -4707,13 +5044,13 @@ function createHealthServer(port, logger) {
 }
 
 // src/runtime/runner.ts
-import { resolve as resolve2, dirname as dirname2 } from "path";
+import { resolve as resolve3, dirname as dirname3 } from "path";
 
 // src/runtime/load-bundle.ts
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function loadBundle(file, context2, logger) {
-  const absolutePath = resolve(file);
+  const absolutePath = resolve2(file);
   const fileUrl = pathToFileURL2(absolutePath).href;
   logger?.debug?.(`Importing bundle: ${absolutePath}`);
   const module = await import(`${fileUrl}?t=${Date.now()}`);
@@ -4737,8 +5074,8 @@ async function loadBundle(file, context2, logger) {
 
 // src/runtime/runner.ts
 async function loadFlow(file, config, logger, loggerConfig, healthServer) {
-  const absolutePath = resolve2(file);
-  const flowDir = dirname2(absolutePath);
+  const absolutePath = resolve3(file);
+  const flowDir = dirname3(absolutePath);
   process.chdir(flowDir);
   const flowContext = {
     ...config,
@@ -4787,14 +5124,14 @@ import { randomBytes } from "crypto";
 // src/version.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname4, join as join4 } from "path";
 var versionFilename = fileURLToPath(import.meta.url);
-var versionDirname = dirname3(versionFilename);
+var versionDirname = dirname4(versionFilename);
 function findPackageJson() {
   const paths = [
-    join3(versionDirname, "../package.json"),
+    join4(versionDirname, "../package.json"),
     // dist/ or src/
-    join3(versionDirname, "../../package.json")
+    join4(versionDirname, "../../package.json")
     // src/core/ (not used, but safe)
   ];
   for (const p of paths) {
@@ -5156,8 +5493,8 @@ async function injectSecrets(api, logger) {
 // src/commands/run/index.ts
 function defaultCacheDir() {
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join4(homedir2(), ".cache");
-  return join4(base, "walkeros");
+  const base = xdgCache || join5(homedir2(), ".cache");
+  return join5(base, "walkeros");
 }
 async function lazyPrepareBundleForRun(configPath, options) {
   const { prepareBundleForRun: prepareBundleForRun2 } = await Promise.resolve().then(() => (init_utils3(), utils_exports));
@@ -5871,7 +6208,7 @@ function validateMapping(input) {
 // src/commands/validate/validators/entry.ts
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
-var CLIENT_HEADER = "walkeros-cli/4.0.0";
+var CLIENT_HEADER = "walkeros-cli/4.1.0-next-1778155282668";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path19, flowConfig) {
   const flows = flowConfig.flows;
@@ -7018,7 +7355,7 @@ async function getDeploymentCommand(flowId, options) {
 // src/commands/deployments/index.ts
 init_auth();
 init_http();
-import { getPlatform as getPlatform5 } from "@walkeros/core";
+import { getPlatform as getPlatform4 } from "@walkeros/core";
 init_cli_logger();
 init_output();
 init_loader();
@@ -7187,7 +7524,7 @@ async function createDeployCommand(config, options) {
       const result2 = await loadFlowConfig(config, {
         flowName: options.flow
       });
-      type = getPlatform5(result2.flowSettings);
+      type = getPlatform4(result2.flowSettings);
     }
     const deployment = await createDeployment({
       type,
@@ -7284,14 +7621,14 @@ async function feedbackCommand(text) {
   }
 }
 function promptUser(question) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stderr
     });
     rl.question(question, (answer) => {
       rl.close();
-      resolve4(answer);
+      resolve5(answer);
     });
   });
 }
@@ -7373,7 +7710,7 @@ init_bundle();
 // src/commands/bundle/wrap.ts
 init_bundler();
 import * as path18 from "path";
-import * as os2 from "os";
+import * as os3 from "os";
 import fs17 from "fs-extra";
 import * as esbuild2 from "esbuild";
 async function wrapSkeleton(options) {
@@ -7408,8 +7745,8 @@ async function wrapSkeleton(options) {
     ...options.previewScope ? { previewScope: options.previewScope } : {},
     platform
   }) : generateWrapEntryServer(absoluteSkeletonPath);
-  const entryDir = await fs17.mkdtemp(path18.join(os2.tmpdir(), "walkeros-wrap-"));
-  const entryPath = path18.join(entryDir, "entry.mjs");
+  const entryDir = await fs17.mkdtemp(path18.join(os3.tmpdir(), "walkeros-wrap-"));
+  const entryPath = path18.join(entryDir, "flow.mjs");
   try {
     await fs17.writeFile(entryPath, entryText);
     await fs17.ensureDir(path18.dirname(outputPath));
@@ -7671,12 +8008,12 @@ function buildInitConfig(input) {
 }
 
 // src/telemetry/environment.ts
-import * as os3 from "os";
+import * as os4 from "os";
 function getEnvironment() {
   const locale = Intl.DateTimeFormat().resolvedOptions();
   return {
     os: process.platform,
-    osVersion: os3.release(),
+    osVersion: os4.release(),
     node: process.version,
     language: locale.locale,
     timezone: locale.timeZone