@walkeros/cli 3.2.0 → 3.3.0-next-1776113011459

package/dist/index.js

@@ -326,37 +326,16 @@ var init_utils = __esm({
 });
 
 // src/core/asset-resolver.ts
-import { fileURLToPath } from "url";
-import { existsSync as existsSync2 } from "fs";
 import path4 from "path";
-function getAssetDir() {
-  if (cachedAssetDir) return cachedAssetDir;
-  const currentFile = fileURLToPath(import.meta.url);
-  let dir = path4.dirname(currentFile);
-  while (dir !== path4.dirname(dir)) {
-    if (existsSync2(path4.join(dir, "examples"))) {
-      cachedAssetDir = dir;
-      return dir;
-    }
-    dir = path4.dirname(dir);
-  }
-  cachedAssetDir = path4.dirname(currentFile);
-  return cachedAssetDir;
-}
 function resolveAsset(assetPath, assetType, baseDir) {
   if (isUrl(assetPath)) {
     return assetPath;
   }
-  if (!assetPath.includes("/") && !assetPath.includes("\\")) {
-    const assetDir = getAssetDir();
-    return path4.join(assetDir, "examples", assetPath);
-  }
   if (path4.isAbsolute(assetPath)) {
     return assetPath;
   }
   return path4.resolve(baseDir || process.cwd(), assetPath);
 }
-var cachedAssetDir;
 var init_asset_resolver = __esm({
   "src/core/asset-resolver.ts"() {
     "use strict";
@@ -693,29 +672,6 @@ var init_event_validation = __esm({
 });
 
 // src/core/package-path.ts
-import fs6 from "fs";
-import path7 from "path";
-function resolvePackageImportPath(packageName, packages, configDir, subpath) {
-  const entry = packages?.[packageName];
-  if (entry?.path) {
-    const resolved = path7.isAbsolute(entry.path) ? entry.path : path7.resolve(configDir, entry.path);
-    if (!subpath) return resolved;
-    try {
-      const pkgJson = JSON.parse(
-        fs6.readFileSync(path7.join(resolved, "package.json"), "utf8")
-      );
-      const exportKey = `.${subpath.startsWith("/") ? subpath : `/${subpath}`}`;
-      const exp = pkgJson.exports?.[exportKey];
-      if (exp) {
-        const target = typeof exp === "string" ? exp : exp.import || exp.require || exp.default;
-        if (target) return path7.join(resolved, target);
-      }
-    } catch {
-    }
-    return path7.join(resolved, subpath.replace(/^\//, ""));
-  }
-  return subpath ? `${packageName}${subpath}` : packageName;
-}
 var init_package_path = __esm({
   "src/core/package-path.ts"() {
     "use strict";
@@ -805,8 +761,8 @@ var init_build_defaults = __esm({
 });
 
 // src/config/loader.ts
-import path8 from "path";
-import fs7 from "fs-extra";
+import path7 from "path";
+import fs6 from "fs-extra";
 import { getFlowSettings, getPlatform } from "@walkeros/core";
 function loadBundleConfig(rawConfig, options) {
   const config = validateFlowConfig(rawConfig);
@@ -823,19 +779,21 @@ function loadBundleConfig(rawConfig, options) {
     flowSettings = getFlowSettings(config, flowName);
   }
   const buildDefaults = getBuildDefaults(platform);
-  const packages = flowSettings.packages || {};
+  const packages = flowSettings.bundle?.packages || {};
+  const overrides = flowSettings.bundle?.overrides || {};
   const output = options.buildOverrides?.output || getDefaultOutput(platform);
-  const configDir = isUrl(options.configPath) ? process.cwd() : path8.dirname(options.configPath);
+  const configDir = isUrl(options.configPath) ? process.cwd() : path7.dirname(options.configPath);
   let includes = config.include;
   if (!includes) {
-    const defaultIncludePath = path8.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
-    if (fs7.pathExistsSync(defaultIncludePath)) {
+    const defaultIncludePath = path7.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
+    if (fs6.pathExistsSync(defaultIncludePath)) {
       includes = [DEFAULT_INCLUDE_FOLDER];
     }
   }
   const buildOptions = {
     ...buildDefaults,
     packages,
+    overrides,
     output,
     include: includes,
     configDir,
@@ -991,8 +949,8 @@ var init_cache_utils = __esm({
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
-import path9 from "path";
-import fs8 from "fs-extra";
+import path8 from "path";
+import fs7 from "fs-extra";
 import semver2 from "semver";
 async function withTimeout(promise, ms, errorMessage) {
   let timer;
@@ -1006,11 +964,43 @@ async function withTimeout(promise, ms, errorMessage) {
   }
 }
 function getPackageDirectory(baseDir, packageName) {
-  return path9.join(baseDir, "node_modules", packageName);
+  return path8.join(baseDir, "node_modules", packageName);
+}
+function getNestedPackageDirectory(baseDir, consumerName, nestedPackageName) {
+  return path8.join(
+    baseDir,
+    "node_modules",
+    consumerName,
+    "node_modules",
+    nestedPackageName
+  );
 }
-async function collectAllSpecs(packages, logger, configDir) {
+async function collectAllSpecs(packages, logger, configDir, overrides = {}) {
   const allSpecs = /* @__PURE__ */ new Map();
   const visited = /* @__PURE__ */ new Set();
+  const directLocalNames = new Set(
+    packages.filter((p2) => p2.path).map((p2) => p2.name)
+  );
+  for (const overrideName of Object.keys(overrides)) {
+    if (directLocalNames.has(overrideName)) {
+      logger.warn(
+        `Override for ${overrideName} ignored \u2014 direct package is a local path`
+      );
+    }
+  }
+  const substituteDep = (depName, depSpec, source, from, optional) => {
+    const overrideSpec = overrides[depName];
+    if (overrideSpec) {
+      return {
+        name: depName,
+        spec: overrideSpec,
+        source: "override",
+        from: `override (was ${depSpec} from ${from})`,
+        optional
+      };
+    }
+    return { name: depName, spec: depSpec, source, from, optional };
+  };
   const queue = packages.map((pkg) => ({
     name: pkg.name,
     spec: pkg.version,
@@ -1033,22 +1023,18 @@ async function collectAllSpecs(packages, logger, configDir) {
       localPath: item.localPath
     });
     if (item.localPath) {
-      const resolvedPath = path9.isAbsolute(item.localPath) ? item.localPath : path9.resolve(configDir || process.cwd(), item.localPath);
-      const candidatePath = path9.join(resolvedPath, "package.json");
-      const hasPkgJson = await fs8.pathExists(candidatePath);
+      const resolvedPath = path8.isAbsolute(item.localPath) ? item.localPath : path8.resolve(configDir || process.cwd(), item.localPath);
+      const candidatePath = path8.join(resolvedPath, "package.json");
+      const hasPkgJson = await fs7.pathExists(candidatePath);
       if (hasPkgJson) {
         try {
-          const pkgJson = await fs8.readJson(candidatePath);
+          const pkgJson = await fs7.readJson(candidatePath);
           const deps2 = pkgJson.dependencies || {};
           for (const [depName, depSpec] of Object.entries(deps2)) {
             if (typeof depSpec === "string") {
-              queue.push({
-                name: depName,
-                spec: depSpec,
-                source: "dependency",
-                from: item.name,
-                optional: false
-              });
+              queue.push(
+                substituteDep(depName, depSpec, "dependency", item.name, false)
+              );
             }
           }
           const peerDeps2 = pkgJson.peerDependencies || {};
@@ -1056,13 +1042,15 @@ async function collectAllSpecs(packages, logger, configDir) {
           for (const [depName, depSpec] of Object.entries(peerDeps2)) {
             if (typeof depSpec === "string") {
               const isOptional = peerMeta2[depName]?.optional === true;
-              queue.push({
-                name: depName,
-                spec: depSpec,
-                source: "peerDependency",
-                from: item.name,
-                optional: isOptional
-              });
+              queue.push(
+                substituteDep(
+                  depName,
+                  depSpec,
+                  "peerDependency",
+                  item.name,
+                  isOptional
+                )
+              );
             }
           }
         } catch (error) {
@@ -1090,13 +1078,9 @@ async function collectAllSpecs(packages, logger, configDir) {
     const deps = m2.dependencies || {};
     for (const [depName, depSpec] of Object.entries(deps)) {
       if (typeof depSpec === "string") {
-        queue.push({
-          name: depName,
-          spec: depSpec,
-          source: "dependency",
-          from: item.name,
-          optional: false
-        });
+        queue.push(
+          substituteDep(depName, depSpec, "dependency", item.name, false)
+        );
       }
     }
     const peerDeps = m2.peerDependencies || {};
@@ -1104,24 +1088,27 @@ async function collectAllSpecs(packages, logger, configDir) {
     for (const [depName, depSpec] of Object.entries(peerDeps)) {
       if (typeof depSpec === "string") {
         const isOptional = peerMeta[depName]?.optional === true;
-        queue.push({
-          name: depName,
-          spec: depSpec,
-          source: "peerDependency",
-          from: item.name,
-          optional: isOptional
-        });
+        queue.push(
+          substituteDep(
+            depName,
+            depSpec,
+            "peerDependency",
+            item.name,
+            isOptional
+          )
+        );
       }
     }
   }
   return allSpecs;
 }
 function resolveVersionConflicts(allSpecs, logger) {
-  const resolved = /* @__PURE__ */ new Map();
+  const topLevel = /* @__PURE__ */ new Map();
+  const nested = [];
   for (const [name, specs] of allSpecs) {
     const localSpec = specs.find((s) => s.localPath);
     if (localSpec) {
-      resolved.set(name, {
+      topLevel.set(name, {
         name,
         version: "local",
         localPath: localSpec.localPath
@@ -1147,6 +1134,7 @@ function resolveVersionConflicts(allSpecs, logger) {
     const directSpecs = activeSpecs.filter((s) => s.source === "direct");
     const directExact = directSpecs.find((s) => semver2.valid(s.spec) !== null);
     let chosenVersion;
+    const alreadyNested = /* @__PURE__ */ new Set();
     if (directExact) {
       chosenVersion = directExact.spec;
     } else if (directSpecs.length > 0) {
@@ -1155,9 +1143,14 @@ function resolveVersionConflicts(allSpecs, logger) {
       const exactVersions = activeSpecs.filter((s) => semver2.valid(s.spec) !== null).map((s) => s.spec);
       const uniqueExact = [...new Set(exactVersions)];
       if (uniqueExact.length > 1) {
-        throw new Error(
-          `Version conflict for ${name}: ${uniqueExact.join(" vs ")} (from ${activeSpecs.map((s) => `${s.spec} via ${s.from}`).join(", ")})`
-        );
+        const sorted = [...uniqueExact].sort(semver2.rcompare);
+        chosenVersion = sorted[0];
+        for (let i2 = 1; i2 < sorted.length; i2++) {
+          const loserVersion = sorted[i2];
+          const consumers = activeSpecs.filter((s) => s.spec === loserVersion).map((s) => s.from);
+          nested.push({ name, version: loserVersion, consumers });
+          alreadyNested.add(loserVersion);
+        }
       } else if (uniqueExact.length === 1) {
         chosenVersion = uniqueExact[0];
       } else {
@@ -1173,6 +1166,9 @@ function resolveVersionConflicts(allSpecs, logger) {
               logger.warn(
                 `${name}@${chosenVersion} differs from peer constraint ${spec.spec} (from ${spec.from})`
               );
+            } else if (!alreadyNested.has(spec.spec)) {
+              nested.push({ name, version: spec.spec, consumers: [spec.from] });
+              alreadyNested.add(spec.spec);
             }
           }
         } else {
@@ -1184,31 +1180,46 @@ function resolveVersionConflicts(allSpecs, logger) {
                 `${name}@${chosenVersion} may not satisfy peer constraint ${spec.spec} (from ${spec.from})`
               );
             } else {
-              throw new Error(
-                `Version conflict: ${name}@${chosenVersion} does not satisfy ${spec.spec} required by ${spec.from}`
-              );
+              nested.push({ name, version: spec.spec, consumers: [spec.from] });
             }
           }
         }
       }
     }
-    resolved.set(name, { name, version: chosenVersion });
+    topLevel.set(name, { name, version: chosenVersion });
   }
-  return resolved;
+  const consolidatedMap = /* @__PURE__ */ new Map();
+  for (const entry of nested) {
+    const key = `${entry.name}@${entry.version}`;
+    const existing = consolidatedMap.get(key);
+    if (existing) {
+      for (const c2 of entry.consumers) {
+        if (!existing.consumers.includes(c2)) existing.consumers.push(c2);
+      }
+    } else {
+      consolidatedMap.set(key, { ...entry, consumers: [...entry.consumers] });
+    }
+  }
+  return { topLevel, nested: [...consolidatedMap.values()] };
 }
-async function downloadPackages(packages, targetDir, logger, useCache = true, configDir, tmpDir) {
+async function downloadPackages(packages, targetDir, logger, useCache = true, configDir, tmpDir, overrides = {}) {
   const packagePaths = /* @__PURE__ */ new Map();
   const userSpecifiedPackages = new Set(packages.map((p2) => p2.name));
   validateNoDuplicatePackages(packages);
   logger.debug("Resolving dependencies");
-  const allSpecs = await collectAllSpecs(packages, logger, configDir);
-  const resolved = resolveVersionConflicts(allSpecs, logger);
-  await fs8.ensureDir(targetDir);
+  const allSpecs = await collectAllSpecs(
+    packages,
+    logger,
+    configDir,
+    overrides
+  );
+  const { topLevel, nested } = resolveVersionConflicts(allSpecs, logger);
+  await fs7.ensureDir(targetDir);
   const localPackageMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     if (pkg.path) localPackageMap.set(pkg.name, pkg.path);
   }
-  for (const [name, pkg] of resolved) {
+  for (const [name, pkg] of topLevel) {
     if (pkg.localPath || localPackageMap.has(name)) {
       const localPath = pkg.localPath || localPackageMap.get(name);
       const localPkg = await resolveLocalPackage(
@@ -1232,8 +1243,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
         logger.debug(`Downloading ${packageSpec} (cached)`);
       }
       try {
-        await fs8.ensureDir(path9.dirname(packageDir));
-        await fs8.copy(cachedPath, packageDir);
+        await fs7.ensureDir(path8.dirname(packageDir));
+        await fs7.copy(cachedPath, packageDir);
         packagePaths.set(name, packageDir);
         continue;
       } catch {
@@ -1241,7 +1252,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       }
     }
     try {
-      await fs8.ensureDir(path9.dirname(packageDir));
+      await fs7.ensureDir(path8.dirname(packageDir));
       const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
       await withTimeout(
         pacote.extract(packageSpec, packageDir, {
@@ -1256,8 +1267,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       }
       if (useCache) {
         try {
-          await fs8.ensureDir(path9.dirname(cachedPath));
-          await fs8.copy(packageDir, cachedPath);
+          await fs7.ensureDir(path8.dirname(cachedPath));
+          await fs7.copy(packageDir, cachedPath);
         } catch {
         }
       }
@@ -1266,16 +1277,58 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       throw new Error(`Failed to download ${packageSpec}: ${error}`);
     }
   }
+  for (const nestedPkg of nested) {
+    let resolvedSpec = `${nestedPkg.name}@${nestedPkg.version}`;
+    if (!semver2.valid(nestedPkg.version)) {
+      try {
+        const manifest = await withTimeout(
+          pacote.manifest(resolvedSpec, PACOTE_OPTS),
+          PACKAGE_DOWNLOAD_TIMEOUT_MS,
+          `Manifest fetch timed out: ${resolvedSpec}`
+        );
+        const resolved = manifest.version;
+        resolvedSpec = `${nestedPkg.name}@${resolved}`;
+      } catch (error) {
+        throw new Error(
+          `Failed to resolve nested dependency ${resolvedSpec}: ${error}`
+        );
+      }
+    }
+    for (const consumer of nestedPkg.consumers) {
+      const nestedDir = getNestedPackageDirectory(
+        targetDir,
+        consumer,
+        nestedPkg.name
+      );
+      try {
+        await fs7.ensureDir(path8.dirname(nestedDir));
+        const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
+        await withTimeout(
+          pacote.extract(resolvedSpec, nestedDir, {
+            ...PACOTE_OPTS,
+            cache: cacheDir
+          }),
+          PACKAGE_DOWNLOAD_TIMEOUT_MS,
+          `Nested package download timed out: ${resolvedSpec}`
+        );
+        logger.debug(`Nested: ${resolvedSpec} under ${consumer}`);
+      } catch (error) {
+        throw new Error(
+          `Failed to install nested ${resolvedSpec} for ${consumer}: ${error}`
+        );
+      }
+    }
+  }
   return packagePaths;
 }
 async function getCachedPackagePath(pkg, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "packages");
   const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
-  return path9.join(cacheDir, cacheKey);
+  return path8.join(cacheDir, cacheKey);
 }
 async function isPackageCached(pkg, tmpDir) {
   const cachedPath = await getCachedPackagePath(pkg, tmpDir);
-  return fs8.pathExists(cachedPath);
+  return fs7.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -1314,61 +1367,62 @@ var init_package_manager = __esm({
     };
     SOURCE_PRIORITY = {
       direct: 0,
-      dependency: 1,
-      peerDependency: 2
+      override: 1,
+      dependency: 2,
+      peerDependency: 3
     };
   }
 });
 
 // src/core/build-cache.ts
-import fs9 from "fs-extra";
-import path10 from "path";
+import fs8 from "fs-extra";
+import path9 from "path";
 import { getHashServer as getHashServer2 } from "@walkeros/server-core";
 async function getBuildCachePath(configContent, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "builds");
   const cacheKey = await getFlowSettingsCacheKey(configContent);
-  return path10.join(cacheDir, `${cacheKey}.js`);
+  return path9.join(cacheDir, `${cacheKey}.js`);
 }
 async function isBuildCached(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  return fs9.pathExists(cachePath);
+  return fs8.pathExists(cachePath);
 }
 async function cacheBuild(configContent, buildOutput, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  await fs9.ensureDir(path10.dirname(cachePath));
-  await fs9.writeFile(cachePath, buildOutput, "utf-8");
+  await fs8.ensureDir(path9.dirname(cachePath));
+  await fs8.writeFile(cachePath, buildOutput, "utf-8");
 }
 async function getCachedBuild(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  if (await fs9.pathExists(cachePath)) {
-    return await fs9.readFile(cachePath, "utf-8");
+  if (await fs8.pathExists(cachePath)) {
+    return await fs8.readFile(cachePath, "utf-8");
   }
   return null;
 }
 async function getCodeCachePath(codeContent, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "code");
   const cacheKey = await getHashServer2(codeContent, 12);
-  return path10.join(cacheDir, `${cacheKey}.js`);
+  return path9.join(cacheDir, `${cacheKey}.js`);
 }
 async function cacheCode(codeContent, codeOutput, tmpDir) {
   const cachePath = await getCodeCachePath(codeContent, tmpDir);
-  await fs9.ensureDir(path10.dirname(cachePath));
-  await fs9.writeFile(cachePath, codeOutput, "utf-8");
+  await fs8.ensureDir(path9.dirname(cachePath));
+  await fs8.writeFile(cachePath, codeOutput, "utf-8");
 }
 async function getCachedCode(codeContent, tmpDir) {
   const cachePath = await getCodeCachePath(codeContent, tmpDir);
-  if (await fs9.pathExists(cachePath)) {
-    return fs9.readFile(cachePath, "utf-8");
+  if (await fs8.pathExists(cachePath)) {
+    return fs8.readFile(cachePath, "utf-8");
   }
   return null;
 }
 async function ensureCodeOnDisk(codeContent, compiledCode, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "code");
   const cacheKey = await getHashServer2(codeContent, 12);
-  const cachePath = path10.join(cacheDir, `${cacheKey}.mjs`);
-  if (!await fs9.pathExists(cachePath)) {
-    await fs9.ensureDir(path10.dirname(cachePath));
-    await fs9.writeFile(cachePath, compiledCode, "utf-8");
+  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");
   }
   return cachePath;
 }
@@ -1384,8 +1438,8 @@ var init_build_cache = __esm({
 import crypto from "crypto";
 import esbuild from "esbuild";
 import { builtinModules } from "module";
-import path11 from "path";
-import fs10 from "fs-extra";
+import path10 from "path";
+import fs9 from "fs-extra";
 import { packageNameToVariable, ENV_MARKER_PREFIX } from "@walkeros/core";
 function isInlineCode(code) {
   return code !== null && typeof code === "object" && !Array.isArray(code) && "push" in code;
@@ -1438,18 +1492,18 @@ function generateInlineCode(inline, config, env, chain, chainPropertyName, isDes
 }
 async function copyIncludes(includes, sourceDir, outputDir, logger) {
   for (const include of includes) {
-    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)) {
+    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)) {
       throw new Error(
         `Circular include detected: "${include}" resolves to "${resolvedSource}" which overlaps with output directory "${resolvedOutput}"`
       );
     }
-    if (await fs10.pathExists(sourcePath)) {
-      await fs10.copy(sourcePath, destPath);
+    if (await fs9.pathExists(sourcePath)) {
+      await fs9.copy(sourcePath, destPath);
       logger.debug(`Copied ${include} to output`);
     } else {
       logger.warn(`Include folder not found: ${include}`);
@@ -1520,14 +1574,14 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       const cachedBuild = await getCachedBuild(configContent, CACHE_DIR);
       if (cachedBuild) {
         logger.debug("Using cached build");
-        const outputPath = path11.resolve(buildOptions.output);
-        await fs10.ensureDir(path11.dirname(outputPath));
-        await fs10.writeFile(outputPath, cachedBuild);
-        const stats = await fs10.stat(outputPath);
+        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 fs10.stat(outputPath);
+          const stats2 = await fs9.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -1550,7 +1604,7 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
     }
   }
   try {
-    await fs10.ensureDir(TEMP_DIR);
+    await fs9.ensureDir(TEMP_DIR);
     const hasSourcesOrDests = Object.keys(
       flowSettings.sources || {}
     ).length > 0 || Object.keys(
@@ -1570,7 +1624,12 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
             imports: [`default as ${varName}`]
           };
         }
-        for (const section of ["sources", "destinations", "transformers", "stores"]) {
+        for (const section of [
+          "sources",
+          "destinations",
+          "transformers",
+          "stores"
+        ]) {
           const steps = flowSettings[section];
           if (!steps) continue;
           for (const step of Object.values(steps)) {
@@ -1600,12 +1659,13 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       buildOptions.cache,
       buildOptions.configDir,
       // For resolving relative local paths
-      CACHE_DIR
+      CACHE_DIR,
+      buildOptions.overrides
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
-        const pkgJsonPath = path11.join(pkgPath, "package.json");
-        const pkgJson = await fs10.readJSON(pkgJsonPath);
+        const pkgJsonPath = path10.join(pkgPath, "package.json");
+        const pkgJson = await fs9.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -1613,12 +1673,12 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
               require: pkgJson.main
             }
           };
-          await fs10.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs9.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
-    const packageJsonPath = path11.join(TEMP_DIR, "package.json");
-    await fs10.writeFile(
+    const packageJsonPath = path10.join(TEMP_DIR, "package.json");
+    await fs9.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
@@ -1628,8 +1688,8 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       buildOptions,
       packagePaths
     );
-    const outputPath = path11.resolve(buildOptions.output);
-    await fs10.ensureDir(path11.dirname(outputPath));
+    const outputPath = path10.resolve(buildOptions.output);
+    await fs9.ensureDir(path10.dirname(outputPath));
     let compiledCode = null;
     if (buildOptions.cache !== false) {
       compiledCode = await getCachedCode(codeEntry, CACHE_DIR);
@@ -1640,8 +1700,8 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       logger.debug(
         `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
       );
-      const entryPath = path11.join(TEMP_DIR, "entry.js");
-      await fs10.writeFile(entryPath, codeEntry);
+      const entryPath = path10.join(TEMP_DIR, "entry.js");
+      await fs9.writeFile(entryPath, codeEntry);
       const esbuildOptions = createEsbuildOptions(
         { ...buildOptions, minify: false },
         entryPath,
@@ -1660,7 +1720,7 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
       } finally {
         await esbuild.stop();
       }
-      compiledCode = await fs10.readFile(outputPath, "utf-8");
+      compiledCode = await fs9.readFile(outputPath, "utf-8");
       if (buildOptions.cache !== false) {
         await cacheCode(codeEntry, compiledCode, CACHE_DIR);
       }
@@ -1677,14 +1737,14 @@ export { __configData };`;
 ` : "";
       const esmOutput = `${banner}${compiledCode}
 ${dataDeclaration}`;
-      await fs10.writeFile(outputPath, esmOutput);
+      await fs9.writeFile(outputPath, esmOutput);
     } else {
       const stage2Entry = (buildOptions.platform || "node") === "browser" ? generateWebEntry(stage1Path, dataPayload, {
         windowCollector: buildOptions.windowCollector,
         windowElb: buildOptions.windowElb
       }) : generateServerEntry(stage1Path, dataPayload);
-      const stage2EntryPath = path11.join(TEMP_DIR, "stage2.mjs");
-      await fs10.writeFile(stage2EntryPath, stage2Entry);
+      const stage2EntryPath = path10.join(TEMP_DIR, "stage2.mjs");
+      await fs9.writeFile(stage2EntryPath, stage2Entry);
       const stage2Options = {
         entryPoints: [stage2EntryPath],
         bundle: true,
@@ -1721,13 +1781,13 @@ ${dataDeclaration}`;
         await esbuild.stop();
       }
     }
-    const outputStats = await fs10.stat(outputPath);
+    const outputStats = await fs9.stat(outputPath);
     const sizeKB = (outputStats.size / 1024).toFixed(1);
     const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
     logger.info(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
     if (buildOptions.cache !== false) {
       const configContent = generateCacheKeyContent(flowSettings, buildOptions);
-      const buildOutput = await fs10.readFile(outputPath, "utf-8");
+      const buildOutput = await fs9.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput, CACHE_DIR);
       logger.debug("Build cached for future use");
     }
@@ -1741,7 +1801,7 @@ ${dataDeclaration}`;
       );
     }
     if (buildOptions.include && buildOptions.include.length > 0) {
-      const outputDir = path11.dirname(outputPath);
+      const outputDir = path10.dirname(outputPath);
       await copyIncludes(
         buildOptions.include,
         buildOptions.configDir || process.cwd(),
@@ -1754,13 +1814,13 @@ ${dataDeclaration}`;
     throw error;
   } finally {
     if (!buildOptions.tempDir) {
-      fs10.remove(TEMP_DIR).catch(() => {
+      fs9.remove(TEMP_DIR).catch(() => {
       });
     }
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs10.stat(outputPath);
+  const stats = await fs9.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1943,9 +2003,8 @@ function detectExplicitCodeImports(flowSettings) {
   }
   return explicitCodeImports;
 }
-function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, storePackages, explicitCodeImports) {
+async function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, storePackages, explicitCodeImports, packagePaths, withDev) {
   const importStatements = [];
-  const examplesMappings = [];
   const usedPackages = /* @__PURE__ */ new Set([
     ...destinationPackages,
     ...sourcePackages,
@@ -1980,21 +2039,6 @@ function generateImportStatements(packages, destinationPackages, sourcePackages,
           }
         }
       }
-      const examplesImport = uniqueImports.find(
-        (imp) => imp.includes("examples as ")
-      );
-      if (examplesImport) {
-        const examplesVarName = examplesImport.split(" as ")[1];
-        const destinationMatch = packageName.match(
-          /@walkeros\/web-destination-(.+)$/
-        );
-        if (destinationMatch) {
-          const destinationName = destinationMatch[1];
-          examplesMappings.push(
-            `  ${destinationName}: typeof ${examplesVarName} !== 'undefined' ? ${examplesVarName} : undefined`
-          );
-        }
-      }
     }
     if (packageName === "@walkeros/collector" && !namedImportsToGenerate.includes("startFlow")) {
       namedImportsToGenerate.push("startFlow");
@@ -2004,7 +2048,27 @@ function generateImportStatements(packages, destinationPackages, sourcePackages,
       importStatements.push(`import { ${importList} } from '${packageName}';`);
     }
   }
-  return { importStatements, examplesMappings };
+  const devExportEntries = [];
+  if (withDev) {
+    for (const packageName of usedPackages) {
+      const localPath = packagePaths.get(packageName);
+      if (!localPath) continue;
+      try {
+        const pkgJsonPath = path10.join(localPath, "package.json");
+        const pkgJson = await fs9.readJSON(pkgJsonPath);
+        const exports = pkgJson.exports;
+        if (exports && typeof exports === "object" && "./dev" in exports) {
+          const varName = `__dev_${packageNameToVariable(packageName)}`;
+          importStatements.push(
+            `import * as ${varName} from '${packageName}/dev';`
+          );
+          devExportEntries.push(`'${packageName}': ${varName}`);
+        }
+      } catch {
+      }
+    }
+  }
+  return { importStatements, devExportEntries };
 }
 function validateComponentNames(components, section) {
   for (const name of Object.keys(components)) {
@@ -2067,13 +2131,15 @@ async function createEntryPoint(flowSettings, buildOptions, packagePaths) {
     validateComponentNames(flowWithSections.transformers, "transformers");
   if (flowWithSections.stores)
     validateComponentNames(flowWithSections.stores, "stores");
-  const { importStatements } = generateImportStatements(
+  const { importStatements, devExportEntries } = await generateImportStatements(
     buildOptions.packages,
     destinationPackages,
     sourcePackages,
     transformerPackages,
     storePackages,
-    explicitCodeImports
+    explicitCodeImports,
+    packagePaths,
+    buildOptions.skipWrapper === true
   );
   const importsCode = importStatements.join("\n");
   const hasFlow = Object.values(flowSettings.sources || {}).some(
@@ -2097,9 +2163,14 @@ ${userCode}` : userCode,
     codeConfigObject,
     buildOptions.code || ""
   );
+  const devExportsBlock = devExportEntries.length > 0 ? `
+export const __devExports = {
+  ${devExportEntries.join(",\n  ")},
+};` : "";
+  const fullModule = wireConfigModule + devExportsBlock;
   const codeEntry = importsCode ? `${importsCode}
 
-${wireConfigModule}` : wireConfigModule;
+${fullModule}` : fullModule;
   return { codeEntry, dataPayload, hasFlow: true };
 }
 function createBuildError(buildError, code) {
@@ -2345,6 +2416,79 @@ const __configData = ${dataPayload};
   const { collector, elb } = await startFlow(wireConfig(__configData));${assignmentCode}
 })();`;
 }
+function generateWrapEntry(stage1Path, options = {}) {
+  const assignments = [];
+  if (options.windowCollector) {
+    assignments.push(
+      `  if (typeof window !== 'undefined') window['${options.windowCollector}'] = collector;`
+    );
+  }
+  if (options.windowElb) {
+    assignments.push(
+      `  if (typeof window !== 'undefined') window['${options.windowElb}'] = elb;`
+    );
+  }
+  const assignmentCode = assignments.length > 0 ? "\n" + assignments.join("\n") : "";
+  const hasPreview = !!(options.previewOrigin && options.previewScope);
+  const previewOriginLiteral = JSON.stringify(options.previewOrigin ?? "");
+  const previewScopeLiteral = JSON.stringify(options.previewScope ?? "");
+  const preflightBlock = hasPreview ? `
+  // --- Preview mode preflight ---
+  if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+    var __previewOrigin = ${previewOriginLiteral};
+    var __previewScope = ${previewScopeLiteral};
+    var __params = new URLSearchParams(location.search);
+    var __tokens = __params.getAll('elbPreview');
+    var __param = __tokens.length > 0 ? __tokens[__tokens.length - 1] : null;
+    var __secure = location.protocol === 'https:' ? '; Secure' : '';
+
+    if (__param === 'off') {
+      document.cookie = 'elbPreview=; path=/; max-age=0; SameSite=Lax' + __secure;
+    } else if (__param && /^[a-zA-Z0-9_-]{8,32}$/.test(__param)) {
+      document.cookie = 'elbPreview=' + __param + '; path=/; max-age=604800; SameSite=Lax' + __secure;
+    }
+
+    var __match = /(?:^|; )elbPreview=([^;]+)/.exec(document.cookie);
+    var __token = __match && __match[1];
+    if (__token && /^[a-zA-Z0-9_-]{8,32}$/.test(__token)) {
+      var __s = document.createElement('script');
+      __s.src = 'https://' + __previewOrigin + '/preview/' + __previewScope + '/walker.' + __token + '.js';
+      document.head.appendChild(__s);
+      return;
+    }
+  }
+  // --- End preview mode preflight ---
+` : "";
+  return `import { startFlow, wireConfig, __configData } from '${stage1Path}';
+
+(async () => {${preflightBlock}
+  const { collector, elb } = await startFlow(wireConfig(__configData));${assignmentCode}
+})();`;
+}
+function generateWrapEntryServer(stage1Path) {
+  return `import { startFlow, wireConfig, __configData } from '${stage1Path}';
+
+export default async function(context = {}) {
+  const config = wireConfig(__configData);
+
+  if (context.logger) config.logger = context.logger;
+
+  if (context.sourceSettings && config.sources) {
+    for (const src of Object.values(config.sources)) {
+      if (src.config?.settings) {
+        src.config.settings = { ...src.config.settings, ...context.sourceSettings };
+      }
+    }
+  }
+
+  const result = await startFlow(config);
+
+  const httpSource = Object.values(result.collector.sources || {})
+    .find(s => 'httpHandler' in s && typeof s.httpHandler === 'function');
+
+  return { ...result, httpHandler: httpSource ? httpSource.httpHandler : undefined };
+}`;
+}
 function processConfigValue(value) {
   return serializeWithCode(value, 0);
 }
@@ -2425,12 +2569,12 @@ var init_bundler = __esm({
 });
 
 // src/commands/bundle/upload.ts
-import fs11 from "fs-extra";
+import fs10 from "fs-extra";
 function sanitizeUrl(url) {
   return url.split("?")[0];
 }
 async function uploadBundleToUrl(filePath, url, timeoutMs = 3e4) {
-  const bundleContent = await fs11.readFile(filePath);
+  const bundleContent = await fs10.readFile(filePath);
   const doUpload = async (attempt) => {
     const response = await fetch(url, {
       method: "PUT",
@@ -2509,8 +2653,8 @@ var init_api_client = __esm({
 });
 
 // src/commands/bundle/dockerfile.ts
-import path12 from "path";
-import fs12 from "fs-extra";
+import path11 from "path";
+import fs11 from "fs-extra";
 function buildDockerfileContent(platform, includedFolders) {
   const bundleFile = platform === "web" ? "walker.js" : "bundle.mjs";
   const lines = [
@@ -2520,21 +2664,21 @@ function buildDockerfileContent(platform, includedFolders) {
     `COPY ${bundleFile} /app/flow/${bundleFile}`
   ];
   for (const folder of includedFolders) {
-    const name = path12.basename(folder);
+    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 = path12.join(outputDir, "Dockerfile");
-  if (customFile && await fs12.pathExists(customFile)) {
-    await fs12.copy(customFile, destPath);
+  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 fs12.writeFile(destPath, dockerfile);
+  await fs11.writeFile(destPath, dockerfile);
   logger.info(`Dockerfile: ${destPath}`);
 }
 var init_dockerfile = __esm({
@@ -2544,15 +2688,15 @@ var init_dockerfile = __esm({
 });
 
 // src/commands/bundle/index.ts
-import path13 from "path";
-import fs13 from "fs-extra";
+import path12 from "path";
+import fs12 from "fs-extra";
 import { getPlatform as getPlatform2 } from "@walkeros/core";
 function resolveOutputPath(output, buildOptions) {
-  const resolved = path13.resolve(output);
-  const ext = path13.extname(resolved);
-  if (output.endsWith("/") || output.endsWith(path13.sep) || !ext) {
+  const resolved = path12.resolve(output);
+  const ext = path12.extname(resolved);
+  if (output.endsWith("/") || output.endsWith(path12.sep) || !ext) {
     const filename = buildOptions.platform === "browser" ? "walker.js" : "bundle.mjs";
-    return path13.join(resolved, filename);
+    return path12.join(resolved, filename);
   }
   return resolved;
 }
@@ -2582,7 +2726,7 @@ async function bundleCommand(options) {
       } catch {
         throw new Error("Invalid JSON received on stdin");
       }
-      configPath = path13.resolve(process.cwd(), "stdin.config.json");
+      configPath = path12.resolve(process.cwd(), "stdin.config.json");
     } else {
       const file = options.config || "bundle.config.json";
       configPath = resolveAsset(file, "config");
@@ -2636,19 +2780,25 @@ async function bundleCommand(options) {
         if (uploadUrl) {
           await uploadBundleToUrl(buildOptions.output, uploadUrl);
           logger.info(`Uploaded to: ${sanitizeUrl(uploadUrl)}`);
-          await fs13.remove(buildOptions.output);
+          await fs12.remove(buildOptions.output);
         }
         if (!options.json && !options.all && options.stats && stats) {
           displayStats(stats, logger);
         }
         if (writingToStdout && !options.json) {
-          const bundleContent = await fs13.readFile(buildOptions.output);
+          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";
+            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 = path13.dirname(buildOptions.output);
+            const outputDir = path12.dirname(buildOptions.output);
             const customFile = typeof options.dockerfile === "string" ? options.dockerfile : void 0;
             await generateDockerfile(
               outputDir,
@@ -2719,7 +2869,7 @@ Build Summary: ${successCount}/${results.length} succeeded`
 }
 async function bundle(configOrPath, options = {}) {
   let rawConfig;
-  let configPath = path13.resolve(process.cwd(), "walkeros.config.json");
+  let configPath = path12.resolve(process.cwd(), "walkeros.config.json");
   if (typeof configOrPath === "string") {
     configPath = resolveAsset(configOrPath, "config");
     rawConfig = await loadJsonConfig(configPath);
@@ -2775,45 +2925,6 @@ var init_bundle = __esm({
   }
 });
 
-// src/commands/push/env-loader.ts
-var env_loader_exports = {};
-__export(env_loader_exports, {
-  loadDestinationEnvs: () => loadDestinationEnvs
-});
-async function loadDestinationEnvs(destinations, packages, configDir) {
-  const envs = {};
-  const resolveDir = configDir || process.cwd();
-  for (const [destKey, destConfig] of Object.entries(destinations)) {
-    const typedConfig = destConfig;
-    if (!typedConfig.package) {
-      continue;
-    }
-    try {
-      const packageName = typedConfig.package;
-      const isDemoPackage = packageName.includes("-demo");
-      const importPath = isDemoPackage ? resolvePackageImportPath(packageName, packages, resolveDir) : resolvePackageImportPath(packageName, packages, resolveDir, "/dev");
-      const module = await import(importPath);
-      const examplesModule = module.examples || module.default?.examples;
-      const envModule = examplesModule?.env;
-      if (envModule?.push) {
-        envs[destKey] = {
-          init: envModule.init,
-          push: envModule.push,
-          simulation: envModule.simulation || []
-        };
-      }
-    } catch {
-    }
-  }
-  return envs;
-}
-var init_env_loader = __esm({
-  "src/commands/push/env-loader.ts"() {
-    "use strict";
-    init_package_path();
-  }
-});
-
 // src/runtime/cache.ts
 var cache_exports = {};
 __export(cache_exports, {
@@ -2822,7 +2933,7 @@ __export(cache_exports, {
   writeCache: () => writeCache
 });
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   copyFileSync,
   writeFileSync as writeFileSync3,
@@ -2840,7 +2951,7 @@ function readCache(cacheDir) {
   try {
     const metaPath = join2(cacheDir, "meta.json");
     const bundlePath = join2(cacheDir, "bundle.mjs");
-    if (!existsSync4(metaPath) || !existsSync4(bundlePath)) return null;
+    if (!existsSync3(metaPath) || !existsSync3(bundlePath)) return null;
     const meta = JSON.parse(readFileSync2(metaPath, "utf-8"));
     return { bundlePath, version: meta.version };
   } catch {
@@ -2850,7 +2961,7 @@ function readCache(cacheDir) {
 function readCacheConfig(cacheDir) {
   try {
     const configPath = join2(cacheDir, "config.json");
-    if (!existsSync4(configPath)) return null;
+    if (!existsSync3(configPath)) return null;
     return readFileSync2(configPath, "utf-8");
   } catch {
     return null;
@@ -2868,15 +2979,15 @@ __export(utils_exports, {
   isPreBuiltConfig: () => isPreBuiltConfig,
   prepareBundleForRun: () => prepareBundleForRun
 });
-import path17 from "path";
-import fs16 from "fs-extra";
+import path16 from "path";
+import fs15 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
   const tempDir = getTmpPath(
     void 0,
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  await fs16.ensureDir(tempDir);
-  const tempPath = path17.join(tempDir, "bundle.mjs");
+  await fs15.ensureDir(tempDir);
+  const tempPath = path16.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
     verbose: options.verbose,
@@ -2891,7 +3002,7 @@ async function prepareBundleForRun(configPath, options) {
   return {
     bundlePath: tempPath,
     cleanup: async () => {
-      await fs16.remove(tempDir);
+      await fs15.remove(tempDir);
     }
   };
 }
@@ -2910,8 +3021,8 @@ var init_utils3 = __esm({
 init_bundle();
 
 // src/commands/push/index.ts
-import path16 from "path";
-import fs15 from "fs-extra";
+import path15 from "path";
+import fs14 from "fs-extra";
 import {
   createIngest,
   getPlatform as getPlatform4,
@@ -2924,28 +3035,28 @@ import {
 // ../collector/dist/index.mjs
 import { assign as o } from "@walkeros/core";
 import { assign as r, createLogger as i } from "@walkeros/core";
-import { buildCacheContext as a, clone as c, compileCache as u, checkCache as f, storeCache as l, compileNext as d, createIngest as g, debounce as p, getId as m, getGrantedConsent as h, isDefined as y, isFunction as v, isObject as b, isRouteArray as w, processEventMapping as k, resolveNext as C, tryCatchAsync as O, useHooks as j } from "@walkeros/core";
-import { isArray as A } from "@walkeros/core";
-import { tryCatch as x, tryCatchAsync as q } from "@walkeros/core";
-import { createIngest as S, getMappingValue as $, tryCatchAsync as D, compileNext as _, resolveNext as I, isRouteArray as P, compileCache as E, checkCache as M, storeCache as R, applyUpdate as H, buildCacheContext as T } from "@walkeros/core";
-import { createIngest as G, isObject as N, tryCatchAsync as B, useHooks as U, compileNext as F, resolveNext as W, isRouteArray as L, compileCache as V, checkCache as z, storeCache as J, buildCacheContext as K } from "@walkeros/core";
-import { assign as ve, getId as be, isFunction as we, isString as ke } from "@walkeros/core";
-import { isObject as Ce } from "@walkeros/core";
-import { createIngest as qe, getGrantedConsent as Se, processEventMapping as $e, tryCatchAsync as De, useHooks as _e } from "@walkeros/core";
-import { useHooks as Pe, tryCatchAsync as Ee } from "@walkeros/core";
-import { useHooks as Me } from "@walkeros/core";
-function Q(e, n) {
+import { assign as a, buildCacheContext as c, clone as u, compileCache as f, checkCache as l, storeCache as d, compileNext as g, createIngest as p, debounce as m, getId as h, getGrantedConsent as y, isDefined as v, isFunction as b, isObject as w, isRouteArray as k, processEventMapping as C, resolveNext as O, tryCatchAsync as j, useHooks as A } from "@walkeros/core";
+import { isArray as x } from "@walkeros/core";
+import { tryCatch as q, tryCatchAsync as S } from "@walkeros/core";
+import { createIngest as $, getMappingValue as D, tryCatchAsync as _, compileNext as I, resolveNext as P, isRouteArray as E, compileCache as M, checkCache as R, storeCache as H, applyUpdate as T, buildCacheContext as G } from "@walkeros/core";
+import { createIngest as N, isObject as B, tryCatchAsync as U, useHooks as F, compileNext as W, resolveNext as L, isRouteArray as V, compileCache as z, checkCache as J, storeCache as K, buildCacheContext as Q } from "@walkeros/core";
+import { assign as be, getId as we, isFunction as ke, isString as Ce } from "@walkeros/core";
+import { isObject as Oe } from "@walkeros/core";
+import { createIngest as Se, getGrantedConsent as $e, processEventMapping as De, tryCatchAsync as _e, useHooks as Ie } from "@walkeros/core";
+import { useHooks as Ee, tryCatchAsync as Me } from "@walkeros/core";
+import { useHooks as Re } from "@walkeros/core";
+function X(e, n) {
   return e.storeId && n.stores[e.storeId] ? n.stores[e.storeId] : n.stores.__cache;
 }
-function X(e) {
+function Y(e) {
   const n = {};
   for (const [t, o2] of Object.entries(e)) {
     const e2 = o2.config?.next;
-    e2 && !L(e2) ? n[t] = { next: e2 } : n[t] = {};
+    e2 && !V(e2) ? n[t] = { next: e2 } : n[t] = {};
   }
   return n;
 }
-function Z(e, n = {}) {
+function ee(e, n = {}) {
   if (!e) return [];
   if (Array.isArray(e)) return e;
   const t = [], o2 = /* @__PURE__ */ new Set();
@@ -2961,23 +3072,23 @@ function Z(e, n = {}) {
   }
   return t;
 }
-async function ee(e, n, t) {
+async function ne(e, n, t) {
   if (n.init && !n.config.init) {
-    const o2 = n.type || "unknown", s = e.logger.scope(`transformer:${o2}`), r2 = { collector: e, logger: s, id: t, ingest: G(t), config: n.config, env: oe(n.config.env) };
+    const o2 = n.type || "unknown", s = e.logger.scope(`transformer:${o2}`), r2 = { collector: e, logger: s, id: t, ingest: N(t), config: n.config, env: se(n.config.env) };
     s.debug("init");
-    const i2 = await U(n.init, "TransformerInit", e.hooks)(r2);
+    const i2 = await F(n.init, "TransformerInit", e.hooks)(r2);
     if (false === i2) return false;
     n.config = { ...i2 || n.config, env: i2?.env || n.config.env, init: true }, s.debug("init done");
   }
   return true;
 }
-async function ne(e, n, t, o2, s, r2) {
-  const i2 = n.type || "unknown", a2 = e.logger.scope(`transformer:${i2}`), c2 = { collector: e, logger: a2, id: t, ingest: s, config: n.config, env: { ...oe(n.config.env), ...r2 ? { respond: r2 } : {} } };
+async function te(e, n, t, o2, s, r2) {
+  const i2 = n.type || "unknown", a2 = e.logger.scope(`transformer:${i2}`), c2 = { collector: e, logger: a2, id: t, ingest: s, config: n.config, env: { ...se(n.config.env), ...r2 ? { respond: r2 } : {} } };
   a2.debug("push", { event: o2.name });
-  const u2 = await U(n.push, "TransformerPush", e.hooks)(o2, c2);
+  const u2 = await F(n.push, "TransformerPush", e.hooks)(o2, c2);
   return a2.debug("push done"), u2;
 }
-async function te(e, n, t, o2, s, r2, i2) {
+async function oe(e, n, t, o2, s, r2, i2) {
   i2 && s?._meta && (s._meta.chainPath = i2);
   let a2 = o2, c2 = r2;
   for (const o3 of t) {
@@ -2988,7 +3099,7 @@ async function te(e, n, t, o2, s, r2, i2) {
     }
     if (s && s._meta && s._meta.path.length > 256) return e.logger.error(`Max path length exceeded at ${o3}`), { event: null, respond: c2 };
     s && s._meta && (s._meta.hops++, s._meta.path.push(o3));
-    if (!await B(ee)(e, r3, o3)) return e.logger.error(`Transformer init failed: ${o3}`), { event: null, respond: c2 };
+    if (!await U(ne)(e, r3, o3)) return e.logger.error(`Transformer init failed: ${o3}`), { event: null, respond: c2 };
     if (i2 && void 0 !== r3.config?.chainMocks?.[i2]) {
       const n2 = r3.config.chainMocks[i2];
       e.logger.scope(`transformer:${r3.type || "unknown"}`).debug("chainMock", { chain: i2 }), a2 = n2;
@@ -2999,10 +3110,10 @@ async function te(e, n, t, o2, s, r2, i2) {
       continue;
     }
     if (r3.config?.disabled) continue;
-    const u2 = r3.config?.cache, f2 = u2 ? V(u2) : void 0, l2 = f2 ? Q(f2, e) : void 0;
+    const u2 = r3.config?.cache, f2 = u2 ? z(u2) : void 0, l2 = f2 ? X(f2, e) : void 0;
     let d2;
     if (f2 && l2) {
-      const e2 = K(s, a2), n2 = z(f2, l2, e2, `t:${o3}`);
+      const e2 = Q(s, a2), n2 = J(f2, l2, e2, `t:${o3}`);
       if ("HIT" === n2?.status && n2.value) {
         if (a2 = n2.value, f2.full) return { event: a2, respond: c2 };
         continue;
@@ -3011,31 +3122,31 @@ async function te(e, n, t, o2, s, r2, i2) {
     }
     const g2 = r3.config.before;
     if (g2) {
-      const t2 = Z("string" == typeof g2 || Array.isArray(g2) && !L(g2) ? g2 : W(F(g2), K(s, a2)) || void 0, X(n));
+      const t2 = ee("string" == typeof g2 || Array.isArray(g2) && !V(g2) ? g2 : L(W(g2), Q(s, a2)) || void 0, Y(n));
       if (t2.length > 0) {
-        const o4 = await te(e, n, t2, a2, s, c2, i2);
+        const o4 = await oe(e, n, t2, a2, s, c2, i2);
         if (null === o4.event) return { event: null, respond: o4.respond ?? c2 };
         o4.respond && (c2 = o4.respond), a2 = Array.isArray(o4.event) ? o4.event[0] : o4.event;
       }
     }
-    const p2 = await B(ne, (n2) => (e.logger.scope(`transformer:${r3.type || "unknown"}`).error("Push failed", { error: n2 }), false))(e, r3, o3, a2, s, c2);
+    const p2 = await U(te, (n2) => (e.logger.scope(`transformer:${r3.type || "unknown"}`).error("Push failed", { error: n2 }), false))(e, r3, o3, a2, s, c2);
     if (false === p2) return { event: null, respond: c2 };
     if (Array.isArray(p2)) {
       const r4 = t.slice(t.indexOf(o3) + 1), u3 = await Promise.all(p2.map(async (t2) => {
-        const o4 = t2.event || a2, u4 = s ? { ...s, _meta: { ...s._meta, path: [...s._meta.path] } } : G("unknown");
+        const o4 = t2.event || a2, u4 = s ? { ...s, _meta: { ...s._meta, path: [...s._meta.path] } } : N("unknown");
         if (t2.next) {
           let s2 = t2.next;
-          if (L(t2.next)) {
-            const e2 = F(t2.next);
-            s2 = W(e2, K(u4, o4));
+          if (V(t2.next)) {
+            const e2 = W(t2.next);
+            s2 = L(e2, Q(u4, o4));
           }
           if (s2) {
-            const t3 = Z(s2, X(n));
-            if (t3.length > 0) return te(e, n, t3, o4, u4, c2, i2);
+            const t3 = ee(s2, Y(n));
+            if (t3.length > 0) return oe(e, n, t3, o4, u4, c2, i2);
           }
           return { event: o4, respond: c2 };
         }
-        return r4.length > 0 ? te(e, n, r4, o4, u4, c2, i2) : { event: o4, respond: c2 };
+        return r4.length > 0 ? oe(e, n, r4, o4, u4, c2, i2) : { event: o4, respond: c2 };
       }));
       let f3 = c2;
       const l3 = [];
@@ -3050,41 +3161,41 @@ async function te(e, n, t, o2, s, r2, i2) {
       const { event: t2, respond: o4, next: r4 } = p2;
       if (o4 && (c2 = o4), r4) {
         let o5 = r4;
-        if (L(r4)) {
-          const e2 = F(r4);
-          if (o5 = W(e2, K(s, a2)), !o5) {
+        if (V(r4)) {
+          const e2 = W(r4);
+          if (o5 = L(e2, Q(s, a2)), !o5) {
             t2 && (a2 = t2);
             continue;
           }
         }
-        const u3 = Z(o5, X(n));
-        return u3.length > 0 ? te(e, n, u3, t2 || a2, s, c2, i2) : (e.logger.warn(`Branch target not found: ${JSON.stringify(r4)}`), { event: null, respond: c2 });
+        const u3 = ee(o5, Y(n));
+        return u3.length > 0 ? oe(e, n, u3, t2 || a2, s, c2, i2) : (e.logger.warn(`Branch target not found: ${JSON.stringify(r4)}`), { event: null, respond: c2 });
       }
       t2 && (a2 = t2);
     }
-    if (d2 && l2 && J(l2, d2.key, a2, d2.ttl), (!p2 || "object" == typeof p2 && !p2.next) && r3.config.next && L(r3.config.next)) {
-      const t2 = r3.config.next, o4 = F(t2), u3 = W(o4, K(s, a2));
+    if (d2 && l2 && K(l2, d2.key, a2, d2.ttl), (!p2 || "object" == typeof p2 && !p2.next) && r3.config.next && V(r3.config.next)) {
+      const t2 = r3.config.next, o4 = W(t2), u3 = L(o4, Q(s, a2));
       if (u3) {
-        const t3 = Z(u3, X(n));
-        if (t3.length > 0) return te(e, n, t3, a2, s, c2, i2);
+        const t3 = ee(u3, Y(n));
+        if (t3.length > 0) return oe(e, n, t3, a2, s, c2, i2);
       }
       return { event: a2, respond: c2 };
     }
   }
   return { event: a2, respond: c2 };
 }
-function oe(e) {
-  return e && N(e) ? e : {};
+function se(e) {
+  return e && B(e) ? e : {};
 }
-function Te(e) {
+function Ge(e) {
   if (null === e || "object" != typeof e) return e;
-  if (Array.isArray(e)) return e.map(Te);
+  if (Array.isArray(e)) return e.map(Ge);
   const n = {};
-  for (const [t, o2] of Object.entries(e)) n[t] = "function" == typeof o2 ? o2 : Te(o2);
+  for (const [t, o2] of Object.entries(e)) n[t] = "function" == typeof o2 ? o2 : Ge(o2);
   return n;
 }
-function Ge(e) {
-  const n = [], { simulation: t, ...o2 } = e, s = Te(o2);
+function Ne(e) {
+  const n = [], { simulation: t, ...o2 } = e, s = Ge(o2);
   for (const e2 of t) {
     const t2 = e2.startsWith("call:") ? e2.slice(5) : e2, o3 = t2.split(".");
     let r2 = s;
@@ -3281,12 +3392,9 @@ function applyOverrides(config, overrides) {
   }
 }
 
-// src/commands/push/index.ts
-init_package_path();
-
 // src/commands/push/flow-context.ts
 init_utils2();
-import path14 from "path";
+import path13 from "path";
 import { pathToFileURL } from "url";
 import { JSDOM, VirtualConsole } from "jsdom";
 
@@ -3328,7 +3436,7 @@ function installTimerInterception(options = {}) {
   if (options.domWindow && options.domWindow !== globalThis) {
     patchTarget(options.domWindow);
   }
-  const drainMicrotasks = () => new Promise((resolve3) => realSetTimeout(resolve3, 0));
+  const drainMicrotasks = () => new Promise((resolve4) => realSetTimeout(resolve4, 0));
   async function flush(wallTimeout = 5e3) {
     const deadline = Date.now() + wallTimeout;
     const maxIterations = 100;
@@ -3376,7 +3484,15 @@ function installTimerInterception(options = {}) {
 
 // src/commands/push/flow-context.ts
 async function withFlowContext(options, fn) {
-  const { esmPath, platform, logger, snapshotCode, timeout, networkCalls, asyncDrain } = options;
+  const {
+    esmPath,
+    platform,
+    logger,
+    snapshotCode,
+    timeout,
+    networkCalls,
+    asyncDrain
+  } = options;
   const startTime = Date.now();
   const g2 = global;
   let savedWindow, savedDocument, savedNavigator;
@@ -3423,7 +3539,7 @@ async function withFlowContext(options, fn) {
         vm.runInThisContext(snapshotCode);
       }
     }
-    const fileUrl = pathToFileURL(path14.resolve(esmPath)).href;
+    const fileUrl = pathToFileURL(path13.resolve(esmPath)).href;
     const module = await import(`${fileUrl}?t=${Date.now()}`);
     const { wireConfig, startFlow } = module;
     if (typeof wireConfig !== "function" || typeof startFlow !== "function") {
@@ -3434,7 +3550,8 @@ async function withFlowContext(options, fn) {
     const flowModule = {
       wireConfig,
       startFlow,
-      __configData: module.__configData
+      __configData: module.__configData,
+      __devExports: module.__devExports
     };
     if (timerControl) {
       const result = await fn(flowModule);
@@ -3522,51 +3639,41 @@ init_cli_logger();
 init_tmp();
 init_config();
 init_bundler();
-import path15 from "path";
-import fs14 from "fs-extra";
+import path14 from "path";
+import fs13 from "fs-extra";
 import { getPlatform as getPlatform3 } from "@walkeros/core";
-async function prepareFlow(options) {
+async function prepareFlow(input) {
   const logger = createCLILogger({
-    silent: options.silent,
-    verbose: options.verbose
+    silent: input.silent,
+    verbose: input.verbose
   });
   logger.debug("Loading flow configuration");
-  const { flowSettings, buildOptions } = await loadFlowConfig(
-    options.configPath,
-    {
-      flowName: options.flow,
-      logger
-    }
-  );
+  const { flowSettings, buildOptions } = loadBundleConfig(input.config, {
+    configPath: process.cwd(),
+    flowName: input.flow
+  });
   const platform = getPlatform3(flowSettings);
-  const configDir = buildOptions.configDir || process.cwd();
   const overrides = buildOverrides(
-    { simulate: options.simulate, mock: options.mock },
+    { simulate: input.simulate, mock: input.mock },
     flowSettings
   );
-  if (overrides.destinations) {
-    const { loadDestinationEnvs: loadDestinationEnvs2 } = await Promise.resolve().then(() => (init_env_loader(), env_loader_exports));
-    const envs = await loadDestinationEnvs2(
-      flowSettings.destinations ?? {},
-      flowSettings.packages,
-      configDir
-    );
-    for (const [destId, env] of Object.entries(envs)) {
-      if (overrides.destinations[destId] && env.push) {
-        overrides.destinations[destId].env = env.push;
-        if (env.simulation && env.simulation.length > 0) {
-          overrides.destinations[destId].simulation = env.simulation;
-        }
+  if (input.mode === "prebuilt") {
+    return {
+      bundlePath: input.bundlePath,
+      platform,
+      overrides,
+      flowSettings,
+      cleanup: async () => {
       }
-    }
+    };
   }
   logger.debug("Bundling flow configuration");
   const tempDir = getTmpPath(
     void 0,
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  await fs14.ensureDir(tempDir);
-  const bundlePath = path15.join(tempDir, "bundle.mjs");
+  await fs13.ensureDir(tempDir);
+  const bundlePath = path14.join(tempDir, "bundle.mjs");
   const pushBuildOptions = {
     ...buildOptions,
     output: bundlePath,
@@ -3582,9 +3689,8 @@ async function prepareFlow(options) {
     platform,
     overrides,
     flowSettings,
-    configDir,
     cleanup: async () => {
-      await fs14.remove(tempDir).catch(() => {
+      await fs13.remove(tempDir).catch(() => {
       });
     }
   };
@@ -3599,11 +3705,11 @@ function resolveBeforeChain(before, transformers, ingest, event) {
     const compiled = compileNext(next);
     const resolved = resolveNext(compiled, buildCacheContext(ingest, event));
     if (!resolved) return [];
-    return Z(resolved, X(transformers));
+    return ee(resolved, Y(transformers));
   }
-  return Z(
+  return ee(
     next,
-    X(transformers)
+    Y(transformers)
   );
 }
 async function pushCore(inputPath, event, options = {}) {
@@ -3664,7 +3770,7 @@ async function pushCore(inputPath, event, options = {}) {
     };
   } finally {
     if (tempDir) {
-      await fs15.remove(tempDir).catch(() => {
+      await fs14.remove(tempDir).catch(() => {
       });
     }
   }
@@ -3804,35 +3910,15 @@ async function executeConfigPush(options, validatedEvent, logger, setTempDir, sn
     logger
   });
   const platform = getPlatform4(flowSettings);
-  const overrides = buildOverrides(
-    { mock: options.mock },
-    flowSettings
-  );
-  if (overrides.destinations) {
-    const { loadDestinationEnvs: loadDestinationEnvs2 } = await Promise.resolve().then(() => (init_env_loader(), env_loader_exports));
-    const configDir = buildOptions.configDir || process.cwd();
-    const envs = await loadDestinationEnvs2(
-      flowSettings.destinations ?? {},
-      flowSettings.packages,
-      configDir
-    );
-    for (const [destId, env] of Object.entries(envs)) {
-      if (overrides.destinations[destId] && env.push) {
-        overrides.destinations[destId].env = env.push;
-        if (env.simulation && env.simulation.length > 0) {
-          overrides.destinations[destId].simulation = env.simulation;
-        }
-      }
-    }
-  }
+  const overrides = buildOverrides({ mock: options.mock }, flowSettings);
   logger.debug("Bundling flow configuration");
   const tempDir = getTmpPath(
     void 0,
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
-  await fs15.ensureDir(tempDir);
-  const tempPath = path16.join(tempDir, "bundle.mjs");
+  await fs14.ensureDir(tempDir);
+  const tempPath = path15.join(tempDir, "bundle.mjs");
   const pushBuildOptions = {
     ...buildOptions,
     output: tempPath,
@@ -3862,9 +3948,9 @@ async function executeBundlePush(bundleContent, platform, validatedEvent, logger
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
-  await fs15.ensureDir(tempDir);
-  const tempPath = path16.join(tempDir, "bundle.mjs");
-  await fs15.writeFile(tempPath, bundleContent, "utf8");
+  await fs14.ensureDir(tempDir);
+  const tempPath = path15.join(tempDir, "bundle.mjs");
+  await fs14.writeFile(tempPath, bundleContent, "utf8");
   logger.debug(`Bundle written to: ${tempPath}`);
   logger.debug(
     `Executing in ${platform} environment (${platform === "web" ? "JSDOM" : "Node.js"})`
@@ -3883,7 +3969,15 @@ async function executeDestinationPush(esmPath, event, logger, platform, override
   const startTime = Date.now();
   const networkCalls = [];
   return withFlowContext(
-    { esmPath, platform, logger, snapshotCode, timeout, networkCalls, asyncDrain: { timeout: 5e3 } },
+    {
+      esmPath,
+      platform,
+      logger,
+      snapshotCode,
+      timeout,
+      networkCalls,
+      asyncDrain: { timeout: 5e3 }
+    },
     async (module) => {
       const config = module.wireConfig(module.__configData ?? void 0);
       applyOverrides(config, overrides || {});
@@ -3903,15 +3997,31 @@ async function executeDestinationPush(esmPath, event, logger, platform, override
     }
   );
 }
-async function simulateSource(configPath, input, options) {
+async function simulateSource(configOrPath, input, options) {
   const startTime = Date.now();
-  const prepared = await prepareFlow({
-    configPath,
+  let config;
+  if (typeof configOrPath === "string") {
+    config = await loadJsonConfig(configOrPath);
+  } else {
+    config = configOrPath;
+  }
+  const prepareInput = options.bundlePath ? {
+    mode: "prebuilt",
+    bundlePath: options.bundlePath,
+    config,
     flow: options.flow,
     simulate: ["source." + options.sourceId],
     silent: options.silent,
     verbose: options.verbose
-  });
+  } : {
+    mode: "build",
+    config,
+    flow: options.flow,
+    simulate: ["source." + options.sourceId],
+    silent: options.silent,
+    verbose: options.verbose
+  };
+  const prepared = await prepareFlow(prepareInput);
   try {
     const logger = createCLILogger({
       silent: options.silent,
@@ -3919,22 +4029,7 @@ async function simulateSource(configPath, input, options) {
     });
     const sourceConfig = (prepared.flowSettings.sources ?? {})[options.sourceId];
     if (!sourceConfig?.package) {
-      throw new Error(
-        `Source "${options.sourceId}" has no package defined`
-      );
-    }
-    const devPath = resolvePackageImportPath(
-      sourceConfig.package,
-      prepared.flowSettings.packages,
-      prepared.configDir,
-      "/dev"
-    );
-    const devModule = await import(devPath);
-    const createTrigger = devModule.examples?.createTrigger || devModule.default?.examples?.createTrigger;
-    if (!createTrigger) {
-      throw new Error(
-        `Source package "${sourceConfig.package}" has no createTrigger in /dev export`
-      );
+      throw new Error(`Source "${options.sourceId}" has no package defined`);
     }
     let snapshotCode;
     if (options.snapshot) {
@@ -3953,17 +4048,26 @@ async function simulateSource(configPath, input, options) {
         networkCalls
       },
       async (module) => {
-        const config = module.wireConfig(module.__configData ?? void 0);
-        applyOverrides(config, prepared.overrides);
+        const devExports = module.__devExports?.[sourceConfig.package];
+        const createTrigger = devExports?.examples?.createTrigger;
+        if (!createTrigger) {
+          throw new Error(
+            `Source package "${sourceConfig.package}" has no createTrigger in /dev export`
+          );
+        }
+        const flowConfig = module.wireConfig(module.__configData ?? void 0);
+        applyOverrides(flowConfig, prepared.overrides);
         const captured = [];
-        config.hooks = {
-          ...config.hooks || {},
+        flowConfig.hooks = {
+          ...flowConfig.hooks || {},
           prePush: ({ fn }, event) => {
             captured.push({ event, timestamp: Date.now() });
             return { ok: true };
           }
         };
-        const instance = await createTrigger(config, { sourceId: options.sourceId });
+        const instance = await createTrigger(flowConfig, {
+          sourceId: options.sourceId
+        });
         const { trigger } = instance;
         logger.info("Simulating source");
         const inputRecord = input ?? {};
@@ -3991,7 +4095,7 @@ async function simulateSource(configPath, input, options) {
     await prepared.cleanup();
   }
 }
-async function simulateTransformer(configPath, event, options) {
+async function simulateTransformer(configOrPath, event, options) {
   const startTime = Date.now();
   const parsed = schemas3.PartialEventSchema.safeParse(event);
   if (!parsed.success) {
@@ -4001,14 +4105,31 @@ async function simulateTransformer(configPath, event, options) {
       error: parsed.error.message
     };
   }
-  const prepared = await prepareFlow({
-    configPath,
+  let config;
+  if (typeof configOrPath === "string") {
+    config = await loadJsonConfig(configOrPath);
+  } else {
+    config = configOrPath;
+  }
+  const prepareInput = options.bundlePath ? {
+    mode: "prebuilt",
+    bundlePath: options.bundlePath,
+    config,
     flow: options.flow,
     simulate: ["transformer." + options.transformerId],
     mock: options.mock,
     silent: options.silent,
     verbose: options.verbose
-  });
+  } : {
+    mode: "build",
+    config,
+    flow: options.flow,
+    simulate: ["transformer." + options.transformerId],
+    mock: options.mock,
+    silent: options.silent,
+    verbose: options.verbose
+  };
+  const prepared = await prepareFlow(prepareInput);
   try {
     const logger = createCLILogger({
       silent: options.silent,
@@ -4031,11 +4152,11 @@ async function simulateTransformer(configPath, event, options) {
         networkCalls
       },
       async (module) => {
-        const config = module.wireConfig(module.__configData ?? void 0);
-        applyOverrides(config, prepared.overrides);
-        if (config.sources) config.sources = {};
-        if (config.destinations) config.destinations = {};
-        const result = await module.startFlow(config);
+        const flowConfig = module.wireConfig(module.__configData ?? void 0);
+        applyOverrides(flowConfig, prepared.overrides);
+        if (flowConfig.sources) flowConfig.sources = {};
+        if (flowConfig.destinations) flowConfig.destinations = {};
+        const result = await module.startFlow(flowConfig);
         if (!result?.collector)
           throw new Error("Invalid bundle: collector not available");
         const collector = result.collector;
@@ -4045,7 +4166,7 @@ async function simulateTransformer(configPath, event, options) {
             `Transformer "${options.transformerId}" not found in collector. Available: ${Object.keys(collector.transformers || {}).join(", ") || "none"}`
           );
         }
-        const initialized = await ee(
+        const initialized = await ne(
           collector,
           transformer,
           options.transformerId
@@ -4070,7 +4191,7 @@ async function simulateTransformer(configPath, event, options) {
             processedEvent
           );
           if (beforeChainIds.length > 0) {
-            const beforeResult = await te(
+            const beforeResult = await oe(
               collector,
               collector.transformers,
               beforeChainIds,
@@ -4091,7 +4212,7 @@ async function simulateTransformer(configPath, event, options) {
             processedEvent = Array.isArray(beforeResult) ? beforeResult[0] : beforeResult;
           }
         }
-        const pushResult = await ne(
+        const pushResult = await te(
           collector,
           transformer,
           options.transformerId,
@@ -4131,7 +4252,7 @@ async function simulateTransformer(configPath, event, options) {
     await prepared.cleanup();
   }
 }
-async function simulateDestination(configPath, event, options) {
+async function simulateDestination(configOrPath, event, options) {
   const startTime = Date.now();
   const parsed = schemas3.PartialEventSchema.safeParse(event);
   if (!parsed.success) {
@@ -4141,14 +4262,31 @@ async function simulateDestination(configPath, event, options) {
       error: parsed.error.message
     };
   }
-  const prepared = await prepareFlow({
-    configPath,
+  let config;
+  if (typeof configOrPath === "string") {
+    config = await loadJsonConfig(configOrPath);
+  } else {
+    config = configOrPath;
+  }
+  const prepareInput = options.bundlePath ? {
+    mode: "prebuilt",
+    bundlePath: options.bundlePath,
+    config,
     flow: options.flow,
     simulate: ["destination." + options.destinationId],
     mock: options.mock,
     silent: options.silent,
     verbose: options.verbose
-  });
+  } : {
+    mode: "build",
+    config,
+    flow: options.flow,
+    simulate: ["destination." + options.destinationId],
+    mock: options.mock,
+    silent: options.silent,
+    verbose: options.verbose
+  };
+  const prepared = await prepareFlow(prepareInput);
   try {
     const logger = createCLILogger({
       silent: options.silent,
@@ -4170,25 +4308,32 @@ async function simulateDestination(configPath, event, options) {
         networkCalls
       },
       async (module) => {
-        const config = module.wireConfig(module.__configData ?? void 0);
-        applyOverrides(config, prepared.overrides);
-        const destOverride = prepared.overrides.destinations?.[options.destinationId];
+        const flowConfig = module.wireConfig(module.__configData ?? void 0);
+        applyOverrides(flowConfig, prepared.overrides);
+        const destPkg = (prepared.flowSettings.destinations ?? {})[options.destinationId];
         let trackedCalls = [];
-        if (destOverride?.simulation?.length) {
-          const destinations = config.destinations;
-          const destConfig = destinations[options.destinationId]?.config;
-          if (destConfig?.env) {
-            const combined = {
-              ...destConfig.env,
-              simulation: destOverride.simulation
-            };
-            const { wrappedEnv, calls } = Ge(combined);
-            destConfig.env = wrappedEnv;
-            trackedCalls = calls;
+        if (destPkg?.package) {
+          const devExports = module.__devExports?.[destPkg.package];
+          const devEnv = devExports?.examples?.env;
+          if (devEnv?.push) {
+            const destinations = flowConfig.destinations;
+            const destConfig = destinations[options.destinationId]?.config;
+            if (destConfig) {
+              destConfig.env = devEnv.push;
+            }
+            if (devEnv.simulation?.length) {
+              const combined = {
+                ...devEnv.push,
+                simulation: devEnv.simulation
+              };
+              const { wrappedEnv, calls } = Ne(combined);
+              if (destConfig) destConfig.env = wrappedEnv;
+              trackedCalls = calls;
+            }
           }
         }
-        if (config.sources) config.sources = {};
-        const result = await module.startFlow(config);
+        if (flowConfig.sources) flowConfig.sources = {};
+        const result = await module.startFlow(flowConfig);
         if (!result?.collector)
           throw new Error("Invalid bundle: collector not available");
         const collector = result.collector;
@@ -4228,17 +4373,17 @@ init_core();
 init_tmp();
 init_config_file();
 init_auth();
-import path18 from "path";
+import path17 from "path";
 import { writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
 
 // src/runtime/resolve-bundle.ts
 init_stdin();
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
 function getDefaultWritePath() {
-  if (existsSync3("/app/flow")) return "/app/flow/bundle.mjs";
+  if (existsSync2("/app/flow")) return "/app/flow/bundle.mjs";
   return "/tmp/walkeros-bundle.mjs";
 }
 function isUrl2(value) {
@@ -4246,7 +4391,7 @@ function isUrl2(value) {
 }
 function writeBundleToDisk(writePath, content) {
   const dir = dirname(writePath);
-  if (!existsSync3(dir)) {
+  if (!existsSync2(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   writeFileSync2(writePath, content, "utf-8");
@@ -4272,7 +4417,7 @@ async function readBundleFromStdin(writePath) {
 }
 async function resolveBundle(bundleEnv) {
   const writePath = getDefaultWritePath();
-  if (!isUrl2(bundleEnv) && existsSync3(bundleEnv)) {
+  if (!isUrl2(bundleEnv) && existsSync2(bundleEnv)) {
     return { path: bundleEnv, source: "file" };
   }
   if (isUrl2(bundleEnv)) {
@@ -4327,7 +4472,7 @@ init_cache();
 
 // src/commands/run/validators.ts
 init_asset_resolver();
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 
 // src/schemas/primitives.ts
 import { z as z2 } from "@walkeros/core/dev";
@@ -4421,7 +4566,7 @@ var PushInputSchema = z7.object(PushInputShape);
 // src/commands/run/validators.ts
 function validateFlowFile(filePath) {
   const absolutePath = resolveAsset(filePath, "bundle");
-  if (!existsSync5(absolutePath)) {
+  if (!existsSync4(absolutePath)) {
     throw new Error(
       `Flow file not found: ${filePath}
    Resolved path: ${absolutePath}
@@ -4447,12 +4592,12 @@ init_utils3();
 // src/commands/run/pipeline.ts
 init_tmp();
 import { writeFileSync as writeFileSync4 } from "fs";
-import fs17 from "fs-extra";
+import fs16 from "fs-extra";
 
 // src/runtime/health-server.ts
 import http from "http";
 function createHealthServer(port, logger) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let flowHandler = null;
     const server = http.createServer((req, res) => {
       if (req.url === "/health" && req.method === "GET") {
@@ -4479,7 +4624,7 @@ function createHealthServer(port, logger) {
     server.headersTimeout = 1e4;
     server.listen(port, "0.0.0.0", () => {
       logger.info(`Health server listening on port ${port}`);
-      resolve3({
+      resolve4({
         server,
         setFlowHandler(handler) {
           flowHandler = handler;
@@ -4573,9 +4718,9 @@ import { randomBytes } from "crypto";
 
 // src/version.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
 import { dirname as dirname3, join as join3 } from "path";
-var versionFilename = fileURLToPath2(import.meta.url);
+var versionFilename = fileURLToPath(import.meta.url);
 var versionDirname = dirname3(versionFilename);
 function findPackageJson() {
   const paths = [
@@ -4868,7 +5013,7 @@ async function runPipeline(options) {
             await currentBundleCleanup().catch(() => {
             });
           if (currentConfigPath)
-            await fs17.remove(currentConfigPath).catch(() => {
+            await fs16.remove(currentConfigPath).catch(() => {
             });
           currentBundleCleanup = newBundleResult.cleanup;
           currentConfigPath = tmpConfigPath;
@@ -4895,7 +5040,7 @@ async function runPipeline(options) {
       await healthServer.close();
       if (currentBundleCleanup) await currentBundleCleanup().catch(() => {
       });
-      if (currentConfigPath) await fs17.remove(currentConfigPath).catch(() => {
+      if (currentConfigPath) await fs16.remove(currentConfigPath).catch(() => {
       });
       logger.info("Shutdown complete");
       clearTimeout(forceTimer);
@@ -5045,7 +5190,7 @@ async function resolveBundlePath(configInput, apiConfig, logger) {
       logger.info(`Bundle: ${resolved.path}`);
     }
     if (isPreBuiltConfig(resolved.path)) {
-      return path18.resolve(resolved.path);
+      return path17.resolve(resolved.path);
     }
     const flowFile = validateFlowFile(resolved.path);
     logger.debug("Building flow bundle");
@@ -5111,7 +5256,7 @@ async function resolveBundlePath(configInput, apiConfig, logger) {
   }
   const defaultFile = "server-collect.mjs";
   logger.debug(`No config specified, using default: ${defaultFile}`);
-  return path18.resolve(defaultFile);
+  return path17.resolve(defaultFile);
 }
 async function run(options) {
   const startTime = Date.now();
@@ -5371,18 +5516,29 @@ function validateFlow(input, options = {}) {
       }
     }
   }
-  const packages = config.packages;
-  if (packages && typeof packages === "object") {
-    for (const [pkgName, pkgConfig] of Object.entries(packages)) {
-      if (!pkgConfig.version && !pkgConfig.path) {
-        warnings.push({
-          path: `packages.${pkgName}`,
-          message: `Package "${pkgName}" has no version specified`,
-          suggestion: "Consider specifying a version for reproducible builds"
-        });
+  let totalPackageCount = 0;
+  if (flows && typeof flows === "object") {
+    for (const [flowName, flowValue] of Object.entries(
+      flows
+    )) {
+      const flow = flowValue;
+      const packages = flow.bundle?.packages;
+      if (packages && typeof packages === "object") {
+        for (const [pkgName, pkgConfig] of Object.entries(packages)) {
+          if (!pkgConfig.version && !pkgConfig.path) {
+            warnings.push({
+              path: `flows.${flowName}.bundle.packages.${pkgName}`,
+              message: `Package "${pkgName}" has no version specified`,
+              suggestion: "Consider specifying a version for reproducible builds"
+            });
+          }
+        }
+        totalPackageCount += Object.keys(packages).length;
       }
     }
-    details.packageCount = Object.keys(packages).length;
+  }
+  if (totalPackageCount > 0) {
+    details.packageCount = totalPackageCount;
   }
   if (coreResult.context) {
     details.context = coreResult.context;
@@ -6748,20 +6904,101 @@ async function feedbackCommand(text) {
   }
 }
 function promptUser(question) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stderr
     });
     rl.question(question, (answer) => {
       rl.close();
-      resolve3(answer);
+      resolve4(answer);
     });
   });
 }
 
 // src/index.ts
 init_bundle();
+
+// src/commands/bundle/wrap.ts
+init_bundler();
+import * as path18 from "path";
+import * as os2 from "os";
+import fs17 from "fs-extra";
+import * as esbuild2 from "esbuild";
+async function wrapSkeleton(options) {
+  const {
+    skeletonPath,
+    platform,
+    outputPath,
+    windowCollector,
+    windowElb,
+    target,
+    minify = true,
+    minifyOptions
+  } = options;
+  if (options.previewScope && !/^[a-zA-Z0-9_-]{1,64}$/.test(options.previewScope)) {
+    throw new Error(
+      `Invalid previewScope "${options.previewScope}". Must match /^[a-zA-Z0-9_-]{1,64}$/.`
+    );
+  }
+  if (options.previewOrigin && !/^[a-z0-9.-]+$/.test(options.previewOrigin)) {
+    throw new Error(
+      `Invalid previewOrigin "${options.previewOrigin}". Must be a bare hostname matching /^[a-z0-9.-]+$/.`
+    );
+  }
+  if (!await fs17.pathExists(skeletonPath)) {
+    throw new Error(`wrapSkeleton: skeleton not found at ${skeletonPath}`);
+  }
+  const absoluteSkeletonPath = path18.resolve(skeletonPath);
+  const entryText = platform === "browser" ? generateWrapEntry(absoluteSkeletonPath, {
+    ...windowCollector ? { windowCollector } : {},
+    ...windowElb ? { windowElb } : {},
+    ...options.previewOrigin ? { previewOrigin: options.previewOrigin } : {},
+    ...options.previewScope ? { previewScope: options.previewScope } : {}
+  }) : generateWrapEntryServer(absoluteSkeletonPath);
+  const entryDir = await fs17.mkdtemp(path18.join(os2.tmpdir(), "walkeros-wrap-"));
+  const entryPath = path18.join(entryDir, "entry.mjs");
+  try {
+    await fs17.writeFile(entryPath, entryText);
+    await fs17.ensureDir(path18.dirname(outputPath));
+    const esbuildOptions = {
+      entryPoints: [entryPath],
+      bundle: true,
+      format: "esm",
+      platform,
+      outfile: outputPath,
+      treeShaking: true,
+      logLevel: "error",
+      minify,
+      ...minify && {
+        minifyWhitespace: minifyOptions?.whitespace ?? true,
+        minifyIdentifiers: minifyOptions?.identifiers ?? true,
+        minifySyntax: minifyOptions?.syntax ?? true,
+        legalComments: minifyOptions?.legalComments ?? "none",
+        charset: "utf8"
+      }
+    };
+    if (platform === "browser") {
+      esbuildOptions.define = {
+        "process.env.NODE_ENV": '"production"',
+        global: "globalThis"
+      };
+      esbuildOptions.target = target ?? "es2018";
+    } else {
+      esbuildOptions.external = getNodeExternals();
+      esbuildOptions.banner = {
+        js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+      };
+      esbuildOptions.target = target ?? "node18";
+    }
+    await esbuild2.build(esbuildOptions);
+  } finally {
+    await fs17.remove(entryDir).catch(() => {
+    });
+  }
+}
+
+// src/index.ts
 init_auth();
 init_http();
 init_api_client();
@@ -6940,6 +7177,7 @@ export {
   validateCommand,
   whoami,
   whoamiCommand,
+  wrapSkeleton,
   writeConfig
 };
 //# sourceMappingURL=index.js.map