@walkeros/cli 4.6.0 → 4.7.0-next-1790187973605

package/dist/index.js

@@ -2689,6 +2689,7 @@ import path12 from "path";
 import fs11 from "fs-extra";
 import {
   packageNameToVariable as packageNameToVariable2,
+  getStepRuntimeProps,
   ENV_MARKER_PREFIX,
   SECRET_MARKER_PREFIX as SECRET_MARKER_PREFIX2,
   isPathStepEntry,
@@ -2701,29 +2702,25 @@ function isInlineCode2(code) {
 function hasCodeReference2(code) {
   return isInlineCode2(code) || typeof code === "string";
 }
-function generateInlineCode(inline, config, env, chains, isDestination) {
+function generateInlineCode(inline, runtimeProps, isDestination) {
   const pushFn = inline.push.replace("$code:", "");
   const initFn = inline.init ? inline.init.replace("$code:", "") : void 0;
   const typeLine = inline.type ? `type: '${inline.type}',` : "";
-  const chainLines = [];
-  if (chains?.before !== void 0) {
-    chainLines.push(`before: ${JSON.stringify(chains.before)}`);
-  }
-  if (chains?.next !== void 0) {
-    chainLines.push(`next: ${JSON.stringify(chains.next)}`);
-  }
-  const chainBlock = chainLines.length ? `,
-      ${chainLines.join(",\n      ")}` : "";
+  const props = {
+    config: {},
+    env: {},
+    ...runtimeProps
+  };
+  const propLines = Object.entries(props).map(([key, value]) => `${key}: ${processConfigValue(value)}`).join(",\n      ");
   if (isDestination) {
     return `{
       code: {
         ${typeLine}
-        config: ${processConfigValue(config || {})},
+        config: ${processConfigValue(props.config)},
         ${initFn ? `init: ${initFn},` : ""}
         push: ${pushFn}
       },
-      config: ${processConfigValue(config || {})},
-      env: ${processConfigValue(env || {})}${chainBlock}
+      ${propLines}
     }`;
   }
   return `{
@@ -2733,8 +2730,7 @@ function generateInlineCode(inline, config, env, chains, isDestination) {
         ${initFn ? `init: ${initFn},` : ""}
         push: ${pushFn}
       }),
-      config: ${processConfigValue(config || {})},
-      env: ${processConfigValue(env || {})}${chainBlock}
+      ${propLines}
     }`;
 }
 async function copyIncludes(includes, sourceDir, outputDir, logger) {
@@ -3461,24 +3457,11 @@ function buildSplitConfigObject(flowSettings, namedImports) {
     }
     return packageNameToVariable2(step.package);
   }
-  function getStepProps(step) {
-    const props = {};
-    for (const [key, value] of Object.entries(step)) {
-      if (key === "code" || key === "package" || key === "import") continue;
-      if (value !== void 0 && value !== null) {
-        props[key] = value;
-      }
-    }
-    return props;
-  }
-  function buildSplitStepEntry(section, stepId3, step) {
-    const codeVar = resolveCodeVar(step);
-    const stepProps = getStepProps(step);
-    const { codeProps, dataProps } = classifyStepProperties(stepProps);
+  function buildSplitStepEntry(section, stepId3, codeVar, runtimeProps) {
+    const { codeProps, dataProps } = classifyStepProperties(runtimeProps);
     const codeEntries = [];
-    codeEntries.push(`code: ${codeVar}`);
+    if (codeVar !== void 0) codeEntries.push(`code: ${codeVar}`);
     for (const [key, value] of Object.entries(codeProps)) {
-      if (key === "code") continue;
       codeEntries.push(`${key}: ${processConfigValue(value)}`);
     }
     for (const key of Object.keys(dataProps)) {
@@ -3492,6 +3475,14 @@ function buildSplitConfigObject(flowSettings, namedImports) {
       ${codeEntries.join(",\n      ")}
     }`;
   }
+  function buildStepEntry(kind, section, stepId3, step) {
+    const runtimeProps = getStepRuntimeProps(step, kind);
+    if (isInlineCode2(step.code)) {
+      return `    ${stepId3}: ${generateInlineCode(step.code, runtimeProps, kind === "Destination")}`;
+    }
+    const codeVar = isPathStepEntry({ ...step }, kind) ? void 0 : resolveCodeVar(step);
+    return buildSplitStepEntry(section, stepId3, codeVar, runtimeProps);
+  }
   Object.entries(sources).forEach(([name, source]) => {
     validateReference("Source", name, source);
   });
@@ -3501,75 +3492,21 @@ function buildSplitConfigObject(flowSettings, namedImports) {
   Object.entries(transformers).forEach(([name, transformer]) => {
     validateReference("Transformer", name, transformer);
   });
-  const sourcesEntries = Object.entries(sources).filter(([, source]) => source.package || hasCodeReference2(source.code)).map(([key, source]) => {
-    if (isInlineCode2(source.code)) {
-      return `    ${key}: ${generateInlineCode(source.code, source.config || {}, source.env, { next: source.next })}`;
-    }
-    return buildSplitStepEntry("sources", key, source);
-  });
-  const destinationsEntries = Object.entries(destinations).filter(([, dest]) => dest.package || hasCodeReference2(dest.code)).map(([key, dest]) => {
-    if (isInlineCode2(dest.code)) {
-      return `    ${key}: ${generateInlineCode(dest.code, dest.config || {}, dest.env, { before: dest.before, next: dest.next }, true)}`;
-    }
-    return buildSplitStepEntry("destinations", key, dest);
-  });
+  const sourcesEntries = Object.entries(sources).filter(([, source]) => source.package || hasCodeReference2(source.code)).map(([key, source]) => buildStepEntry("Source", "sources", key, source));
+  const destinationsEntries = Object.entries(destinations).filter(([, dest]) => dest.package || hasCodeReference2(dest.code)).map(
+    ([key, dest]) => buildStepEntry("Destination", "destinations", key, dest)
+  );
   const transformersEntries = Object.entries(transformers).filter(
     ([, transformer]) => transformer.package || hasCodeReference2(transformer.code) || isPathStepEntry({ ...transformer }, "Transformer")
-  ).map(([key, transformer]) => {
-    if (isInlineCode2(transformer.code)) {
-      return `    ${key}: ${generateInlineCode(transformer.code, transformer.config || {}, transformer.env, { before: transformer.before, next: transformer.next })}`;
-    }
-    if (isPathStepEntry({ ...transformer }, "Transformer")) {
-      const chainLines = [];
-      if (transformer.before !== void 0) {
-        chainLines.push(`before: ${JSON.stringify(transformer.before)}`);
-      }
-      if (transformer.next !== void 0) {
-        chainLines.push(`next: ${JSON.stringify(transformer.next)}`);
-      }
-      if (transformer.cache !== void 0) {
-        chainLines.push(`cache: ${JSON.stringify(transformer.cache)}`);
-      }
-      if (transformer.config !== void 0) {
-        chainLines.push(
-          `config: ${processConfigValue(transformer.config)}`
-        );
-      }
-      return `    ${key}: {
-      ${chainLines.join(",\n      ")}
-    }`;
-    }
-    return buildSplitStepEntry("transformers", key, transformer);
-  });
+  ).map(
+    ([key, transformer]) => buildStepEntry("Transformer", "transformers", key, transformer)
+  );
   Object.entries(stores).forEach(([name, store]) => {
     if (store.package || hasCodeReference2(store.code)) {
       validateReference("Store", name, store);
     }
   });
-  const storesEntries = Object.entries(stores).filter(([, store]) => store.package || hasCodeReference2(store.code)).map(([key, store]) => {
-    if (isInlineCode2(store.code)) {
-      return `    ${key}: ${generateInlineCode(store.code, store.config || {}, store.env)}`;
-    }
-    const codeVar = resolveCodeVar(store);
-    const storeProps = getStepProps(store);
-    const { codeProps, dataProps } = classifyStepProperties(storeProps);
-    const codeEntries = [];
-    codeEntries.push(`code: ${codeVar}`);
-    for (const [propKey, value] of Object.entries(codeProps)) {
-      if (propKey === "code") continue;
-      codeEntries.push(`${propKey}: ${processConfigValue(value)}`);
-    }
-    for (const propKey of Object.keys(dataProps)) {
-      codeEntries.push(`${propKey}: __data.stores.${key}.${propKey}`);
-    }
-    if (Object.keys(dataProps).length > 0) {
-      if (!dataPayloadObj["stores"]) dataPayloadObj["stores"] = {};
-      dataPayloadObj["stores"][key] = dataProps;
-    }
-    return `    ${key}: {
-      ${codeEntries.join(",\n      ")}
-    }`;
-  });
+  const storesEntries = Object.entries(stores).filter(([, store]) => store.package || hasCodeReference2(store.code)).map(([key, store]) => buildStepEntry("Store", "stores", key, store));
   const storesDeclaration = storesEntries.length > 0 ? `const stores = {
 ${storesEntries.join(",\n")}
 };` : "const stores = {};";
@@ -4486,17 +4423,11 @@ init_utils();
 init_bundler();
 import path16 from "path";
 import fs15 from "fs-extra";
-import {
-  createIngest,
-  getPlatform as getPlatform3,
-  getNextSteps,
-  buildCacheContext,
-  stepId
-} from "@walkeros/core";
+import { createIngest, getPlatform as getPlatform3, stepId } from "@walkeros/core";
 import {
   enrichEvent,
   transformerInit,
-  transformerPush,
+  runCollectorNext,
   runTransformerChain,
   wrapEnv
 } from "@walkeros/collector";
@@ -4564,6 +4495,11 @@ function buildOverrides(flags, flowConfig) {
         `--mock is not supported for sources. Use --simulate source.${parsed.name}`
       );
     }
+    if (parsed.type === "collector" && !parsed.chainType) {
+      throw new Error(
+        `Use --mock collector.next.TRANSFORMER=VALUE to mock a step of the collector's chain`
+      );
+    }
     if (parsed.type === "transformer" && !parsed.chainType) {
       throw new Error(
         `Use --mock destination.NAME.before.${parsed.name}=VALUE for path-specific transformer mocks`
@@ -4576,7 +4512,7 @@ function buildOverrides(flags, flowConfig) {
       parsedValue = valuePart;
     }
     if (parsed.chainType && parsed.transformerId) {
-      const chainPath = `destination.${parsed.name}.${parsed.chainType}`;
+      const chainPath = parsed.type === "collector" ? `collector.${parsed.chainType}` : `destination.${parsed.name}.${parsed.chainType}`;
       if (!overrides.transformerMocks) overrides.transformerMocks = {};
       if (!overrides.transformerMocks[chainPath])
         overrides.transformerMocks[chainPath] = {};
@@ -4613,6 +4549,19 @@ function parseStep(step) {
       missingName: (input, p) => `Invalid step format: "${input}". Missing name after "${p}."`
     }
   });
+  if (prefix === "collector" && rest.length > 0) {
+    if (name !== "next" || rest.length !== 1 || !rest[0]) {
+      throw new Error(
+        `Invalid step format: "${step}". Expected "collector.next.TRANSFORMER"`
+      );
+    }
+    return {
+      type: prefix,
+      name,
+      chainType: "next",
+      transformerId: rest[0]
+    };
+  }
   if (rest.length >= 2) {
     const chainType = rest[0];
     if (chainType !== "before" && chainType !== "next") {
@@ -5186,6 +5135,7 @@ async function runPushCommand(options) {
             {
               collectorName: plan.ids[0],
               flow: options.flow,
+              mock: options.mock,
               silent: options.silent,
               verbose: options.verbose,
               snapshot: options.snapshot
@@ -5268,37 +5218,6 @@ function getDevEnv(devModule) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every(isString);
 }
-function walkStaticChain(startId, transformers) {
-  const chain = [];
-  const visited = /* @__PURE__ */ new Set();
-  let current = startId;
-  while (current && transformers[current]) {
-    if (visited.has(current)) break;
-    visited.add(current);
-    chain.push(current);
-    const next = transformers[current].config?.next;
-    if (typeof next === "string") {
-      current = next;
-      continue;
-    }
-    if (Array.isArray(next) && next.every(isString)) {
-      chain.push(...next);
-      break;
-    }
-    break;
-  }
-  return chain;
-}
-function resolveBeforeChain(before, transformers, ingest, event) {
-  if (!before) return [];
-  if (Array.isArray(before) && before.every(isString)) {
-    return before;
-  }
-  const ids = getNextSteps(before, buildCacheContext(ingest, event));
-  if (ids.length === 0) return [];
-  if (ids.length === 1) return walkStaticChain(ids[0], transformers);
-  return ids;
-}
 async function pushCore(inputPath, event, options = {}) {
   const logger = createCLILogger({
     silent: options.silent,
@@ -5649,6 +5568,18 @@ async function simulateSource(configOrPath, input, options) {
     await prepared.cleanup();
   }
 }
+async function runTransformerSimulation(collector, transformerId, event, ingest) {
+  const result = await runTransformerChain(
+    collector,
+    collector.transformers,
+    transformerId,
+    event,
+    ingest,
+    void 0,
+    `transformer.${transformerId}`
+  );
+  return result.copies.map((copy) => copy.event);
+}
 async function simulateTransformer(configOrPath, event, options) {
   const startTime = Date.now();
   const parsed = schemas3.PartialEventSchema.safeParse(event);
@@ -5740,58 +5671,17 @@ async function simulateTransformer(configOrPath, event, options) {
         };
         const captured = [];
         logger.info(`Simulating transformer: ${options.transformerId}`);
-        let processedEvent = inputEvent;
-        const before = transformer.config.before;
-        if (before && collector.transformers) {
-          const beforeChainIds = resolveBeforeChain(
-            before,
-            collector.transformers,
-            ingest,
-            processedEvent
-          );
-          if (beforeChainIds.length > 0) {
-            const beforeResult = await runTransformerChain(
-              collector,
-              collector.transformers,
-              beforeChainIds,
-              processedEvent,
-              ingest,
-              void 0,
-              `transformer.${options.transformerId}.before`
-            );
-            if (beforeResult === null) {
-              captured.push({ event: null, timestamp: Date.now() });
-              await collector.command("shutdown");
-              return buildSimulationResult({
-                step: "transformer",
-                name: options.transformerId,
-                startTime,
-                captured
-              });
-            }
-            processedEvent = Array.isArray(beforeResult) ? beforeResult[0] : beforeResult;
-          }
-        }
-        const pushResult = await transformerPush(
+        const outputs = await runTransformerSimulation(
           collector,
-          transformer,
           options.transformerId,
-          processedEvent,
+          inputEvent,
           ingest
         );
-        if (pushResult === false) {
+        if (outputs.length === 0) {
           captured.push({ event: null, timestamp: Date.now() });
-        } else if (Array.isArray(pushResult)) {
-          for (const r of pushResult) {
-            captured.push({
-              event: r.event || processedEvent,
-              timestamp: Date.now()
-            });
-          }
-        } else if (pushResult && typeof pushResult === "object" && pushResult.event) {
-          captured.push({ event: pushResult.event, timestamp: Date.now() });
-        } else {
-          captured.push({ event: processedEvent, timestamp: Date.now() });
+        }
+        for (const output of outputs) {
+          captured.push({ event: output, timestamp: Date.now() });
         }
         await collector.command("shutdown");
         return buildSimulationResult({
@@ -5819,6 +5709,13 @@ async function simulateTransformer(configOrPath, event, options) {
     await prepared.cleanup();
   }
 }
+async function runCollectorSimulation(collector, event) {
+  const enriched = enrichEvent(collector, event);
+  const result = await runCollectorNext(collector, enriched, {
+    ingest: createIngest("collector")
+  });
+  return result.copies.map((copy) => copy.event);
+}
 async function simulateCollector(configOrPath, event, options) {
   const startTime = Date.now();
   const parsed = schemas3.PartialEventSchema.safeParse(event);
@@ -5842,6 +5739,7 @@ async function simulateCollector(configOrPath, event, options) {
     config,
     flow: options.flow,
     simulate: ["collector." + options.collectorName],
+    mock: options.mock,
     silent: options.silent,
     verbose: options.verbose
   } : {
@@ -5849,6 +5747,7 @@ async function simulateCollector(configOrPath, event, options) {
     config,
     flow: options.flow,
     simulate: ["collector." + options.collectorName],
+    mock: options.mock,
     silent: options.silent,
     verbose: options.verbose
   };
@@ -5895,8 +5794,11 @@ async function simulateCollector(configOrPath, event, options) {
           if (options.state.timing !== void 0)
             collector.timing = options.state.timing;
         }
-        const enriched = enrichEvent(collector, event);
-        const captured = [{ event: enriched, timestamp: Date.now() }];
+        const outputs = await runCollectorSimulation(collector, event);
+        const captured = outputs.length > 0 ? outputs.map((output) => ({
+          event: output,
+          timestamp: Date.now()
+        })) : [{ event: null, timestamp: Date.now() }];
         await collector.command("shutdown");
         return buildSimulationResult({
           step: "collector",
@@ -8120,6 +8022,7 @@ function validateEvent2(input) {
 // src/commands/validate/validators/flow.ts
 import {
   getFlowSettings as getFlowSettings2,
+  getRouteGraph,
   isObject as isObject5,
   resolveContracts,
   validateStepEntry as validateStepEntry2
@@ -8236,6 +8139,15 @@ function validateFlow(input, options = {}) {
   if (coreResult.context) {
     details.context = coreResult.context;
   }
+  if (errors.length === 0 && isFlowJson(input)) {
+    const typedFlows = input.flows;
+    const flowsToLint = options.flow ? options.flow in typedFlows ? [options.flow] : [] : Object.keys(typedFlows);
+    for (const name of flowsToLint) {
+      const flowSettings = typedFlows[name];
+      if (!flowSettings) continue;
+      lintFlowRoutes(name, flowSettings, errors, warnings);
+    }
+  }
   if (errors.length === 0 && isFlowJson(input)) {
     const typedFlows = input.flows;
     const flowNames = Object.keys(typedFlows);
@@ -8283,15 +8195,6 @@ function validateFlow(input, options = {}) {
       }
     }
   }
-  if (errors.length === 0 && isFlowJson(input)) {
-    const typedFlows = input.flows;
-    const flowsToLint = options.flow ? options.flow in typedFlows ? [options.flow] : [] : Object.keys(typedFlows);
-    for (const name of flowsToLint) {
-      const flowSettings = typedFlows[name];
-      if (!flowSettings) continue;
-      lintFlowRoutes(name, flowSettings, warnings);
-    }
-  }
   if (errors.length === 0 && isFlowJson(input)) {
     const flowsMap = input.flows;
     const flowsToResolve = options.flow ? options.flow in flowsMap ? [options.flow] : [] : Object.keys(flowsMap);
@@ -8325,48 +8228,19 @@ function validateFlow(input, options = {}) {
     details
   };
 }
-function isRouteConfig(spec) {
-  return typeof spec === "object" && spec !== null && !Array.isArray(spec);
-}
-function isRouteNext(spec) {
-  if (!("next" in spec)) return false;
-  const value = spec.next;
-  return value !== void 0;
-}
-function isRouteOne(spec) {
-  if (!("one" in spec)) return false;
-  const value = spec.one;
-  return Array.isArray(value);
-}
-function isRouteMany(spec) {
-  if (!("many" in spec)) return false;
-  const value = spec.many;
-  return Array.isArray(value);
-}
-function flattenRouteTargets(spec) {
-  if (!spec) return [];
-  if (typeof spec === "string") return [spec];
-  if (isRouteConfig(spec)) {
-    if (isRouteNext(spec)) return flattenRouteTargets(spec.next);
-    if (isRouteOne(spec)) {
-      return Array.from(new Set(spec.one.flatMap(flattenRouteTargets)));
-    }
-    if (isRouteMany(spec)) {
-      return Array.from(new Set(spec.many.flatMap(flattenRouteTargets)));
-    }
-    return [];
-  }
-  if (spec.length === 0) return [];
-  if (typeof spec[0] === "string") {
-    return spec.filter((s) => typeof s === "string");
+function routeTargets(spec) {
+  if (spec === void 0) return [];
+  const targets = /* @__PURE__ */ new Set();
+  for (const node of getRouteGraph(spec)) {
+    for (const target of node.targets) targets.add(target);
   }
-  return Array.from(new Set(spec.flatMap(flattenRouteTargets)));
+  return [...targets];
 }
 function buildConnectionGraph(config) {
   const connections = [];
   for (const [name, source] of Object.entries(config.sources || {})) {
     if (!source.next || !source.examples) continue;
-    const nextNames = flattenRouteTargets(source.next);
+    const nextNames = routeTargets(source.next);
     for (const nextName of nextNames) {
       const transformer = config.transformers?.[nextName];
       if (transformer?.examples) {
@@ -8383,7 +8257,7 @@ function buildConnectionGraph(config) {
   }
   for (const [name, transformer] of Object.entries(config.transformers || {})) {
     if (!transformer.next || !transformer.examples) continue;
-    const nextNames = flattenRouteTargets(transformer.next);
+    const nextNames = routeTargets(transformer.next);
     for (const nextName of nextNames) {
       const nextTransformer = config.transformers?.[nextName];
       if (nextTransformer?.examples) {
@@ -8404,7 +8278,7 @@ function buildConnectionGraph(config) {
   }
   for (const [name, dest] of Object.entries(config.destinations || {})) {
     if (!dest.before || !dest.examples) continue;
-    const beforeNames = flattenRouteTargets(dest.before);
+    const beforeNames = routeTargets(dest.before);
     for (const beforeName of beforeNames) {
       const transformer = config.transformers?.[beforeName];
       if (transformer?.examples) {
@@ -8422,8 +8296,8 @@ function buildConnectionGraph(config) {
   return connections;
 }
 function checkCompatibility(conn, errors, warnings) {
-  const fromOuts = Object.entries(conn.from.examples).filter(([, ex]) => ex.out !== void 0 && ex.out.length > 0).map(([name, ex]) => ({ name, value: ex.out }));
-  const toIns = Object.entries(conn.to.examples).filter(([, ex]) => ex.in !== void 0).map(([name, ex]) => ({ name, value: ex.in }));
+  const fromOuts = Object.entries(conn.from.examples).filter(([, ex]) => hasComparableOut(ex.out)).map(([name, ex]) => ({ name, value: ex.out }));
+  const toIns = Object.entries(conn.to.examples).filter(([, ex]) => ex.in !== void 0 && !ex.command).map(([name, ex]) => ({ name, value: ex.in }));
   const path20 = `${conn.from.type}.${conn.from.name} \u2192 ${conn.to.type}.${conn.to.name}`;
   if (fromOuts.length === 0 || toIns.length === 0) {
     warnings.push({
@@ -8451,6 +8325,10 @@ function checkCompatibility(conn, errors, warnings) {
     });
   }
 }
+function hasComparableOut(out) {
+  if (Array.isArray(out) || typeof out === "string") return out.length > 0;
+  return isObject5(out) && Object.keys(out).length > 0;
+}
 function isStructurallyCompatible(a, b) {
   if (typeof a !== typeof b) return false;
   if (a === null || b === null) return a === b;
@@ -8463,87 +8341,98 @@ function isStructurallyCompatible(a, b) {
   }
   return true;
 }
-function lintFlowRoutes(flowName, flow, warnings) {
+function lintFlowRoutes(flowName, flow, errors, warnings) {
+  const known = new Set(Object.keys(flow.transformers || {}));
+  const check = (spec, position) => {
+    if (spec !== void 0) lintRoute(spec, position, known, errors, warnings);
+  };
+  const at = `flows.${flowName}`;
   for (const [name, source] of Object.entries(flow.sources || {})) {
-    lintRoute(source.next, `flows.${flowName}.sources.${name}.next`, warnings);
-    lintRoute(
-      source.before,
-      `flows.${flowName}.sources.${name}.before`,
-      warnings
-    );
+    check(source.before, `${at}.sources.${name}.before`);
+    check(source.next, `${at}.sources.${name}.next`);
   }
   for (const [name, transformer] of Object.entries(flow.transformers || {})) {
-    lintRoute(
-      transformer.next,
-      `flows.${flowName}.transformers.${name}.next`,
-      warnings
-    );
-    lintRoute(
-      transformer.before,
-      `flows.${flowName}.transformers.${name}.before`,
-      warnings
-    );
+    check(transformer.before, `${at}.transformers.${name}.before`);
+    check(transformer.next, `${at}.transformers.${name}.next`);
   }
+  check(flow.collector?.next, `${at}.collector.next`);
   for (const [name, dest] of Object.entries(flow.destinations || {})) {
-    lintRoute(
-      dest.before,
-      `flows.${flowName}.destinations.${name}.before`,
-      warnings
-    );
-    lintRoute(
-      dest.next,
-      `flows.${flowName}.destinations.${name}.next`,
-      warnings
-    );
+    check(dest.before, `${at}.destinations.${name}.before`);
+    check(dest.next, `${at}.destinations.${name}.next`);
   }
 }
-function lintRoute(spec, position, warnings) {
-  if (!spec) return;
-  if (typeof spec === "string") return;
-  if (Array.isArray(spec)) {
-    for (let i = 0; i < spec.length; i++) {
-      const entry = spec[i];
-      if (i < spec.length - 1 && typeof entry === "object" && entry !== null && !Array.isArray(entry) && isRouteMany(entry)) {
+function routeAt(spec, path20) {
+  let current = spec;
+  for (const key of path20) {
+    if (typeof key === "number")
+      current = Array.isArray(current) ? current[key] : void 0;
+    else current = isObject5(current) ? current[key] : void 0;
+  }
+  return current;
+}
+function lintRoute(spec, position, known, errors, warnings) {
+  const where = (path20) => path20.length > 0 ? `${position}.${path20.join(".")}` : position;
+  const reported = /* @__PURE__ */ new Set();
+  const once = (key) => {
+    if (reported.has(key)) return false;
+    reported.add(key);
+    return true;
+  };
+  for (const node of getRouteGraph(spec)) {
+    for (const target of node.targets) {
+      if (known.has(target) || !once(`unknown:${target}`)) continue;
+      errors.push({
+        path: position,
+        message: `Unknown transformer "${target}" in route at ${position}`,
+        code: "UNKNOWN_ROUTE_TARGET"
+      });
+    }
+    const last = node.path[node.path.length - 1];
+    if (node.stop && !node.match && node.kind !== "many") {
+      const self = routeAt(spec, node.path);
+      const list = routeAt(spec, node.path.slice(0, -1));
+      if (isObject5(self) && self.stop === true && typeof last === "number" && Array.isArray(list) && last < list.length - 1 && once(`stop:${where(node.path)}`)) {
+        const at = where(node.path);
         warnings.push({
-          path: position,
-          message: `dead code after many at ${position}: main chain terminates at the many operator`,
-          suggestion: "Remove entries after the many operator; move them into each many branch if they should still run."
+          path: at,
+          message: `dead code after stop at ${at}: entries after an unconditional stop never run`,
+          suggestion: "Remove the entries after the stop, or give the stop a match."
         });
       }
-      lintRoute(entry, `${position}[${i}]`, warnings);
-    }
-    return;
-  }
-  if (isRouteNext(spec)) {
-    lintRoute(spec.next, `${position}.next`, warnings);
-    return;
-  }
-  if (isRouteOne(spec)) {
-    for (let i = 0; i < spec.one.length; i++) {
-      lintRoute(spec.one[i], `${position}.one[${i}]`, warnings);
     }
-    return;
-  }
-  if (isRouteMany(spec)) {
-    if (spec.many.length === 0) {
-      warnings.push({
-        path: position,
-        message: `empty many at ${position}: main chain terminates with no branches; use next or remove`,
-        suggestion: "Add one or more branch targets to many, or replace many with next if no fan-out is needed."
-      });
-    } else if (spec.many.length === 1) {
-      const only = spec.many[0];
-      const hint = typeof only === "string" ? `use 'next: "${only}"' for clarity` : `use 'next' for clarity`;
+    if (node.kind === "many" && last === "many" && node.targets.length === 0 && once(`empty:${where(node.path)}`)) {
+      const at = where(node.path.slice(0, -1));
       warnings.push({
-        path: position,
-        message: `single-entry many at ${position}: ${hint}`,
-        suggestion: "Replace many with next when only one branch exists."
+        path: at,
+        message: `empty many at ${at}: selects no branch, so it has no effect`,
+        suggestion: "Add two or more branch targets to many, or remove it."
       });
     }
-    for (let i = 0; i < spec.many.length; i++) {
-      lintRoute(spec.many[i], `${position}.many[${i}]`, warnings);
+    for (const decision of [...node.via ?? [], node]) {
+      const index = decision.path[decision.path.length - 1];
+      if (typeof index !== "number") continue;
+      const listPath = decision.path.slice(0, -1);
+      const list = routeAt(spec, listPath);
+      if (!Array.isArray(list)) continue;
+      const at = where(listPath);
+      if (decision.kind === "many" && list.length === 1 && once(`single:${at}`)) {
+        const only = list[0];
+        const hint = typeof only === "string" ? `use 'next: "${only}"' for clarity` : `use 'next' for clarity`;
+        warnings.push({
+          path: at,
+          message: `single-entry many at ${at}: ${hint}`,
+          suggestion: "Replace many with next when only one branch exists."
+        });
+      }
+      const explicitOne = listPath[listPath.length - 1] === "one";
+      if (decision.kind === "one" && !explicitOne && list.length > 1 && once(`first-match:${at}`)) {
+        warnings.push({
+          path: at,
+          message: `first-match array at ${at}: an array made only of route configs is an implicit one, the first matching entry wins`,
+          suggestion: 'Write { "one": [...] } explicitly, or add the step ids as a sequence to run every entry in order.'
+        });
+      }
     }
-    return;
   }
 }
 function checkContractCompliance(config, contract, errors, warnings, strict) {
@@ -8641,7 +8530,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.6.0";
+var CLIENT_HEADER = "walkeros-cli/4.7.0-next-1790187973605";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path20, flowConfig) {
   const flows = flowConfig.flows;
@@ -8748,7 +8637,7 @@ async function validateEntry(path20, flowConfig) {
   }
   const config = entry.config;
   const settings = config?.settings;
-  const ajv = new Ajv({ allErrors: true });
+  const ajv = new Ajv({ allErrors: true, validateFormats: false });
   const validate2 = ajv.compile(settingsSchema);
   const isValid = validate2(settings || {});
   if (!isValid) {
@@ -8778,10 +8667,8 @@ async function validateEntry(path20, flowConfig) {
 async function validate(type, input, options = {}) {
   let resolved = input;
   if (typeof input === "string") {
-    resolved = await loadJsonFromSource(input, {
-      name: type,
-      required: true
-    });
+    if (input.trim() === "") throw new Error(`${type} is required`);
+    resolved = await loadJsonConfig(input);
   }
   if (options.path) {
     return validateEntry(options.path, resolved);
@@ -10897,108 +10784,6 @@ init_config_file();
 init_sse();
 init_utils();
 
-// src/commands/simulate/example-loader.ts
-function findExample(config, exampleName, stepTarget) {
-  if (stepTarget) {
-    return findExampleInStep(config, exampleName, stepTarget);
-  }
-  return findExampleAcrossSteps(config, exampleName);
-}
-function findExampleInStep(config, exampleName, stepTarget) {
-  const dotIndex = stepTarget.indexOf(".");
-  if (dotIndex === -1) {
-    throw new Error(
-      `Invalid --step format: "${stepTarget}". Expected "type.name" (e.g. "destination.gtag")`
-    );
-  }
-  const type = stepTarget.substring(0, dotIndex);
-  const name = stepTarget.substring(dotIndex + 1);
-  const stepMap = getStepMap(config, type);
-  if (!stepMap) {
-    throw new Error(`No ${type}s found in flow config`);
-  }
-  const step = stepMap[name];
-  if (!step) {
-    const available = Object.keys(stepMap).join(", ");
-    throw new Error(`${type} "${name}" not found. Available: ${available}`);
-  }
-  const examples = step.examples;
-  if (!examples || !examples[exampleName]) {
-    const available = examples ? Object.keys(examples).join(", ") : "none";
-    throw new Error(
-      `Example "${exampleName}" not found in ${type} "${name}". Available: ${available}`
-    );
-  }
-  return {
-    stepType: type,
-    stepName: name,
-    exampleName,
-    example: examples[exampleName]
-  };
-}
-function findExampleAcrossSteps(config, exampleName) {
-  const matches = [];
-  const stepTypes = ["source", "transformer", "destination"];
-  for (const type of stepTypes) {
-    const stepMap = getStepMap(config, type);
-    if (!stepMap) continue;
-    for (const [name, step] of Object.entries(stepMap)) {
-      const examples = step.examples;
-      if (examples && examples[exampleName]) {
-        matches.push({
-          stepType: type,
-          stepName: name,
-          exampleName,
-          example: examples[exampleName]
-        });
-      }
-    }
-  }
-  if (matches.length === 0) {
-    throw new Error(`Example "${exampleName}" not found in any step`);
-  }
-  if (matches.length > 1) {
-    const locations = matches.map((m) => `${m.stepType}.${m.stepName}`).join(", ");
-    throw new Error(
-      `Example "${exampleName}" found in multiple steps: ${locations}. Use --step to disambiguate.`
-    );
-  }
-  return matches[0];
-}
-function getStepMap(config, type) {
-  switch (type) {
-    case "source":
-      return config.sources;
-    case "transformer":
-      return config.transformers;
-    case "destination":
-      return config.destinations;
-    default:
-      throw new Error(
-        `Invalid step type: "${type}". Must be "source", "transformer", or "destination"`
-      );
-  }
-}
-
-// src/commands/simulate/compare.ts
-function compareOutput(expected, actual) {
-  const expectedStr = JSON.stringify(expected, null, 2);
-  const actualStr = JSON.stringify(actual, null, 2);
-  if (expectedStr === actualStr) {
-    return { expected, actual, match: true };
-  }
-  return {
-    expected,
-    actual,
-    match: false,
-    diff: `Expected:
-${expectedStr}
-
-Actual:
-${actualStr}`
-  };
-}
-
 // src/telemetry/index.ts
 var telemetry_exports = {};
 __export(telemetry_exports, {
@@ -11217,7 +11002,6 @@ export {
   clearAuthFields,
   clientContextHeaders,
   compareContract,
-  compareOutput,
   completeDeviceLogin,
   containsCodeMarkers,
   createApiClient,
@@ -11251,7 +11035,6 @@ export {
   feedback,
   feedbackCommand,
   fetchHealth,
-  findExample,
   getAuthHeaders,
   getClientContext,
   getDefaultProject,