@usejourney/k6-adapter 0.1.4 → 0.2.0

package/dist/index.d.ts

@@ -11,11 +11,35 @@ interface ExportK6Options {
      * adapter does not pull a runtime dep on core. JSON-serialized verbatim.
      */
     k6Options?: Record<string, unknown>;
+    /**
+     * Opt in to custom k6 metrics. Every step records a Trend
+     * `<prefix>_<step_slug>_duration` (`res.timings.duration`, ms) and a Counter
+     * `<prefix>_<step_slug>_tps`; every completed iteration records
+     * `<prefix>_flow_duration` (sum of its step durations) and `<prefix>_flow_tps`.
+     * A step's `metric` option overrides its slug (`false` skips it).
+     */
+    metricsPrefix?: string;
+    /**
+     * Stop the iteration's remaining steps when a step's `assert` fails,
+     * mirroring `journey run`. Default: the failure is recorded as a failed
+     * k6 check and the iteration carries on.
+     */
+    haltOnFailure?: boolean;
+    /**
+     * Project root that relative `fileFrom()` paths resolve against. Defaults to
+     * the nearest ancestor of the journey file holding `journey.config.json`,
+     * else `process.cwd()`.
+     */
+    projectDir?: string;
 }
 interface ExportK6Result {
     outFile: string;
     source: string;
 }
+/** Nearest ancestor of `from` (inclusive) containing `journey.config.json`. */
+declare function findProjectDir(from: string): string | undefined;
+/** String-literal `fileFrom("…")` paths in a module's source. */
+declare function scanFileFromLiterals(source: string): string[];
 declare function exportToK6(opts: ExportK6Options): Promise<ExportK6Result>;
 
-export { type ExportK6Options, type ExportK6Result, exportToK6 };
+export { type ExportK6Options, type ExportK6Result, exportToK6, findProjectDir, scanFileFromLiterals };

package/dist/index.js

@@ -1,84 +1,22 @@
 // src/index.ts
-import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import { basename, dirname as dirname2, resolve as resolve2 } from "path";
-import { transform } from "esbuild";
-
-// src/inline.ts
-import { readFile } from "fs/promises";
-import { dirname, isAbsolute, resolve } from "path";
-var IMPORT_RE = /^\s*import\s+[^;]*?from\s+["']([^"']+)["'];?\s*$/gm;
-function stripCoreImports(source) {
-  return source.replace(IMPORT_RE, (match, specifier) => {
-    if (specifier === "@usejourney/core") return "";
-    return match;
-  });
-}
-function stripTypeImports(source) {
-  return source.replace(/^\s*import\s+type\s+[^;]*?from\s+["'][^"']+["'];?\s*$/gm, "");
-}
-function findRelativeImports(source, fromFile) {
-  const out = [];
-  IMPORT_RE.lastIndex = 0;
-  let m;
-  while (m = IMPORT_RE.exec(source)) {
-    const spec = m[1];
-    if (!spec.startsWith(".")) continue;
-    const base = dirname(fromFile);
-    const abs = isAbsolute(spec) ? spec : resolve(base, spec);
-    const withExt = abs.endsWith(".ts") || abs.endsWith(".js") ? abs : null;
-    const candidates = withExt ? [withExt] : [`${abs}.ts`, `${abs}.js`, abs.replace(/\.js$/, ".ts")];
-    out.push({ specifier: spec, sourcePath: candidates[0] });
-  }
-  return out;
-}
-async function inlineRelativeImports(journeySource, journeyPath, visited = /* @__PURE__ */ new Set()) {
-  const imports = findRelativeImports(journeySource, journeyPath);
-  let out = journeySource;
-  for (const imp of imports) {
-    const tryPaths = imp.sourcePath.endsWith(".ts") || imp.sourcePath.endsWith(".js") ? [imp.sourcePath, imp.sourcePath.replace(/\.js$/, ".ts")] : [`${imp.sourcePath}.ts`, `${imp.sourcePath}.js`];
-    let resolved;
-    for (const p of tryPaths) {
-      try {
-        const content = await readFile(p, "utf8");
-        resolved = { path: p, content };
-        break;
-      } catch {
-      }
-    }
-    const importLineRe = new RegExp(
-      `^\\s*import\\s+[^;]*?from\\s+["']${imp.specifier.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}["'];?\\s*$`,
-      "m"
-    );
-    if (!resolved) continue;
-    if (visited.has(resolved.path)) {
-      out = out.replace(importLineRe, "");
-      continue;
-    }
-    visited.add(resolved.path);
-    const cleaned = stripCoreImports(stripTypeImports(resolved.content));
-    const recursed = await inlineRelativeImports(cleaned, resolved.path, visited);
-    const converted = recursed.replace(/^\s*export\s+(const|function|class)\s+/gm, "$1 ");
-    out = out.replace(
-      importLineRe,
-      `
-// ----- inlined from ${imp.specifier} -----
-${converted}
-// ----- end inlined -----
-`
-    );
-  }
-  return out;
-}
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "path";
+import { build } from "esbuild";
 
 // src/shim.ts
-var SHIM_SOURCE = `import http from "k6/http";
+var SHIM_MODULE_SOURCE = `import http from "k6/http";
 import { check, group } from "k6";
+import { Trend, Counter } from "k6/metrics";
 
-const __BASE_URL = __ENV.JOURNEY_BASE_URL || "";
+// k6 reads JOURNEY_BASE_URL; BASE_URL (the name environments/*.json use for
+// \`journey run\`) is the fallback.
+const __BASE_URL = __ENV.JOURNEY_BASE_URL || __ENV.BASE_URL || "";
 const __journeys = [];
 let __currentNodes = null;
 let __outputSlot = null;
 const __MAX_SUB_DEPTH = 8;
+const __config = { metricsPrefix: null, haltOnFailure: false, projectRoot: "./", files: {} };
 
 // Sub-journey output cache \u2014 mirrors the runtime's MemorySubJourneyCache.
 // Scope is per-VU: k6 gives each VU its own JS runtime, and module-scoped state
@@ -101,10 +39,35 @@ function __cacheSet(key, value, ttlMs) {
   __subCache[key] = ttlMs !== undefined ? { value: value, expiresAt: Date.now() + ttlMs } : { value: value };
 }
 
+// ---- maybe-async helpers -------------------------------------------------
+function __isThenable(v) {
+  return v !== null && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
+}
+function __then(v, fn) {
+  return __isThenable(v) ? v.then(fn) : fn(v);
+}
+function __lazy(v) {
+  return typeof v === "function" ? v() : v;
+}
+function __tryFinally(body, fin) {
+  let r;
+  try { r = body(); } catch (e) { fin(); throw e; }
+  if (__isThenable(r)) return r.then((v) => { fin(); return v; }, (e) => { fin(); throw e; });
+  fin();
+  return r;
+}
+// Run fn; report { ok, error } synchronously when possible, else as a promise.
+function __attempt(fn) {
+  let r;
+  try { r = fn(); } catch (e) { return { ok: false, error: e }; }
+  if (__isThenable(r)) return r.then(() => ({ ok: true }), (e) => ({ ok: false, error: e }));
+  return { ok: true };
+}
+
 // Minimal no-op stand-in for zod. Reusable journeys declare \`inputs\` / \`outputs\`
 // schemas via \`z\`, but k6 has no zod runtime and the schemas are not enforced
 // in exported scripts \u2014 every access or call returns the same chainable proxy.
-const z = new Proxy(function () {}, {
+export const z = new Proxy(function () {}, {
   get() { return z; },
   apply() { return z; },
   construct() { return z; },
@@ -112,7 +75,7 @@ const z = new Proxy(function () {}, {
 
 // Sub-journey cacheKey / cacheTtlMs / cache opts ARE honored \u2014 see __runSub
 // and the per-VU note on __subCache above.
-function journey(name, optsOrBody, maybeBody) {
+export function journey(name, optsOrBody, maybeBody) {
   const body = typeof optsOrBody === "function" ? optsOrBody : maybeBody;
   const opts = typeof optsOrBody === "function" ? null : optsOrBody;
   if (opts && opts.reusable === true) {
@@ -121,30 +84,49 @@ function journey(name, optsOrBody, maybeBody) {
   __journeys.push({ name, body });
 }
 
-function step(name, opts) {
+export function step(name, opts) {
   if (!__currentNodes) {
     throw new Error("step(" + JSON.stringify(name) + ") called outside a journey(...) body");
   }
   __currentNodes.push({ kind: "step", name, opts });
 }
 
-function invokeJourney(handle, opts) {
+export function invokeJourney(handle, opts) {
   if (!__currentNodes) {
     throw new Error("invokeJourney(...) called outside a journey(...) body");
   }
   __currentNodes.push({ kind: "sub", handle, opts: opts || {} });
 }
 
-function output(value) {
+export function output(value) {
   if (__outputSlot) __outputSlot.value = value;
 }
 
-function env(key) {
+export function env(key) {
   const v = __ENV[key];
   if (v === undefined) throw new Error("env: missing " + key);
   return v;
 }
 
+export function tryEnv(key) {
+  return __ENV[key];
+}
+
+export function isEndpointRef(e) {
+  return e !== null && typeof e === "object" && typeof e.operationId === "string";
+}
+
+export class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AssertionError";
+  }
+}
+
+function __fmt(v) {
+  try { return JSON.stringify(v); } catch (e) { return String(v); }
+}
+
 function deepEqual(a, b) {
   if (Object.is(a, b)) return true;
   if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
@@ -155,31 +137,211 @@ function deepEqual(a, b) {
   return true;
 }
 
-function expect(value) {
-  const fail = (msg) => { const e = new Error(msg); e.name = "AssertionError"; throw e; };
+// Mirrors @usejourney/core's expect() \u2014 same matchers, same failure messages.
+export function expect(value) {
+  const fail = (msg) => { throw new AssertionError(msg); };
+  const num = (m) => { if (typeof value !== "number") fail(m + " is only supported on numbers (got " + typeof value + ")"); };
   return {
-    toBe(expected) { if (!Object.is(value, expected)) fail("expected " + JSON.stringify(value) + " to be " + JSON.stringify(expected)); },
-    toEqual(expected) { if (!deepEqual(value, expected)) fail("expected " + JSON.stringify(value) + " to equal " + JSON.stringify(expected)); },
+    toBe(expected) { if (!Object.is(value, expected)) fail("expected " + __fmt(value) + " to be " + __fmt(expected)); },
+    toEqual(expected) { if (!deepEqual(value, expected)) fail("expected " + __fmt(value) + " to equal " + __fmt(expected)); },
     toBeDefined() { if (value === undefined) fail("expected value to be defined"); },
     toContain(expected) {
-      if (typeof value === "string") { if (!value.includes(expected)) fail("expected string to contain " + JSON.stringify(expected)); return; }
-      if (Array.isArray(value)) { if (!value.some((v) => deepEqual(v, expected))) fail("expected array to contain " + JSON.stringify(expected)); return; }
-      fail("toContain only supports strings and arrays");
+      if (typeof value === "string") {
+        if (typeof expected !== "string" || !value.includes(expected)) fail("expected " + __fmt(value) + " to contain " + __fmt(expected));
+        return;
+      }
+      if (Array.isArray(value)) { if (!value.some((v) => deepEqual(v, expected))) fail("expected array to contain " + __fmt(expected)); return; }
+      fail("toContain is only supported on strings and arrays");
     },
     toMatch(expected) {
-      if (typeof value !== "string") fail("toMatch only supports strings");
+      if (typeof value !== "string") fail("toMatch is only supported on strings");
       const re = typeof expected === "string" ? new RegExp(expected) : expected;
-      if (!re.test(value)) fail("expected " + JSON.stringify(value) + " to match " + re);
+      if (!re.test(value)) fail("expected " + __fmt(value) + " to match " + re);
+    },
+    toBeGreaterThan(n) { num("toBeGreaterThan"); if (!(value > n)) fail("expected " + __fmt(value) + " to be greater than " + n); },
+    toBeGreaterThanOrEqual(n) { num("toBeGreaterThanOrEqual"); if (!(value >= n)) fail("expected " + __fmt(value) + " to be greater than or equal to " + n); },
+    toBeLessThan(n) { num("toBeLessThan"); if (!(value < n)) fail("expected " + __fmt(value) + " to be less than " + n); },
+    toBeLessThanOrEqual(n) { num("toBeLessThanOrEqual"); if (!(value <= n)) fail("expected " + __fmt(value) + " to be less than or equal to " + n); },
+    toHaveLength(n) {
+      const len = value === null || value === undefined ? undefined : value.length;
+      if (typeof len !== "number") fail("toHaveLength is only supported on strings, arrays, and objects with a numeric .length");
+      if (len !== n) fail("expected " + __fmt(value) + " to have length " + n + ", got " + len);
     },
   };
 }
 
-function __parseBody(res) {
-  const ct = (res.headers && (res.headers["Content-Type"] || res.headers["content-type"])) || "";
+// ---- files / multipart ---------------------------------------------------
+// fileFrom() paths are project-root relative. The export pre-loads every
+// string-literal fileFrom("\u2026") path with open(\u2026, "b") in the init context and
+// hands the bytes over through __configure({ files }).
+function __isFileRef(v) { return v !== null && typeof v === "object" && v.__journeyFile === true; }
+function __isMultipart(v) { return v !== null && typeof v === "object" && v.__journeyMultipart === true; }
+function __basename(p) { const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\\\")); return i === -1 ? p : p.slice(i + 1); }
+function __isAbsPath(p) { return p.charAt(0) === "/" || /^[A-Za-z]:[\\\\/]/.test(p); }
+
+function __loadFile(path) {
+  if (Object.prototype.hasOwnProperty.call(__config.files, path)) return __config.files[path];
+  let bytes;
+  try {
+    bytes = open(__isAbsPath(path) ? path : __config.projectRoot + path, "b");
+  } catch (e) {
+    throw new Error(
+      "fileFrom(" + JSON.stringify(path) + "): the file was not pre-loaded at k6 init time and can't be opened now (" +
+        (e && e.message ? e.message : e) + "). Pass a string literal to fileFrom() so \`journey export k6\` can pre-load it, " +
+        "or call fileFrom() at module top level.",
+    );
+  }
+  __config.files[path] = bytes;
+  return bytes;
+}
+
+export function fileFrom(path, contentType, filename) {
+  if (typeof path !== "string" || path.length === 0) throw new TypeError("fileFrom(path): path must be a non-empty string");
+  // At init time (module top level) this opens the file eagerly; in a VU it
+  // only succeeds for paths the export pre-loaded.
+  __loadFile(path);
+  const ref = { __journeyFile: true, path: path };
+  if (contentType !== undefined) ref.contentType = contentType;
+  if (filename !== undefined) ref.filename = filename;
+  return ref;
+}
+
+export function multipart(parts) {
+  if (parts === null || typeof parts !== "object") throw new TypeError("multipart(parts): parts must be an object");
+  const copy = {};
+  for (const k of Object.keys(parts)) copy[k] = parts[k];
+  return { __journeyMultipart: true, parts: copy };
+}
+
+export function isFileRef(v) { return __isFileRef(v); }
+export function isMultipartBody(v) { return __isMultipart(v); }
+
+function __headerKey(h, name) {
+  const lower = name.toLowerCase();
+  for (const k of Object.keys(h)) if (k.toLowerCase() === lower) return k;
+  return undefined;
+}
+function __defaultHeader(h, name, value) {
+  if (__headerKey(h, name) === undefined) h[name] = value;
+}
+function __toArrayBuffer(v) {
+  if (v instanceof ArrayBuffer) return v;
+  return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength);
+}
+
+// Encode a resolved step body for http.request, defaulting Content-Type the
+// way @usejourney/core's buildRequest does. Mutates \`headers\`.
+function __encodeBody(body, headers) {
+  if (body === undefined) return null;
+  if (typeof body === "string") { __defaultHeader(headers, "Content-Type", "application/json"); return body; }
+  if (__isMultipart(body)) {
+    // k6 sets multipart/form-data with its own boundary; a caller-supplied
+    // Content-Type can't carry it, so drop it (core does the same).
+    const ctKey = __headerKey(headers, "Content-Type");
+    if (ctKey !== undefined) delete headers[ctKey];
+    const names = Object.keys(body.parts);
+    const out = {};
+    let hasFile = false;
+    for (const k of names) {
+      const v = body.parts[k];
+      if (__isFileRef(v)) {
+        hasFile = true;
+        out[k] = http.file(__loadFile(v.path), v.filename || __basename(v.path), v.contentType || "application/octet-stream");
+      } else {
+        out[k] = String(v);
+      }
+    }
+    if (hasFile) return out; // object body with a file \u2192 k6 sends multipart/form-data
+    // Text-only: k6 would url-encode an object body, so build multipart by hand.
+    const boundary = "----JourneyBoundary" + Math.random().toString(36).slice(2);
+    let s = "";
+    for (const k of names) {
+      s += "--" + boundary + "\\r\\nContent-Disposition: form-data; name=\\"" + k + "\\"\\r\\n\\r\\n" + out[k] + "\\r\\n";
+    }
+    headers["Content-Type"] = "multipart/form-data; boundary=" + boundary;
+    return s + "--" + boundary + "--\\r\\n";
+  }
+  if (__isFileRef(body)) {
+    __defaultHeader(headers, "Content-Type", body.contentType || "application/octet-stream");
+    return __loadFile(body.path);
+  }
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    __defaultHeader(headers, "Content-Type", "application/octet-stream");
+    return __toArrayBuffer(body);
+  }
+  __defaultHeader(headers, "Content-Type", "application/json");
+  return JSON.stringify(body);
+}
+
+// ---- fetch ---------------------------------------------------------------
+// Minimal WHATWG-fetch stand-in for helpers that \`import { fetch } from
+// "@usejourney/core"\`. Backed by the synchronous http.request; resolves to a
+// Response-like object. Rejects (like fetch) only on network errors.
+function __headersLike(raw) {
+  const lower = {};
+  if (raw) for (const k of Object.keys(raw)) lower[k.toLowerCase()] = String(raw[k]);
+  return {
+    get(name) { const v = lower[String(name).toLowerCase()]; return v === undefined ? null : v; },
+    has(name) { return Object.prototype.hasOwnProperty.call(lower, String(name).toLowerCase()); },
+    forEach(cb) { for (const k of Object.keys(lower)) cb(lower[k], k); },
+    keys() { return Object.keys(lower)[Symbol.iterator](); },
+    entries() { return Object.keys(lower).map((k) => [k, lower[k]])[Symbol.iterator](); },
+  };
+}
+function __plainHeaders(h) {
+  const out = {};
+  if (!h) return out;
+  if (typeof h.forEach === "function" && !Array.isArray(h)) { h.forEach((v, k) => { out[k] = v; }); return out; }
+  if (Array.isArray(h)) { for (const pair of h) out[pair[0]] = pair[1]; return out; }
+  for (const k of Object.keys(h)) out[k] = h[k];
+  return out;
+}
+
+export function fetch(input, init) {
+  try {
+    const opts = init || {};
+    const url = typeof input === "string" ? input : input && input.url ? input.url : String(input);
+    const method = String(opts.method || (input && input.method) || "GET").toUpperCase();
+    const headers = __plainHeaders(opts.headers);
+    let body = opts.body === undefined || opts.body === null ? null : opts.body;
+    if (body !== null && typeof body !== "string") {
+      if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) body = __toArrayBuffer(body);
+      else throw new TypeError("fetch (k6 export): only string and binary bodies are supported");
+    }
+    const res = http.request(method, url, body, { headers: headers });
+    if (res.status === 0 && res.error) return Promise.reject(new TypeError("fetch failed: " + res.error));
+    const text = res.body === null || res.body === undefined ? "" : typeof res.body === "string" ? res.body : String(res.body);
+    const response = {
+      status: res.status,
+      ok: res.status >= 200 && res.status < 300,
+      statusText: res.status_text || "",
+      url: res.url || url,
+      redirected: false,
+      headers: __headersLike(res.headers),
+      text() { return Promise.resolve(text); },
+      json() { try { return Promise.resolve(JSON.parse(text)); } catch (e) { return Promise.reject(e); } },
+      clone() { return response; },
+    };
+    return Promise.resolve(response);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+// ---- request execution ---------------------------------------------------
+function __parseBody(res, headers) {
+  const ct = headers["content-type"] || "";
   if (ct.indexOf("json") !== -1) { try { return res.json(); } catch (e) { return null; } }
   return res.body;
 }
 
+// Response header keys are lowercased, matching fetch() in the core runtime.
+function __lowerHeaders(h) {
+  const out = {};
+  if (h) for (const k of Object.keys(h)) out[k.toLowerCase()] = h[k];
+  return out;
+}
+
 function __interpolate(path, params) {
   if (!params) return path;
   let out = path;
@@ -212,37 +374,113 @@ function __collectNodes(body, input) {
   return nodes;
 }
 
+// ---- custom metrics (opt-in via --metrics-prefix) ------------------------
+const __metrics = {};
+const __warnedMetrics = {};
+let __flowMetrics = null;
+let __flowDuration = 0;
+
+function __slug(s) {
+  return String(s).toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+// Metric base name (<prefix>_<slug>) for a step, or null when it opted out.
+function __metricName(stepName, opts) {
+  const m = opts ? opts.metric : undefined;
+  if (m === false) return null;
+  const slug = typeof m === "string" && m !== "" ? m.replace(/[^A-Za-z0-9_]+/g, "_") : __slug(stepName);
+  return __config.metricsPrefix + "_" + (slug || "step");
+}
+function __declareMetric(name) {
+  if (__metrics[name]) return;
+  __metrics[name] = { duration: new Trend(name + "_duration"), tps: new Counter(name + "_tps") };
+}
+// k6 only allows metric declaration in the init context, but steps are only
+// known by evaluating journey bodies. Dry-collect every journey (and, best
+// effort, every sub-journey) at init to declare a Trend + Counter per step.
+function __declareNodes(nodes, depth) {
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (n.kind === "step") {
+      const name = __metricName(n.name, n.opts);
+      if (name) __declareMetric(name);
+      continue;
+    }
+    if (depth >= __MAX_SUB_DEPTH) continue;
+    let input;
+    try { input = __lazy(n.opts.inputs); } catch (e) { input = undefined; }
+    if (__isThenable(input)) input = undefined;
+    try {
+      __declareNodes(__collectNodes(n.handle.body, input), depth + 1);
+    } catch (e) {
+      console.warn("[journey] metrics: could not pre-declare metrics for sub-journey " + JSON.stringify(n.handle.name) + " (" + (e && e.message ? e.message : e) + ")");
+    }
+  }
+}
+export function __declareMetrics() {
+  if (!__config.metricsPrefix) return;
+  __flowMetrics = {
+    duration: new Trend(__config.metricsPrefix + "_flow_duration"),
+    tps: new Counter(__config.metricsPrefix + "_flow_tps"),
+  };
+  for (let i = 0; i < __journeys.length; i++) {
+    const j = __journeys[i];
+    try {
+      __declareNodes(__collectNodes(j.body, undefined), 0);
+    } catch (e) {
+      console.warn("[journey] metrics: could not pre-declare metrics for journey " + JSON.stringify(j.name) + " (" + (e && e.message ? e.message : e) + ")");
+    }
+  }
+}
+function __recordStep(stepName, opts, res) {
+  if (!__config.metricsPrefix) return;
+  const d = res.timings ? res.timings.duration : 0;
+  __flowDuration += d;
+  const name = __metricName(stepName, opts);
+  if (!name) return;
+  const m = __metrics[name];
+  if (!m) {
+    if (!__warnedMetrics[name]) {
+      __warnedMetrics[name] = true;
+      console.warn("[journey] metrics: " + name + "_* was not declared at init (step only discovered at run time); not recorded");
+    }
+    return;
+  }
+  m.duration.add(d);
+  m.tps.add(1);
+}
+
+// Thrown to stop the iteration when an assert fails under --halt-on-failure.
+const __HALT = { __journeyHalt: true };
+
 function __executeStep(current, journeyName) {
   const opts = current.opts;
-  const headers = typeof opts.headers === "function" ? opts.headers() : (opts.headers || {});
-  const body = typeof opts.body === "function" ? opts.body() : opts.body;
-  // params and query are lazy in the core runtime \u2014 resolve a function form
-  // before interpolating the path / building the query string, like headers/body.
-  const params = typeof opts.params === "function" ? opts.params() : opts.params;
-  const query = typeof opts.query === "function" ? opts.query() : opts.query;
+  // Same resolution order as the core runtime: headers, query, body, params.
+  return __then(__lazy(opts.headers), (headers) =>
+    __then(__lazy(opts.query), (query) =>
+      __then(__lazy(opts.body), (body) =>
+        __then(__lazy(opts.params), (params) => __send(current, journeyName, headers, query, body, params)))));
+}
+
+function __send(current, journeyName, headers, query, body, params) {
+  const opts = current.opts;
   const path = __interpolate(opts.endpoint.path, params);
   const base = opts.endpoint.baseUrl || __BASE_URL;
   const url = base + path + __buildQuery(query);
   const requestHeaders = __mergeHeaders(headers);
-  if (body !== undefined && !("Content-Type" in requestHeaders) && !("content-type" in requestHeaders)) {
-    requestHeaders["Content-Type"] = "application/json";
-  }
-  const res = http.request(
-    opts.endpoint.method,
-    url,
-    body !== undefined ? (typeof body === "string" ? body : JSON.stringify(body)) : null,
-    { headers: requestHeaders },
-  );
-  const wrapped = { status: res.status, headers: res.headers, body: __parseBody(res) };
-  if (opts.assert) {
-    const name = journeyName + " \u203A " + current.name;
-    check(wrapped, {
-      [name]: (r) => {
-        try { opts.assert(r); return true; } catch (e) { console.error(name + ": " + (e && e.message ? e.message : e)); return false; }
-      },
-    });
-  }
-  if (opts.after) opts.after(wrapped);
+  const payload = __encodeBody(body, requestHeaders);
+  const res = http.request(opts.endpoint.method, url, payload, { headers: requestHeaders });
+  __recordStep(current.name, opts, res);
+  const resHeaders = __lowerHeaders(res.headers);
+  const wrapped = { status: res.status, headers: resHeaders, body: __parseBody(res, resHeaders) };
+  const afterHook = () => (opts.after ? opts.after(wrapped) : undefined);
+  if (!opts.assert) return afterHook();
+  const name = journeyName + " \u203A " + current.name;
+  return __then(__attempt(() => opts.assert(wrapped)), (r) => {
+    if (!r.ok) console.error(name + ": " + (r.error && r.error.message ? r.error.message : r.error));
+    check(wrapped, { [name]: () => r.ok });
+    if (!r.ok && __config.haltOnFailure) throw __HALT;
+    return afterHook();
+  });
 }
 
 // Inline a sub-journey node under a k6 group() named after the child journey.
@@ -255,89 +493,288 @@ function __runSub(node, depth) {
   const handle = node.handle;
   const opts = node.opts || {};
   const label = opts.name || handle.name;
-  let input = opts.inputs;
-  if (typeof input === "function") input = input();
-
-  // Cache active only when a cacheKey is supplied and not disabled \u2014 mirrors
-  // the core runtime. Composite key is childName:resolvedKey.
-  let resolvedKey;
-  if (opts.cacheKey !== undefined) {
-    resolvedKey = typeof opts.cacheKey === "function" ? opts.cacheKey(input) : opts.cacheKey;
-  }
-  const cacheKeyStr =
-    !__cacheOff && resolvedKey !== undefined && opts.cache !== "off"
-      ? handle.name + ":" + resolvedKey
-      : undefined;
-
-  const prevSlot = __outputSlot;
-  const slot = { value: undefined };
-  __outputSlot = slot;
-  try {
-    let hit = false;
+  return __then(__lazy(opts.inputs), (input) => {
+    // Cache active only when a cacheKey is supplied and not disabled \u2014 mirrors
+    // the core runtime. Composite key is childName:resolvedKey.
+    let resolvedKey;
+    if (opts.cacheKey !== undefined) {
+      resolvedKey = typeof opts.cacheKey === "function" ? opts.cacheKey(input) : opts.cacheKey;
+    }
+    const cacheKeyStr =
+      !__cacheOff && resolvedKey !== undefined && opts.cache !== "off"
+        ? handle.name + ":" + resolvedKey
+        : undefined;
+
+    const slot = { value: undefined };
+    const finish = () => {
+      if (opts.assert) {
+        return __then(opts.assert(slot.value), () => (opts.after ? opts.after(slot.value) : undefined));
+      }
+      return opts.after ? opts.after(slot.value) : undefined;
+    };
     if (cacheKeyStr !== undefined) {
       const entry = __cacheGet(cacheKeyStr);
-      if (entry !== undefined) { slot.value = entry.value; hit = true; }
+      if (entry !== undefined) { slot.value = entry.value; return finish(); }
     }
-    if (!hit) {
+    const prevSlot = __outputSlot;
+    __outputSlot = slot;
+    const ran = __tryFinally(() => {
       const childNodes = __collectNodes(handle.body, input);
-      group(label, () => { __runNodes(childNodes, handle.name, depth + 1); });
+      // group() rejects async functions; a sync callback that returns a
+      // promise is accepted (requests after its first await lose the tag).
+      return group(label, () => __runNodes(childNodes, handle.name, depth + 1));
+    }, () => { __outputSlot = prevSlot; });
+    return __then(ran, () => {
       if (cacheKeyStr !== undefined) __cacheSet(cacheKeyStr, slot.value, opts.cacheTtlMs);
-    }
-  } finally {
-    __outputSlot = prevSlot;
-  }
-  if (opts.assert) opts.assert(slot.value);
-  if (opts.after) opts.after(slot.value);
+      return finish();
+    });
+  });
 }
 
 function __runNodes(nodes, journeyName, depth) {
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    if (node.kind === "sub") __runSub(node, depth);
-    else __executeStep(node, journeyName);
-  }
+  let i = 0;
+  const next = () => {
+    while (i < nodes.length) {
+      const node = nodes[i++];
+      const r = node.kind === "sub" ? __runSub(node, depth) : __executeStep(node, journeyName);
+      if (__isThenable(r)) return r.then(next);
+    }
+    return undefined;
+  };
+  return next();
 }
-`;
-var ENTRY_SOURCE = `
-export default function () {
-  for (let i = 0; i < __journeys.length; i++) {
-    const j = __journeys[i];
-    const nodes = __collectNodes(j.body, undefined);
-    __runNodes(nodes, j.name, 0);
-  }
+
+/** Called by the generated entry before any journey module evaluates. */
+export function __configure(cfg) {
+  if (cfg.metricsPrefix) __config.metricsPrefix = cfg.metricsPrefix;
+  if (cfg.haltOnFailure) __config.haltOnFailure = true;
+  if (cfg.projectRoot) __config.projectRoot = cfg.projectRoot;
+  if (cfg.files) for (const k of Object.keys(cfg.files)) __config.files[k] = cfg.files[k];
+}
+
+/** One k6 iteration: run every registered entry journey in order. */
+export function __iterate() {
+  __flowDuration = 0;
+  let j = 0;
+  const next = () => {
+    while (j < __journeys.length) {
+      const def = __journeys[j++];
+      const r = __runNodes(__collectNodes(def.body, undefined), def.name, 0);
+      if (__isThenable(r)) return r.then(next);
+    }
+    return undefined;
+  };
+  // Flow metrics are recorded only for iterations that ran every step.
+  const done = () => {
+    if (__flowMetrics) {
+      __flowMetrics.duration.add(__flowDuration);
+      __flowMetrics.tps.add(1);
+    }
+  };
+  const halted = (e) => {
+    if (e === __HALT) return undefined;
+    throw e;
+  };
+  let r;
+  try { r = next(); } catch (e) { return halted(e); }
+  if (__isThenable(r)) return r.then(done, halted);
+  done();
+  return undefined;
 }
 `;
 
 // src/index.ts
 var HEADER = `// AUTO-GENERATED BY @usejourney/k6-adapter \u2014 do not edit by hand.
-// Usage: JOURNEY_BASE_URL=https://api.example.com k6 run <this-file>
-`;
-async function exportToK6(opts) {
-  const journeyPath = resolve2(process.cwd(), opts.journeyFile);
-  const rawSource = await readFile2(journeyPath, "utf8");
-  const withoutTypeImports = stripTypeImports(rawSource);
-  const inlined = await inlineRelativeImports(withoutTypeImports, journeyPath);
-  const withoutCore = stripCoreImports(inlined);
-  const { code: userCode } = await transform(withoutCore, {
-    loader: "ts",
-    format: "esm"
+// Usage: k6 run -e JOURNEY_BASE_URL=https://api.example.com <this-file>
+//        (BASE_URL is accepted as a fallback for JOURNEY_BASE_URL)`;
+var METRIC_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var FILES_PLACEHOLDER = "__JOURNEY_PRELOADED_FILES__";
+function findProjectDir(from) {
+  let dir = from;
+  for (; ; ) {
+    if (existsSync(resolve(dir, "journey.config.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function toPosix(p) {
+  return sep === "/" ? p : p.split(sep).join("/");
+}
+function relFromScript(scriptDir, abs) {
+  const rel = toPosix(relative(scriptDir, abs));
+  if (rel === "") return ".";
+  if (isAbsolute(rel)) return rel;
+  return rel.startsWith("../") || rel === ".." ? rel : `./${rel}`;
+}
+var FILE_FROM_RE = /\bfileFrom\s*\(\s*(?:"([^"\\\n]*)"|'([^'\\\n]*)'|`([^`\\$]*)`)/g;
+function scanFileFromLiterals(source) {
+  const out = [];
+  FILE_FROM_RE.lastIndex = 0;
+  let m;
+  while (m = FILE_FROM_RE.exec(source)) out.push(m[1] ?? m[2] ?? m[3]);
+  return out;
+}
+function loaderFor(path) {
+  if (/\.[cm]?tsx$/.test(path)) return "tsx";
+  if (/\.[cm]?ts$/.test(path)) return "ts";
+  if (/\.jsx$/.test(path)) return "jsx";
+  return "js";
+}
+function journeyPlugin(fileRefs, initSource) {
+  return {
+    name: "journey-k6",
+    setup(b) {
+      b.onResolve({ filter: /^@usejourney\/core$/ }, () => ({
+        path: "shim",
+        namespace: "journey"
+      }));
+      b.onLoad({ filter: /^shim$/, namespace: "journey" }, () => ({
+        contents: SHIM_MODULE_SOURCE,
+        loader: "js"
+      }));
+      b.onResolve({ filter: /^journey:init$/ }, () => ({ path: "init", namespace: "journey" }));
+      b.onLoad({ filter: /^init$/, namespace: "journey" }, () => ({
+        contents: initSource,
+        loader: "js"
+      }));
+      b.onResolve({ filter: /^k6(\/.*)?$/ }, (args) => ({ path: args.path, external: true }));
+      b.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (isAbsolute(args.path)) return void 0;
+        return {
+          errors: [
+            {
+              text: `unsupported import "${args.path}": k6 exports can only import "@usejourney/core", k6 modules ("k6", "k6/\u2026") and relative project files. Inline the helper you need or replace the package with plain code.`
+            }
+          ]
+        };
+      });
+      b.onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: "file" }, async (args) => {
+        const contents = await readFile(args.path, "utf8");
+        for (const p of scanFileFromLiterals(contents)) {
+          if (!fileRefs.has(p)) fileRefs.set(p, args.path);
+        }
+        return { contents, loader: loaderFor(args.path) };
+      });
+    }
+  };
+}
+function assertNoEntryConflicts(source, journeyPath, hasK6Options) {
+  if (/^\s*export\s+default\b/m.test(source) || /\bas\s+default\s*[,}]/.test(source)) {
+    throw new Error(
+      `${journeyPath}: a journey file cannot \`export default\` \u2014 the k6 export generates the default function. Move it to a helper module or drop the export.`
+    );
+  }
+  const exportsOptions = /^\s*export\s+(?:const|let|var|function)\s+options\b/m.test(source) || /^\s*export\s*\{[^}]*\boptions\b[^}]*\}/m.test(source);
+  if (hasK6Options && exportsOptions) {
+    throw new Error(
+      `${journeyPath}: declares both a journey \`k6\` block and \`export const options\`. k6 options are module-scoped \u2014 keep only one of them.`
+    );
+  }
+}
+function formatBuildError(err) {
+  const errors = err.errors;
+  if (!Array.isArray(errors) || errors.length === 0) return err;
+  const lines = errors.map((e) => {
+    const loc = e.location;
+    if (!loc) return e.text;
+    const file = isAbsolute(loc.file) ? loc.file : resolve(process.cwd(), loc.file);
+    return `${file}:${loc.line}:${loc.column + 1}: ${e.text}
+    ${loc.lineText.trim()}`;
   });
+  return new Error(`k6 export failed:
+${lines.join("\n")}`);
+}
+async function exportToK6(opts) {
+  const journeyPath = resolve(process.cwd(), opts.journeyFile);
+  const rawSource = await readFile(journeyPath, "utf8");
+  assertNoEntryConflicts(rawSource, journeyPath, opts.k6Options !== void 0);
+  if (opts.metricsPrefix !== void 0 && !METRIC_PREFIX_RE.test(opts.metricsPrefix)) {
+    throw new Error(
+      `invalid metrics prefix ${JSON.stringify(opts.metricsPrefix)}: use letters, digits and "_" (not starting with a digit)`
+    );
+  }
   const fileBase = basename(journeyPath).replace(/\.journey\.ts$/, "");
-  const outFile = opts.outFile ? resolve2(process.cwd(), opts.outFile) : opts.outDir ? resolve2(process.cwd(), opts.outDir, `${fileBase}.k6.js`) : resolve2(dirname2(journeyPath), `${fileBase}.k6.js`);
+  const outFile = opts.outFile ? resolve(process.cwd(), opts.outFile) : opts.outDir ? resolve(process.cwd(), opts.outDir, `${fileBase}.k6.js`) : resolve(dirname(journeyPath), `${fileBase}.k6.js`);
+  const scriptDir = dirname(outFile);
+  const projectDir = opts.projectDir ? resolve(process.cwd(), opts.projectDir) : findProjectDir(dirname(journeyPath)) ?? process.cwd();
+  const rootRel = relFromScript(scriptDir, projectDir);
+  const config = {
+    ...opts.metricsPrefix ? { metricsPrefix: opts.metricsPrefix } : {},
+    ...opts.haltOnFailure ? { haltOnFailure: true } : {},
+    projectRoot: rootRel.endsWith("/") ? rootRel : `${rootRel}/`
+  };
+  const initSource = `import { __configure } from "@usejourney/core";
+__configure(Object.assign(${JSON.stringify(config)}, { files: ${FILES_PLACEHOLDER} }));
+`;
   const optionsBlock = opts.k6Options ? `export const options = ${JSON.stringify(opts.k6Options, null, 2)};
 ` : "";
-  const source = [
-    HEADER,
-    SHIM_SOURCE,
-    optionsBlock,
-    "// ===== user journey =====",
-    userCode.trimStart(),
-    ENTRY_SOURCE
-  ].join("\n");
-  await mkdir(dirname2(outFile), { recursive: true });
+  const entrySource = `import "journey:init";
+import { __declareMetrics, __iterate } from "@usejourney/core";
+export * from ${JSON.stringify(journeyPath)};
+${optionsBlock}
+// Custom metrics must be declared in the k6 init context.
+__declareMetrics();
+
+export default function () {
+  return __iterate();
+}
+`;
+  const fileRefs = /* @__PURE__ */ new Map();
+  let source;
+  try {
+    const result = await build({
+      stdin: {
+        contents: entrySource,
+        resolveDir: dirname(journeyPath),
+        sourcefile: "journey-k6-entry.js",
+        loader: "js"
+      },
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "neutral",
+      target: "es2020",
+      charset: "utf8",
+      logLevel: "silent",
+      // Module markers in the output (`// journeys/x.journey.ts`) are
+      // project-relative, so emitted scripts don't leak local paths.
+      absWorkingDir: projectDir,
+      banner: { js: HEADER },
+      // Journey projects carry no tsconfig; don't let an ancestor's
+      // (e.g. `verbatimModuleSyntax`) change which imports survive.
+      tsconfigRaw: {},
+      plugins: [journeyPlugin(fileRefs, initSource)]
+    });
+    source = result.outputFiles[0].text;
+  } catch (err) {
+    throw formatBuildError(err);
+  }
+  const fileEntries = [];
+  for (const [p, referrer] of fileRefs) {
+    const abs = isAbsolute(p) ? p : resolve(projectDir, p);
+    if (!existsSync(abs)) {
+      throw new Error(
+        `${referrer}: fileFrom(${JSON.stringify(p)}) \u2192 ${abs} does not exist (fileFrom paths are relative to the project root, ${projectDir})`
+      );
+    }
+    fileEntries.push(
+      `    ${JSON.stringify(p)}: open(${JSON.stringify(relFromScript(scriptDir, abs))}, "b")`
+    );
+  }
+  const fileMap = fileEntries.length ? `{
+${fileEntries.join(",\n")}
+  }` : "{}";
+  if (!source.includes(FILES_PLACEHOLDER)) {
+    throw new Error("k6-adapter: internal error \u2014 init block missing from the bundle");
+  }
+  source = source.replace(FILES_PLACEHOLDER, fileMap);
+  await mkdir(dirname(outFile), { recursive: true });
   await writeFile(outFile, source, "utf8");
   return { outFile, source };
 }
 export {
-  exportToK6
+  exportToK6,
+  findProjectDir,
+  scanFileFromLiterals
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usejourney/k6-adapter",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
     "esbuild": "^0.21.5"
   },
   "devDependencies": {
-    "@usejourney/core": "0.1.4"
+    "@usejourney/core": "0.2.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean",