@walkeros/cli 4.8.2 → 4.8.3-next-1793115089237

package/dist/index.js

@@ -862,6 +862,9 @@ function getFlowSection(flow, section) {
       return flow.stores;
   }
 }
+function isLocalPath(spec) {
+  return spec.startsWith(".") || spec.startsWith("/");
+}
 function parsePackageSpec(spec) {
   const at = spec.lastIndexOf("@");
   if (at <= 0) return { name: spec };
@@ -917,8 +920,7 @@ function applyStepPackages(flowSettings, packages, logger) {
     }
   };
   for (const pkg of stepPackages) {
-    const isLocalPath = pkg.startsWith(".") || pkg.startsWith("/");
-    if (isLocalPath) {
+    if (isLocalPath(pkg)) {
       const varName = packageNameToVariable(pkg);
       if (!packages[varName]) {
         packages[varName] = {
@@ -963,6 +965,40 @@ function applyStepPackages(flowSettings, packages, logger) {
     }
   }
 }
+var KIND_TO_SECTION = {
+  source: "sources",
+  transformer: "transformers",
+  destination: "destinations",
+  store: "stores"
+};
+function resolveStepPackage(flow, kind, id, logger) {
+  const normalizedFlow = structuredClone(flow);
+  const packages = structuredClone(
+    normalizedFlow.config?.bundle?.packages ?? {}
+  );
+  applyStepPackages(normalizedFlow, packages, logger);
+  const bucket = getFlowSection(normalizedFlow, KIND_TO_SECTION[kind]);
+  const step = bucket?.[id];
+  if (!step) {
+    const available = Object.keys(bucket ?? {}).join(", ") || "(none)";
+    throw new Error(
+      `${kind} "${id}" not found in flow. Available: ${available}`
+    );
+  }
+  if (typeof step.package !== "string") {
+    throw new Error(
+      `${kind}.${id} has no "package" (inline code cannot be set up).`
+    );
+  }
+  const declared = getFlowSection(flow, KIND_TO_SECTION[kind])?.[id]?.package;
+  return {
+    packageName: step.package,
+    label: declared !== void 0 && isLocalPath(declared) ? declared : step.package,
+    spec: packages[step.package] ?? {},
+    overrides: normalizedFlow.config?.bundle?.overrides ?? {},
+    normalizedFlow
+  };
+}
 
 // src/core/package-manager.ts
 import pacote from "pacote";
@@ -6034,7 +6070,7 @@ async function simulateDestination(configOrPath, event, options) {
 import * as fs20 from "fs";
 import * as path20 from "path";
 import chalk2 from "chalk";
-import { isObject as isObject10 } from "@walkeros/core";
+import { isObject as isObject11 } from "@walkeros/core";
 
 // src/commands/validate/validators/contract.ts
 import { CONTRACT_RULE_KEYS, isObject as isObject5 } from "@walkeros/core";
@@ -6236,7 +6272,7 @@ import {
   ENV_MARKER_PREFIX as ENV_MARKER_PREFIX3,
   getByPath,
   getRouteGraph,
-  isObject as isObject8,
+  isObject as isObject9,
   REF_CONTRACT,
   resolveContracts,
   SECRET_MARKER_PREFIX as SECRET_MARKER_PREFIX4,
@@ -6435,19 +6471,52 @@ function resolutionCode(error) {
 }
 
 // src/commands/validate/validators/settings.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
 import Ajv from "ajv";
 import {
+  createLogger,
   ENV_MARKER_PREFIX as ENV_MARKER_PREFIX2,
-  fetchPackage,
   getErrorMessage as getErrorMessage3,
-  isObject as isObject7,
+  isObject as isObject8,
   REF_CODE_PREFIX,
   REF_STORE,
   SECRET_MARKER_PREFIX as SECRET_MARKER_PREFIX3
 } from "@walkeros/core";
-var CLIENT_HEADER = "walkeros-cli/4.8.2";
+
+// src/core/package-info.ts
+import * as fs19 from "fs";
+import * as path19 from "path";
+import { fetchPackage, isObject as isObject7, parseWalkerOSJson } from "@walkeros/core";
+function readJson(file) {
+  return JSON.parse(fs19.readFileSync(file, "utf-8"));
+}
+async function readStepPackageInfo(resolved, options) {
+  const { packageName, spec } = resolved;
+  if (spec.path === void 0)
+    return fetchPackage(packageName, {
+      ...spec.version ? { version: spec.version } : {},
+      client: options.client
+    });
+  if (options.configDir === void 0)
+    throw new Error(
+      "it is a local path package and the input is not a file, so there is no directory to read it from"
+    );
+  const root = path19.isAbsolute(spec.path) ? spec.path : path19.resolve(options.configDir, spec.path);
+  const file = [
+    path19.join(root, "dist", "walkerOS.json"),
+    path19.join(root, "walkerOS.json")
+  ].find((candidate) => fs19.existsSync(candidate));
+  if (!file) throw new Error(`no walkerOS.json under ${root}`);
+  const meta = readJson(file);
+  if (!isObject7(meta)) throw new Error(`${file} is not a JSON object`);
+  const pkgFile = path19.join(root, "package.json");
+  const pkg = fs19.existsSync(pkgFile) ? readJson(pkgFile) : void 0;
+  const version = isObject7(pkg) && typeof pkg.version === "string" ? pkg.version : void 0;
+  return { ...parseWalkerOSJson(meta), ...version ? { version } : {} };
+}
+
+// src/commands/validate/validators/settings.ts
+var CLIENT_HEADER = "walkeros-cli/4.8.3-next-1793115089237";
+var LOGGER = createLogger();
 function createSettingsContext(configDir) {
   return { configDir, cache: /* @__PURE__ */ new Map(), compiled: /* @__PURE__ */ new Map() };
 }
@@ -6458,7 +6527,7 @@ function selectSettingsSchema(pkg, packageLabel, exportName) {
       pkg.exportSchemas,
       exportName
     ) ? pkg.exportSchemas[exportName] : void 0;
-    if (!isObject7(entry))
+    if (!isObject8(entry))
       return {
         ok: false,
         reason: `${packageLabel} has no export "${exportName}"`
@@ -6486,7 +6555,7 @@ function valueAt(root, segments) {
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) current = current[Number(segment)];
-    else if (isObject7(current)) current = current[segment];
+    else if (isObject8(current)) current = current[segment];
     else return void 0;
   }
   return current;
@@ -6501,7 +6570,7 @@ function prepareSettings(settings) {
   const walk = (value, segments) => {
     if (Array.isArray(value))
       return value.map((item, index) => walk(item, [...segments, `${index}`]));
-    if (isObject7(value))
+    if (isObject8(value))
       return Object.fromEntries(
         Object.entries(value).map(([key, item]) => [
           key,
@@ -6545,62 +6614,9 @@ function prepareSettings(settings) {
 function isUnder(segments, prefix) {
   return prefix.every((segment, index) => segments[index] === segment);
 }
-function bundlePin(rawFlow, name) {
-  const config = isObject7(rawFlow) ? rawFlow.config : void 0;
-  const bundle2 = isObject7(config) ? config.bundle : void 0;
-  const packages = isObject7(bundle2) ? bundle2.packages : void 0;
-  const pin = isObject7(packages) ? packages[name] : void 0;
-  if (!isObject7(pin)) return {};
-  return {
-    ...typeof pin.version === "string" ? { version: pin.version } : {},
-    ...typeof pin.path === "string" ? { path: pin.path } : {}
-  };
-}
-function packageSource(spec, rawFlow) {
-  if (spec.startsWith(".") || spec.startsWith("/"))
-    return { name: spec, localPath: spec };
-  const { name, version } = parsePackageSpec(spec);
-  const pin = bundlePin(rawFlow, name);
-  if (pin.path) return { name, localPath: pin.path };
-  const pinned = pin.version ?? version;
-  return pinned ? { name, version: pinned } : { name };
-}
-function readJson(file) {
-  return JSON.parse(fs19.readFileSync(file, "utf-8"));
-}
-function readLocalSchema(source, configDir) {
-  const localPath = source.localPath ?? "";
-  const root = path19.isAbsolute(localPath) ? localPath : path19.resolve(configDir, localPath);
-  const file = [
-    path19.join(root, "dist", "walkerOS.json"),
-    path19.join(root, "walkerOS.json")
-  ].find((candidate) => fs19.existsSync(candidate));
-  if (!file) throw new Error(`no walkerOS.json under ${root}`);
-  const meta = readJson(file);
-  const pkgFile = path19.join(root, "package.json");
-  const pkg = fs19.existsSync(pkgFile) ? readJson(pkgFile) : void 0;
-  const schemas6 = isObject7(meta) ? meta.schemas : void 0;
-  const exportSchemas = isObject7(meta) ? meta.exportSchemas : void 0;
-  const declared = isObject7(meta) && isObject7(meta.$meta) ? meta.$meta.exports : void 0;
-  const version = isObject7(pkg) && typeof pkg.version === "string" ? pkg.version : void 0;
-  return {
-    ...version ? { version } : {},
-    settings: isObject7(schemas6) ? schemas6.settings : void 0,
-    ...isObject7(exportSchemas) ? { exportSchemas } : {},
-    ...isObject7(declared) ? { exports: Object.keys(declared) } : {}
-  };
-}
-async function loadSchema(source, context2) {
-  if (source.localPath !== void 0) {
-    const configDir = context2.configDir;
-    if (configDir === void 0)
-      throw new Error(
-        "it is a local path package and the input is not a file, so there is no directory to read it from"
-      );
-    return readLocalSchema(source, configDir);
-  }
-  const info = await fetchPackage(source.name, {
-    ...source.version ? { version: source.version } : {},
+async function loadSchema(resolved, context2) {
+  const info = await readStepPackageInfo(resolved, {
+    configDir: context2.configDir,
     client: CLIENT_HEADER
   });
   return {
@@ -6611,7 +6627,7 @@ async function loadSchema(source, context2) {
   };
 }
 function compileSettings(settings) {
-  if (!isObject7(settings)) return void 0;
+  if (!isObject8(settings)) return void 0;
   const ajv = new Ajv({ allErrors: true, validateFormats: false });
   try {
     return { ok: true, validate: ajv.compile(settings) };
@@ -6619,26 +6635,26 @@ function compileSettings(settings) {
     return { ok: false, message: getErrorMessage3(error) };
   }
 }
-function sourceKey(source) {
-  return source.localPath ? `path:${source.localPath}` : `${source.name}@${source.version ?? "latest"}`;
+function sourceKey({ packageName, spec }) {
+  return spec.path !== void 0 ? `path:${spec.path}` : `${packageName}@${spec.version ?? "latest"}`;
 }
-function cachedSchema(source, context2) {
-  const key = sourceKey(source);
+function cachedSchema(resolved, context2) {
+  const key = sourceKey(resolved);
   let pending = context2.cache.get(key);
   if (!pending) {
-    pending = loadSchema(source, context2);
+    pending = loadSchema(resolved, context2);
     context2.cache.set(key, pending);
   }
   return pending;
 }
-function cachedCompile(source, exportName, settings, context2) {
-  const key = `${sourceKey(source)}#${exportName ?? ""}`;
+function cachedCompile(resolved, exportName, settings, context2) {
+  const key = `${sourceKey(resolved)}#${exportName ?? ""}`;
   if (context2.compiled.has(key)) return context2.compiled.get(key);
   const compiled = compileSettings(settings);
   context2.compiled.set(key, compiled);
   return compiled;
 }
-async function checkStepSettings(target, resolvedFlow, rawFlow, check, context2) {
+async function checkStepSettings(target, resolvedFlow, check, context2) {
   const at = `flows.${target.flow}.${target.section}.${target.key}`;
   const outcome = { findings: [], skipped: [], deferred: [] };
   const spec = typeof target.entry.package === "string" ? target.entry.package : "";
@@ -6651,33 +6667,51 @@ async function checkStepSettings(target, resolvedFlow, rawFlow, check, context2)
     });
     return outcome;
   }
-  const source = packageSource(spec, rawFlow);
+  let resolved;
+  try {
+    resolved = resolveStepPackage(
+      resolvedFlow,
+      SECTION_KIND[target.section],
+      target.key,
+      LOGGER
+    );
+  } catch (error) {
+    outcome.skipped.push({
+      path: at,
+      check,
+      reason: `Schema for ${spec} could not be loaded: ${getErrorMessage3(error)}`,
+      code: "SCHEMA_UNAVAILABLE"
+    });
+    return outcome;
+  }
+  const { label } = resolved;
+  const pinned = resolved.spec.path === void 0 ? resolved.spec.version : void 0;
   let schema;
   try {
-    schema = await cachedSchema(source, context2);
+    schema = await cachedSchema(resolved, context2);
   } catch (error) {
     outcome.skipped.push({
       path: at,
       check,
-      reason: `Schema for ${source.name}${source.version ? `@${source.version}` : ""} could not be loaded: ${getErrorMessage3(error)}`,
+      reason: `Schema for ${label}${pinned ? `@${pinned}` : ""} could not be loaded: ${getErrorMessage3(error)}`,
       code: "SCHEMA_UNAVAILABLE"
     });
     return outcome;
   }
   outcome.checked = {
     path: at,
-    package: source.name,
+    package: label,
     ...schema.version ? { version: schema.version } : {}
   };
   const { exportName } = resolveExportName(
-    resolvedFlow,
+    resolved.normalizedFlow,
     SECTION_KIND[target.section],
     target.key
   );
-  const version = schema.version ?? source.version;
+  const version = schema.version ?? pinned;
   const selection = selectSettingsSchema(
     schema,
-    version ? `${source.name}@${version}` : source.name,
+    version ? `${label}@${version}` : label,
     exportName
   );
   if (!selection.ok) {
@@ -6690,7 +6724,7 @@ async function checkStepSettings(target, resolvedFlow, rawFlow, check, context2)
     return outcome;
   }
   const compiled = cachedCompile(
-    source,
+    resolved,
     exportName,
     selection.settings,
     context2
@@ -6699,7 +6733,7 @@ async function checkStepSettings(target, resolvedFlow, rawFlow, check, context2)
     outcome.skipped.push({
       path: at,
       check,
-      reason: `Package ${source.name} has no settings schema`,
+      reason: `Package ${label} has no settings schema`,
       code: "NO_SETTINGS_SCHEMA"
     });
     return outcome;
@@ -6708,14 +6742,14 @@ async function checkStepSettings(target, resolvedFlow, rawFlow, check, context2)
     outcome.skipped.push({
       path: at,
       check,
-      reason: `The settings schema of ${source.name} cannot be compiled: ${compiled.message}`,
+      reason: `The settings schema of ${label} cannot be compiled: ${compiled.message}`,
       code: "SCHEMA_UNAVAILABLE"
     });
     return outcome;
   }
   const validate2 = compiled.validate;
   const step = stepOf(resolvedFlow, target.section, target.key);
-  const config = isObject7(step?.config) ? step.config : {};
+  const config = isObject8(step?.config) ? step.config : {};
   const prepared = prepareSettings(config.settings ?? {});
   const base = `${at}.config.settings`;
   for (const { segments, reference } of prepared.deferred) {
@@ -6796,18 +6830,12 @@ async function validateFlowWithPackages(input, options = {}) {
       continue;
     }
     for (const section of ENTRY_SECTIONS) {
-      const steps = isObject8(rawFlow[section]) ? rawFlow[section] : {};
+      const steps = isObject9(rawFlow[section]) ? rawFlow[section] : {};
       for (const [key, entry] of Object.entries(steps)) {
-        if (!isObject8(entry) || entry.package === void 0) continue;
+        if (!isObject9(entry) || entry.package === void 0) continue;
         const target = { flow: name, section, key, entry };
         pending.push(
-          checkStepSettings(
-            target,
-            flow,
-            rawFlow,
-            "flow:package-settings",
-            context2
-          )
+          checkStepSettings(target, flow, "flow:package-settings", context2)
         );
       }
     }
@@ -6862,9 +6890,9 @@ function runFlowChecks(input, options) {
     };
   }
   errors.push(...scope.errors);
-  const config = isObject8(input) ? input : {};
+  const config = isObject9(input) ? input : {};
   const flowsValue = config.flows;
-  const flows = isObject8(flowsValue) ? flowsValue : void 0;
+  const flows = isObject9(flowsValue) ? flowsValue : void 0;
   const allFlows = scope.allFlows;
   const inScope = (path23) => {
     const flow = flowOfPath(path23, allFlows);
@@ -6907,13 +6935,13 @@ function runFlowChecks(input, options) {
   checks.push("flow:steps");
   for (const flowName of scope.flows) {
     const flowValue = flows?.[flowName];
-    if (!isObject8(flowValue)) continue;
+    if (!isObject9(flowValue)) continue;
     const transformersValue = flowValue.transformers;
-    if (isObject8(transformersValue)) {
+    if (isObject9(transformersValue)) {
       for (const [name, transformerValue] of Object.entries(
         transformersValue
       )) {
-        if (!isObject8(transformerValue)) continue;
+        if (!isObject9(transformerValue)) continue;
         const result2 = validateStepEntry(transformerValue, "Transformer");
         if (!result2.ok) {
           errors.push({
@@ -6926,9 +6954,9 @@ function runFlowChecks(input, options) {
     }
     for (const [section, kind] of STEP_KINDS2) {
       const steps = flowValue[section];
-      if (!isObject8(steps)) continue;
+      if (!isObject9(steps)) continue;
       for (const [name, step] of Object.entries(steps)) {
-        if (!isObject8(step)) continue;
+        if (!isObject9(step)) continue;
         const at = `flows.${flowName}.${section}.${name}`;
         errors.push(...checkStepKeys(step, kind, at));
         const pkg = step.package;
@@ -6951,15 +6979,15 @@ function runFlowChecks(input, options) {
   let totalPackageCount = 0;
   for (const flowName of scope.flows) {
     const flowValue = flows?.[flowName];
-    if (!isObject8(flowValue)) continue;
+    if (!isObject9(flowValue)) continue;
     const flowConfig = flowValue.config;
-    if (!isObject8(flowConfig)) continue;
+    if (!isObject9(flowConfig)) continue;
     const bundle2 = flowConfig.bundle;
-    if (!isObject8(bundle2)) continue;
+    if (!isObject9(bundle2)) continue;
     const packages = bundle2.packages;
-    if (!isObject8(packages)) continue;
+    if (!isObject9(packages)) continue;
     for (const [pkgName, pkgConfigValue] of Object.entries(packages)) {
-      if (!isObject8(pkgConfigValue)) continue;
+      if (!isObject9(pkgConfigValue)) continue;
       if (!pkgConfigValue.version && !pkgConfigValue.path) {
         warnings.push({
           path: `flows.${flowName}.config.bundle.packages.${pkgName}`,
@@ -7047,13 +7075,13 @@ function runFlowChecks(input, options) {
           warnings,
           options.strict === true,
           skipped,
-          isObject8(resolvedConfig) && isObject8(resolvedConfig.settings) ? resolvedConfig.settings : void 0
+          isObject9(resolvedConfig) && isObject9(resolvedConfig.settings) ? resolvedConfig.settings : void 0
         );
       }
       for (const [destName, dest] of Object.entries(flow.destinations || {})) {
-        if (!isObject8(dest.config)) continue;
+        if (!isObject9(dest.config)) continue;
         const mapping = dest.config.mapping;
-        if (!isObject8(mapping)) continue;
+        if (!isObject9(mapping)) continue;
         for (const key of Object.keys(mapping)) {
           if (key.includes(".") && !key.includes(" ")) {
             const parts = key.split(".");
@@ -7114,16 +7142,16 @@ function checkResolvedWindowCollector(name, raw, flow, errors, deferred) {
   });
 }
 function checkWebLoggerFormat(flowName, flow, errors) {
-  if (!isObject8(flow.config) || flow.config.platform !== "web") return;
+  if (!isObject9(flow.config) || flow.config.platform !== "web") return;
   const at = `flows.${flowName}`;
   const loggers = [];
-  if (isObject8(flow.collector))
+  if (isObject9(flow.collector))
     loggers.push([`${at}.collector.logger`, flow.collector.logger]);
   for (const [section] of STEP_KINDS2) {
     const steps = flow[section];
-    if (!isObject8(steps)) continue;
+    if (!isObject9(steps)) continue;
     for (const [name, step] of Object.entries(steps)) {
-      if (isObject8(step) && isObject8(step.config))
+      if (isObject9(step) && isObject9(step.config))
         loggers.push([
           `${at}.${section}.${name}.config.logger`,
           step.config.logger
@@ -7131,7 +7159,7 @@ function checkWebLoggerFormat(flowName, flow, errors) {
     }
   }
   for (const [path23, logger] of loggers) {
-    if (!isObject8(logger) || logger.format === void 0) continue;
+    if (!isObject9(logger) || logger.format === void 0) continue;
     errors.push({
       path: `${path23}.format`,
       message: "logger.format applies to server flows only: a web flow logs to the browser console, which has no output format. Remove it.",
@@ -7236,21 +7264,21 @@ function isStepOut(value) {
   return Array.isArray(value) && value.every((entry) => Array.isArray(entry) && typeof entry[0] === "string");
 }
 function returnedEvents(value) {
-  if (isObject8(value)) return [isObject8(value.event) ? value.event : value];
+  if (isObject9(value)) return [isObject9(value.event) ? value.event : value];
   if (Array.isArray(value)) return value.flatMap(returnedEvents);
   return [];
 }
 function outEvents(out) {
   if (isStepOut(out)) {
     return out.flatMap(([head, first]) => {
-      if (head === "elb") return isObject8(first) ? [first] : [];
+      if (head === "elb") return isObject9(first) ? [first] : [];
       if (head === "return") return returnedEvents(first);
       return [];
     });
   }
   if (Array.isArray(out) || typeof out === "string")
     return out.length > 0 ? [out] : [];
-  return isObject8(out) && Object.keys(out).length > 0 ? [out] : [];
+  return isObject9(out) && Object.keys(out).length > 0 ? [out] : [];
 }
 function hasComparableOut(out) {
   return outEvents(out).length > 0;
@@ -7292,7 +7320,7 @@ function routeAt(spec, path23) {
   for (const key of path23) {
     if (typeof key === "number")
       current = Array.isArray(current) ? current[key] : void 0;
-    else current = isObject8(current) ? current[key] : void 0;
+    else current = isObject9(current) ? current[key] : void 0;
   }
   return current;
 }
@@ -7317,7 +7345,7 @@ function lintRoute(spec, position, known, errors, warnings) {
     if (node.stop && !node.match && node.kind !== "many") {
       const self = routeAt(spec, node.path);
       const list = routeAt(spec, node.path.slice(0, -1));
-      if (isObject8(self) && self.stop === true && typeof last === "number" && Array.isArray(list) && last < list.length - 1 && once2(`stop:${where(node.path)}`)) {
+      if (isObject9(self) && self.stop === true && typeof last === "number" && Array.isArray(list) && last < list.length - 1 && once2(`stop:${where(node.path)}`)) {
         const at = where(node.path);
         warnings.push({
           path: at,
@@ -7369,7 +7397,7 @@ function hasRuntimeValue(value) {
   if (typeof value === "string")
     return value.includes(ENV_MARKER_PREFIX3) || value.startsWith(SECRET_MARKER_PREFIX4) || /\$(?:env|secret)\./.test(value);
   if (Array.isArray(value)) return value.some(hasRuntimeValue);
-  return isObject8(value) && Object.values(value).some(hasRuntimeValue);
+  return isObject9(value) && Object.values(value).some(hasRuntimeValue);
 }
 var VALIDATE_PACKAGE = "@walkeros/transformer-validate";
 function isValidateStep(step) {
@@ -7389,7 +7417,7 @@ function resolveStepContracts(entries, contract) {
   }
   const sources = [];
   for (const [index, entry] of entries.entries()) {
-    if (isObject8(entry)) {
+    if (isObject9(entry)) {
       sources.push(entry);
       continue;
     }
@@ -7407,7 +7435,7 @@ function resolveStepContracts(entries, contract) {
         message: `contract "${match[1]}" is not defined in the root contract (defined: ${Object.keys(resolved).join(", ") || "none"})`
       };
     const rule = match[2] ? getByPath(resolved[match[1]], match[2]) : resolved[match[1]];
-    if (!isObject8(rule))
+    if (!isObject9(rule))
       return {
         ok: false,
         index,
@@ -7418,7 +7446,7 @@ function resolveStepContracts(entries, contract) {
   return { ok: true, sources };
 }
 function checkValidateStepExamples(stepPath, step, contract, errors, warnings, strict, skipped, resolvedSettings) {
-  const settings = resolvedSettings ?? (isObject8(step.config) && isObject8(step.config.settings) ? step.config.settings : {});
+  const settings = resolvedSettings ?? (isObject9(step.config) && isObject9(step.config.settings) ? step.config.settings : {});
   const contractPath = `${stepPath}.config.settings.contract`;
   if (settings.contract !== void 0 && !Array.isArray(settings.contract)) {
     if (step.examples)
@@ -7452,10 +7480,10 @@ function checkValidateStepExamples(stepPath, step, contract, errors, warnings, s
   }
   const mode = settings.mode === "strict" ? "strict" : "pass";
   const format = settings.format === true;
-  const output = isObject8(settings.output) ? settings.output : {};
+  const output = isObject9(settings.output) ? settings.output : {};
   const isValidPath = typeof output.isValid === "string" ? output.isValid : "source.valid";
   for (const [exName, example] of Object.entries(step.examples)) {
-    if (example.command || !isObject8(example.in)) continue;
+    if (example.command || !isObject9(example.in)) continue;
     if (example.out === void 0) continue;
     const event = example.in;
     const verdict = validateEventAgainstContract(event, void 0, {
@@ -7493,14 +7521,14 @@ function checkValidateStepExamples(stepPath, step, contract, errors, warnings, s
 }
 
 // src/commands/validate/validators/mapping.ts
-import { isObject as isObject9 } from "@walkeros/core";
+import { isObject as isObject10 } from "@walkeros/core";
 import { schemas as schemas5 } from "@walkeros/core/dev";
 var { RuleSchema } = schemas5.MappingSchemas;
 function isRule(value) {
-  return isObject9(value) && RuleSchema.safeParse(value).success;
+  return isObject10(value) && RuleSchema.safeParse(value).success;
 }
 function isNestedActions(key, value) {
-  if (key.includes(" ") || !isObject9(value)) return false;
+  if (key.includes(" ") || !isObject10(value)) return false;
   const rules = Object.values(value);
   return rules.length > 0 && rules.every(
     (rule) => Array.isArray(rule) ? rule.length > 0 && rule.every(isRule) : isRule(rule)
@@ -7510,7 +7538,7 @@ function validateMapping(input) {
   const errors = [];
   const warnings = [];
   const details = {};
-  if (!isObject9(input)) {
+  if (!isObject10(input)) {
     errors.push({
       path: "root",
       message: "Mapping must be an object with event patterns as keys",
@@ -7599,7 +7627,6 @@ async function validateEntry(path23, flowConfig, options = {}) {
     const outcome = await checkStepSettings(
       target,
       resolution.flow,
-      file?.flows[target.flow],
       "entry:settings",
       context2
     );
@@ -7740,7 +7767,7 @@ function inapplicableOptions(type, options) {
 }
 function validateContractInput(input) {
   if (!isFlowJson2(input)) return validateContract(input);
-  const contract = isObject10(input) ? input.contract : void 0;
+  const contract = isObject11(input) ? input.contract : void 0;
   if (contract === void 0) {
     return {
       valid: false,