@usejourney/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1217 @@
+// src/endpoint.ts
+function isEndpointRef(e) {
+  return typeof e.operationId === "string";
+}
+
+// src/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { dirname, isAbsolute, join as join2 } from "path";
+import { z } from "zod";
+
+// src/env.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+var KEY = /* @__PURE__ */ Symbol.for("@usejourney/core::env-state");
+var globals = globalThis;
+var shared = globals[KEY] ?? (globals[KEY] = {});
+function setActiveEnvironment(name, values) {
+  shared.active = { name, values };
+}
+function clearActiveEnvironment() {
+  delete shared.active;
+}
+function env(key) {
+  if (!shared.active) {
+    throw new Error(
+      `env(${JSON.stringify(key)}) called with no active environment. Pass --env <name> or set one via setActiveEnvironment().`
+    );
+  }
+  const value = shared.active.values[key];
+  if (value === void 0) {
+    throw new Error(`env: key "${key}" not found in environment "${shared.active.name}"`);
+  }
+  return value;
+}
+function tryEnv(key) {
+  return shared.active?.values[key];
+}
+async function loadEnvironment(environmentsDir, name) {
+  const path = join(environmentsDir, `${name}.json`);
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    throw new Error(`Could not read environment file ${path}: ${err.message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Environment file ${path} is not valid JSON: ${err.message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Environment file ${path} must contain a JSON object`);
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(parsed)) {
+    out[k] = typeof v === "string" ? v : JSON.stringify(v);
+  }
+  return out;
+}
+async function listEnvironments(environmentsDir) {
+  try {
+    const entries = await readdir(environmentsDir);
+    return entries.filter((e) => e.endsWith(".json")).map((e) => e.slice(0, -".json".length)).sort();
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+// src/config.ts
+var JourneyConfigSchema = z.object({
+  name: z.string().min(1).optional(),
+  spec: z.string().min(1).default("openapi.yaml"),
+  generatedDir: z.string().min(1).default("generated"),
+  journeysDir: z.string().min(1).default("journeys"),
+  environmentsDir: z.string().min(1).default("environments"),
+  defaultEnvironment: z.string().min(1).optional(),
+  baseUrl: z.string().url().optional(),
+  runHistoryKeepCount: z.number().int().min(0).default(20),
+  tlsRejectUnauthorized: z.boolean().default(true)
+}).strict();
+function resolveRelative(projectDir, value) {
+  return isAbsolute(value) ? value : join2(projectDir, value);
+}
+function resolveBaseUrl(config) {
+  return config.baseUrl ?? tryEnv("BASE_URL");
+}
+function resolveConfigPaths(loaded) {
+  const { config, projectDir } = loaded;
+  return {
+    specPath: resolveRelative(projectDir, config.spec),
+    generatedDir: resolveRelative(projectDir, config.generatedDir),
+    journeysDir: resolveRelative(projectDir, config.journeysDir),
+    environmentsDir: resolveRelative(projectDir, config.environmentsDir)
+  };
+}
+async function loadConfig(projectDir) {
+  const configPath = join2(projectDir, "journey.config.json");
+  let raw;
+  try {
+    raw = await readFile2(configPath, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Could not read journey.config.json at ${configPath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`journey.config.json is not valid JSON: ${err.message}`);
+  }
+  const result = JourneyConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+    throw new Error(`journey.config.json failed validation:
+${issues}`);
+  }
+  return { config: result.data, projectDir, configPath };
+}
+
+// src/expect.ts
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AssertionError";
+  }
+};
+function format(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    if (!deepEqual(a[k], b[k])) {
+      return false;
+    }
+  }
+  return true;
+}
+function expect(value) {
+  return {
+    toBe(expected) {
+      if (!Object.is(value, expected)) {
+        throw new AssertionError(`expected ${format(value)} to be ${format(expected)}`);
+      }
+    },
+    toEqual(expected) {
+      if (!deepEqual(value, expected)) {
+        throw new AssertionError(`expected ${format(value)} to equal ${format(expected)}`);
+      }
+    },
+    toBeDefined() {
+      if (value === void 0) {
+        throw new AssertionError(`expected value to be defined`);
+      }
+    },
+    toContain(expected) {
+      if (typeof value === "string") {
+        if (typeof expected !== "string" || !value.includes(expected)) {
+          throw new AssertionError(`expected ${format(value)} to contain ${format(expected)}`);
+        }
+        return;
+      }
+      if (Array.isArray(value)) {
+        if (!value.some((v) => deepEqual(v, expected))) {
+          throw new AssertionError(`expected array to contain ${format(expected)}`);
+        }
+        return;
+      }
+      throw new AssertionError(`toContain is only supported on strings and arrays`);
+    },
+    toMatch(expected) {
+      if (typeof value !== "string") {
+        throw new AssertionError(`toMatch is only supported on strings`);
+      }
+      const re = typeof expected === "string" ? new RegExp(expected) : expected;
+      if (!re.test(value)) {
+        throw new AssertionError(`expected ${format(value)} to match ${re}`);
+      }
+    },
+    toBeGreaterThan(n) {
+      assertNumber(value, "toBeGreaterThan");
+      if (!(value > n)) {
+        throw new AssertionError(`expected ${format(value)} to be greater than ${n}`);
+      }
+    },
+    toBeGreaterThanOrEqual(n) {
+      assertNumber(value, "toBeGreaterThanOrEqual");
+      if (!(value >= n)) {
+        throw new AssertionError(`expected ${format(value)} to be greater than or equal to ${n}`);
+      }
+    },
+    toBeLessThan(n) {
+      assertNumber(value, "toBeLessThan");
+      if (!(value < n)) {
+        throw new AssertionError(`expected ${format(value)} to be less than ${n}`);
+      }
+    },
+    toBeLessThanOrEqual(n) {
+      assertNumber(value, "toBeLessThanOrEqual");
+      if (!(value <= n)) {
+        throw new AssertionError(`expected ${format(value)} to be less than or equal to ${n}`);
+      }
+    },
+    toHaveLength(n) {
+      const len = value?.length;
+      if (typeof len !== "number") {
+        throw new AssertionError(
+          `toHaveLength is only supported on strings, arrays, and objects with a numeric .length`
+        );
+      }
+      if (len !== n) {
+        throw new AssertionError(`expected ${format(value)} to have length ${n}, got ${len}`);
+      }
+    }
+  };
+}
+function assertNumber(value, matcher) {
+  if (typeof value !== "number") {
+    throw new AssertionError(`${matcher} is only supported on numbers (got ${typeof value})`);
+  }
+}
+
+// src/history.ts
+import { mkdir, readdir as readdir2, readFile as readFile3, unlink, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+function makeId() {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const id = ts.replace(/:/g, "-");
+  return { id, timestamp: ts };
+}
+async function writeRun(cacheDir, results) {
+  const runsDir = join3(cacheDir, "runs");
+  await mkdir(runsDir, { recursive: true });
+  const { id, timestamp } = makeId();
+  const record = { id, timestamp, results };
+  await writeFile(join3(runsDir, `${id}.run.json`), JSON.stringify(record, null, 2), "utf8");
+  return record;
+}
+async function listRuns(cacheDir) {
+  const runsDir = join3(cacheDir, "runs");
+  let files;
+  try {
+    files = await readdir2(runsDir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const runs = [];
+  for (const file of files) {
+    if (!file.endsWith(".run.json")) continue;
+    try {
+      const raw = await readFile3(join3(runsDir, file), "utf8");
+      const record = JSON.parse(raw);
+      runs.push({
+        id: record.id,
+        timestamp: record.timestamp,
+        journeyNames: record.results.map((r) => r.name),
+        ok: record.results.every((r) => r.ok),
+        durationMs: record.results.reduce((a, r) => a + (r.durationMs ?? 0), 0),
+        stepCount: record.results.reduce((a, r) => a + r.steps.length, 0)
+      });
+    } catch {
+    }
+  }
+  runs.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  return runs;
+}
+async function readRun(cacheDir, id) {
+  const file = join3(cacheDir, "runs", `${id}.run.json`);
+  try {
+    const raw = await readFile3(file, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+async function pruneRuns(cacheDir, keep) {
+  if (keep <= 0) return 0;
+  const runs = await listRuns(cacheDir);
+  if (runs.length <= keep) return 0;
+  const toDelete = runs.slice(keep);
+  const runsDir = join3(cacheDir, "runs");
+  let deleted = 0;
+  for (const run of toDelete) {
+    try {
+      await unlink(join3(runsDir, `${run.id}.run.json`));
+      deleted++;
+    } catch {
+    }
+  }
+  return deleted;
+}
+
+// src/logger.ts
+var SECRET_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "proxy-authorization"
+];
+function describeError(err, depth = 3) {
+  const parts = [];
+  let cur = err;
+  while (cur !== null && cur !== void 0 && parts.length < depth) {
+    const e = cur;
+    const msg = typeof e.message === "string" ? e.message : String(cur);
+    const code = typeof e.code === "string" ? ` (${e.code})` : "";
+    parts.push(`${msg}${code}`);
+    cur = e.cause;
+  }
+  return parts.length === 0 ? String(err) : parts.join(" \u2190 ");
+}
+function maskHeaders(headers, masks = SECRET_HEADERS) {
+  const lower2 = masks.map((m) => m.toLowerCase());
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    out[k] = lower2.includes(k.toLowerCase()) ? "***" : v;
+  }
+  return out;
+}
+function fmtBody(body, max) {
+  if (body === void 0 || body === null) return "";
+  const s = typeof body === "string" ? body : JSON.stringify(body);
+  return s.length > max ? `${s.slice(0, max)}\u2026 (${s.length - max} more chars)` : s;
+}
+function createConsoleLogger(opts = {}) {
+  const write = opts.write ?? ((line) => console.error(line));
+  const mask = opts.mask !== false;
+  const max = opts.maxBodyChars ?? 1024;
+  return {
+    onRequest(req) {
+      write(`\u2192 ${req.method} ${req.url}`);
+      const headers = mask ? maskHeaders(req.headers) : req.headers;
+      const headerKeys = Object.keys(headers);
+      if (headerKeys.length > 0) write(`  headers ${JSON.stringify(headers)}`);
+      const body = fmtBody(req.body, max);
+      if (body) write(`  body    ${body}`);
+    },
+    onResponse(req, res) {
+      write(`\u2190 ${res.status} ${req.method} ${req.url} (${res.durationMs}ms)`);
+      const body = fmtBody(res.body, max);
+      if (body) write(`  body    ${body}`);
+    },
+    onError(req, err, durationMs) {
+      write(`\u2717 ${req.method} ${req.url} failed after ${durationMs}ms: ${describeError(err)}`);
+    },
+    info(msg) {
+      write(msg);
+    }
+  };
+}
+function loggerFromEnv(env2 = process.env) {
+  const debug = env2.DEBUG;
+  if (!debug) return void 0;
+  const tags = debug.split(",").map((t) => t.trim().toLowerCase());
+  if (tags.some((t) => t === "*" || t === "journey" || t === "journey:*")) {
+    return createConsoleLogger();
+  }
+  return void 0;
+}
+
+// src/http.ts
+function resolveUrl(endpoint, ctx, params, query) {
+  const base = isEndpointRef(endpoint) ? ctx.baseUrl : endpoint.baseUrl ?? ctx.baseUrl;
+  if (!base) {
+    throw new Error(
+      `No base URL configured. Set \`baseUrl\` in journey.config.json or on the endpoint descriptor.`
+    );
+  }
+  let path = endpoint.path;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      path = path.replace(`{${k}}`, encodeURIComponent(String(v)));
+    }
+  }
+  const missing = path.match(/\{([^}]+)\}/);
+  if (missing) {
+    throw new Error(`Missing path param "${missing[1]}" for ${endpoint.method} ${endpoint.path}`);
+  }
+  let url;
+  if (path === "") {
+    url = new URL(base);
+  } else {
+    const baseWithSlash = base.endsWith("/") ? base : `${base}/`;
+    const relPath = path.startsWith("/") ? path.slice(1) : path;
+    url = new URL(relPath, baseWithSlash);
+  }
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0) url.searchParams.append(k, String(v));
+    }
+  }
+  return url.toString();
+}
+function buildRequest(opts, ctx) {
+  const url = resolveUrl(opts.endpoint, ctx, opts.params, opts.query);
+  const headers = {
+    ...ctx.defaultHeaders ?? {},
+    ...opts.headers ?? {}
+  };
+  const hasBody = opts.body !== void 0;
+  if (hasBody && !("content-type" in lower(headers))) {
+    headers["Content-Type"] = "application/json";
+  }
+  const spec = { method: opts.endpoint.method, url, headers };
+  if (hasBody) spec.body = opts.body;
+  if (opts.timeoutMs !== void 0) spec.timeoutMs = opts.timeoutMs;
+  return spec;
+}
+function lower(h) {
+  const out = {};
+  for (const [k, v] of Object.entries(h)) out[k.toLowerCase()] = v;
+  return out;
+}
+async function execute(req, ctx) {
+  const logReq = {
+    method: req.method,
+    url: req.url,
+    headers: req.headers,
+    ...req.body !== void 0 ? { body: req.body } : {}
+  };
+  ctx.logger?.onRequest?.(logReq);
+  const f = ctx.fetchImpl ?? fetch;
+  const init = { method: req.method, headers: req.headers };
+  if (req.body !== void 0) {
+    init.body = typeof req.body === "string" ? req.body : JSON.stringify(req.body);
+  }
+  if (ctx.dispatcher !== void 0) {
+    init.dispatcher = ctx.dispatcher;
+  }
+  let timer;
+  const signals = [];
+  if (req.timeoutMs !== void 0) {
+    const abort = new AbortController();
+    timer = setTimeout(() => abort.abort(), req.timeoutMs);
+    signals.push(abort.signal);
+  }
+  if (ctx.signal) signals.push(ctx.signal);
+  if (signals.length === 1) init.signal = signals[0];
+  else if (signals.length > 1) init.signal = AbortSignal.any(signals);
+  const started = Date.now();
+  try {
+    const res = await f(req.url, init);
+    const headers = {};
+    res.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+    const contentType = res.headers.get("content-type") ?? "";
+    const body = contentType.includes("json") ? await res.json().catch(() => null) : await res.text();
+    const wrapped = { status: res.status, headers, body };
+    ctx.logger?.onResponse?.(logReq, { ...wrapped, durationMs: Date.now() - started });
+    return wrapped;
+  } catch (err) {
+    ctx.logger?.onError?.(logReq, err, Date.now() - started);
+    throw err;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/cache.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile4, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+function subJourneyCacheKey(journeyName, resolvedKey) {
+  return `${journeyName}:${resolvedKey}`;
+}
+function isExpired(entry) {
+  return entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt;
+}
+function entryFor(value, ttlMs) {
+  return ttlMs !== void 0 ? { value, expiresAt: Date.now() + ttlMs } : { value };
+}
+var MemorySubJourneyCache = class {
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (isExpired(entry)) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry;
+  }
+  set(key, value, ttlMs) {
+    this.store.set(key, entryFor(value, ttlMs));
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+var DiskSubJourneyCache = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  pathFor(key) {
+    return join4(this.dir, `${createHash("sha256").update(key).digest("hex")}.json`);
+  }
+  async get(key) {
+    const path = this.pathFor(key);
+    let raw;
+    try {
+      raw = await readFile4(path, "utf8");
+    } catch {
+      return void 0;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+    if (isExpired(entry)) {
+      await rm(path, { force: true });
+      return void 0;
+    }
+    return entry;
+  }
+  async set(key, value, ttlMs) {
+    await mkdir2(this.dir, { recursive: true });
+    await writeFile2(this.pathFor(key), JSON.stringify(entryFor(value, ttlMs)), "utf8");
+  }
+};
+function createSubJourneyCache(mode, opts) {
+  switch (mode) {
+    case "off":
+      return void 0;
+    case "disk":
+      return new DiskSubJourneyCache(opts.diskDir);
+    case "run":
+    case "process":
+      return new MemorySubJourneyCache();
+  }
+}
+
+// src/runtime.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("@usejourney/core::runtime-state");
+var globals2 = globalThis;
+var state = globals2[STATE_KEY] ?? (globals2[STATE_KEY] = {
+  registry: [],
+  collecting: void 0,
+  currentCtx: void 0,
+  childOutputs: []
+});
+var MAX_SUB_JOURNEY_DEPTH = 8;
+function getCurrentCtx() {
+  return state.currentCtx;
+}
+function journey(name, optionsOrBody, maybeBody) {
+  const bodyFn = typeof optionsOrBody === "function" ? optionsOrBody : maybeBody;
+  const options = typeof optionsOrBody === "function" ? void 0 : optionsOrBody;
+  if (options && options.reusable === true) {
+    const reusable = options;
+    const def2 = {
+      name,
+      body: bodyFn,
+      options: {
+        reusable: true,
+        ...reusable.inputs ? { inputs: reusable.inputs } : {},
+        ...reusable.outputs ? { outputs: reusable.outputs } : {}
+      }
+    };
+    const handle = {
+      name,
+      ...reusable.inputs ? { inputs: reusable.inputs } : {},
+      ...reusable.outputs ? { outputs: reusable.outputs } : {},
+      __def: def2
+    };
+    return handle;
+  }
+  const entryOpts = options;
+  const def = {
+    name,
+    body: bodyFn,
+    ...entryOpts ? { options: entryOpts } : {}
+  };
+  state.registry.push(def);
+}
+function step(name, options) {
+  if (!state.collecting) {
+    throw new Error(`step(${JSON.stringify(name)}) called outside a journey(...) body`);
+  }
+  state.collecting.push({
+    kind: "step",
+    def: { name, options }
+  });
+}
+function invokeJourney(handle, opts = {}) {
+  if (!state.collecting) {
+    throw new Error(
+      `invokeJourney(${JSON.stringify(handle.name)}) called outside a journey(...) body`
+    );
+  }
+  const callDef = {
+    handle
+  };
+  if (opts.name !== void 0) callDef.name = opts.name;
+  if (opts.inputs !== void 0) callDef.inputs = opts.inputs;
+  if (opts.cacheKey !== void 0) {
+    const ck = opts.cacheKey;
+    callDef.cacheKey = typeof ck === "function" ? ck : ck;
+  }
+  if (opts.cacheTtlMs !== void 0) callDef.cacheTtlMs = opts.cacheTtlMs;
+  if (opts.cache !== void 0) callDef.cache = opts.cache;
+  if (opts.assert !== void 0) {
+    callDef.assert = opts.assert;
+  }
+  if (opts.after !== void 0) {
+    callDef.after = opts.after;
+  }
+  state.collecting.push({ kind: "sub", def: callDef });
+}
+function output(value) {
+  if (state.childOutputs.length === 0) {
+    state.currentCtx?.logger?.onLog?.({
+      level: "warn",
+      text: "output() called outside a reusable journey; ignored"
+    });
+    return;
+  }
+  const slot = state.childOutputs[state.childOutputs.length - 1];
+  if (slot.written) {
+    state.currentCtx?.logger?.onLog?.({
+      level: "warn",
+      text: "output() called more than once in a single sub-journey; last value wins"
+    });
+  }
+  slot.value = value;
+  slot.written = true;
+}
+function getRegisteredJourneys() {
+  return state.registry;
+}
+function clearRegistry() {
+  state.registry.length = 0;
+}
+async function collectPipeline(def) {
+  return collectPipelineWithInput(def, void 0);
+}
+async function collectSubPipeline(call) {
+  let input;
+  try {
+    input = call.inputs !== void 0 ? await resolveLazy(call.inputs) : void 0;
+  } catch {
+    input = void 0;
+  }
+  return collectPipelineWithInput(call.handle.__def, input);
+}
+async function collectPipelineWithInput(def, input) {
+  const nodes = [];
+  const prev = state.collecting;
+  state.collecting = nodes;
+  try {
+    await def.body(input);
+  } finally {
+    state.collecting = prev;
+  }
+  return nodes;
+}
+async function resolveLazy(v) {
+  if (v === void 0) return void 0;
+  return typeof v === "function" ? await v() : v;
+}
+async function discoverChildNodes(call) {
+  let input;
+  try {
+    input = call.inputs !== void 0 ? await resolveLazy(call.inputs) : void 0;
+  } catch {
+    input = void 0;
+  }
+  try {
+    return await collectPipelineWithInput(call.handle.__def, input);
+  } catch {
+    return null;
+  }
+}
+async function planPipeline(nodes, depth) {
+  const out = [];
+  for (const node of nodes) {
+    if (node.kind === "step") {
+      out.push({
+        kind: "step",
+        name: node.def.name,
+        method: node.def.options.endpoint.method,
+        path: node.def.options.endpoint.path
+      });
+      continue;
+    }
+    const planned = {
+      kind: "sub",
+      name: node.def.name ?? node.def.handle.name
+    };
+    const childNodes = depth < MAX_SUB_JOURNEY_DEPTH ? await discoverChildNodes(node.def) : null;
+    if (childNodes) {
+      planned.children = await planPipeline(childNodes, depth + 1);
+    } else {
+      planned.incomplete = true;
+    }
+    out.push(planned);
+  }
+  return out;
+}
+async function planJourney(def) {
+  const nodes = await collectPipeline(def);
+  return planPipeline(nodes, 0);
+}
+async function executeStepNode(s, ctx, meta, stepIdx) {
+  const start = Date.now();
+  ctx.logger?.onStepStart?.({
+    runId: meta.runId,
+    journeyIdx: meta.journeyIdx,
+    journeyName: meta.journeyName,
+    stepIdx,
+    name: s.name
+  });
+  try {
+    const headers = await resolveLazy(s.options.headers);
+    const query = await resolveLazy(s.options.query);
+    const body = await resolveLazy(s.options.body);
+    const params = await resolveLazy(s.options.params);
+    const req = buildRequest(
+      {
+        endpoint: s.options.endpoint,
+        ...params !== void 0 ? { params } : {},
+        ...query !== void 0 ? { query } : {},
+        ...headers !== void 0 ? { headers } : {},
+        ...body !== void 0 ? { body } : {},
+        ...s.options.timeoutMs !== void 0 ? { timeoutMs: s.options.timeoutMs } : {}
+      },
+      ctx
+    );
+    const response = await execute(req, ctx);
+    if (s.options.assert) await s.options.assert(response);
+    if (s.options.after) await s.options.after(response);
+    const durationMs = Date.now() - start;
+    ctx.logger?.onStepEnd?.({
+      runId: meta.runId,
+      journeyIdx: meta.journeyIdx,
+      stepIdx,
+      ok: true,
+      durationMs
+    });
+    return {
+      name: s.name,
+      ok: true,
+      request: { method: req.method, url: req.url },
+      response,
+      durationMs
+    };
+  } catch (err) {
+    const durationMs = Date.now() - start;
+    const error = describeError(err);
+    ctx.logger?.onStepEnd?.({
+      runId: meta.runId,
+      journeyIdx: meta.journeyIdx,
+      stepIdx,
+      ok: false,
+      durationMs,
+      error
+    });
+    return { name: s.name, ok: false, error, durationMs };
+  }
+}
+function resolveCacheKey(cacheKey, input) {
+  if (cacheKey === void 0) return void 0;
+  if (typeof cacheKey === "function") return cacheKey(input);
+  return cacheKey;
+}
+async function executeSubNode(call, ctx, meta, stepIdx, upToStepIdx, depth, execState) {
+  const displayName = call.name ?? call.handle.name;
+  const start = Date.now();
+  const firstChildStepIdx = stepIdx + 1;
+  let input;
+  try {
+    input = call.inputs !== void 0 ? await resolveLazy(call.inputs) : void 0;
+    if (call.handle.inputs) {
+      input = call.handle.inputs.parse(input);
+    }
+  } catch (err) {
+    const durationMs2 = Date.now() - start;
+    const error = `sub-journey "${call.handle.name}" input validation failed: ${describeError(err)}`;
+    ctx.logger?.onGroupStart?.({
+      runId: meta.runId,
+      journeyIdx: meta.journeyIdx,
+      name: displayName,
+      childJourneyName: call.handle.name,
+      stepIdx,
+      firstChildStepIdx,
+      cacheStatus: "miss"
+    });
+    ctx.logger?.onGroupEnd?.({
+      runId: meta.runId,
+      journeyIdx: meta.journeyIdx,
+      name: displayName,
+      childJourneyName: call.handle.name,
+      stepIdx,
+      lastChildStepIdx: stepIdx,
+      ok: false,
+      durationMs: durationMs2,
+      error
+    });
+    return { name: displayName, ok: false, error, durationMs: durationMs2, kind: "sub", children: [] };
+  }
+  const resolvedKey = resolveCacheKey(call.cacheKey, input);
+  const cache = ctx.subJourneyCache;
+  const cacheKeyStr = cache !== void 0 && resolvedKey !== void 0 && call.cache !== "off" ? subJourneyCacheKey(call.handle.name, resolvedKey) : void 0;
+  if (cache !== void 0 && cacheKeyStr !== void 0) {
+    const entry = await cache.get(cacheKeyStr);
+    if (entry !== void 0) {
+      ctx.logger?.onGroupStart?.({
+        runId: meta.runId,
+        journeyIdx: meta.journeyIdx,
+        name: displayName,
+        childJourneyName: call.handle.name,
+        stepIdx,
+        firstChildStepIdx,
+        cacheStatus: "hit",
+        resolvedKey
+      });
+      let cachedOutput = entry.value;
+      let ok = true;
+      let error;
+      if (call.handle.outputs) {
+        try {
+          cachedOutput = call.handle.outputs.parse(entry.value);
+        } catch (err) {
+          ok = false;
+          error = `sub-journey "${call.handle.name}" cached output failed validation: ${describeError(err)}`;
+        }
+      }
+      if (ok) {
+        try {
+          if (call.assert) await call.assert(cachedOutput);
+          if (call.after) await call.after(cachedOutput);
+        } catch (err) {
+          ok = false;
+          error = describeError(err);
+        }
+      }
+      const durationMs2 = Date.now() - start;
+      ctx.logger?.onGroupEnd?.({
+        runId: meta.runId,
+        journeyIdx: meta.journeyIdx,
+        name: displayName,
+        childJourneyName: call.handle.name,
+        stepIdx,
+        lastChildStepIdx: stepIdx,
+        ok,
+        durationMs: durationMs2,
+        ...error !== void 0 ? { error } : {}
+      });
+      return {
+        name: displayName,
+        ok,
+        durationMs: durationMs2,
+        kind: "sub",
+        children: [],
+        cacheStatus: "hit",
+        ...error !== void 0 ? { error } : {}
+      };
+    }
+  }
+  const groupStart = {
+    runId: meta.runId,
+    journeyIdx: meta.journeyIdx,
+    name: displayName,
+    childJourneyName: call.handle.name,
+    stepIdx,
+    firstChildStepIdx,
+    cacheStatus: "miss",
+    ...resolvedKey !== void 0 ? { resolvedKey } : {}
+  };
+  ctx.logger?.onGroupStart?.(groupStart);
+  let childNodes;
+  const prevCollecting = state.collecting;
+  state.collecting = [];
+  try {
+    await call.handle.__def.body(input);
+    childNodes = state.collecting;
+  } finally {
+    state.collecting = prevCollecting;
+  }
+  const slot = { value: void 0, written: false };
+  state.childOutputs.push(slot);
+  const children = [];
+  let childOk = true;
+  let childError;
+  try {
+    const childExecState = { counter: stepIdx + 1, ok: true, halt: false };
+    await executePipeline(childNodes, ctx, meta, upToStepIdx, depth + 1, childExecState, children);
+    childOk = childExecState.ok;
+    execState.counter = childExecState.counter;
+    if (!childOk) {
+      const failed = children.find((c) => !c.ok);
+      childError = failed ? `sub-journey "${call.handle.name}" failed at step "${failed.name}": ${failed.error ?? "unknown error"}` : `sub-journey "${call.handle.name}" failed`;
+    }
+    if (childExecState.halt) execState.halt = true;
+  } finally {
+    state.childOutputs.pop();
+  }
+  let validatedOutput = slot.written ? slot.value : void 0;
+  if (childOk) {
+    if (call.handle.outputs) {
+      if (!slot.written) {
+        childOk = false;
+        childError = `sub-journey "${call.handle.name}" did not call output() before completing`;
+      } else {
+        try {
+          validatedOutput = call.handle.outputs.parse(slot.value);
+        } catch (err) {
+          childOk = false;
+          childError = `sub-journey "${call.handle.name}" output validation failed: ${describeError(err)}`;
+        }
+      }
+    }
+  }
+  if (childOk && cache !== void 0 && cacheKeyStr !== void 0) {
+    const ttlMs = call.cacheTtlMs ?? ctx.subJourneyCacheTtlMs;
+    await cache.set(cacheKeyStr, validatedOutput, ttlMs);
+  }
+  if (childOk) {
+    try {
+      if (call.assert) await call.assert(validatedOutput);
+      if (call.after) await call.after(validatedOutput);
+    } catch (err) {
+      childOk = false;
+      childError = describeError(err);
+    }
+  }
+  const durationMs = Date.now() - start;
+  const lastChildStepIdx = children.length > 0 ? execState.counter - 1 : stepIdx;
+  const groupEnd = {
+    runId: meta.runId,
+    journeyIdx: meta.journeyIdx,
+    name: displayName,
+    childJourneyName: call.handle.name,
+    stepIdx,
+    lastChildStepIdx,
+    ok: childOk,
+    durationMs,
+    ...childError !== void 0 ? { error: childError } : {}
+  };
+  ctx.logger?.onGroupEnd?.(groupEnd);
+  return {
+    name: displayName,
+    ok: childOk,
+    durationMs,
+    kind: "sub",
+    children,
+    cacheStatus: "miss",
+    ...childError !== void 0 ? { error: childError } : {}
+  };
+}
+async function executePipeline(nodes, ctx, meta, upToStepIdx, depth, execState, out) {
+  if (depth > MAX_SUB_JOURNEY_DEPTH) {
+    throw new Error(
+      `sub-journey recursion depth exceeded (max ${MAX_SUB_JOURNEY_DEPTH}); check for cycles`
+    );
+  }
+  for (const node of nodes) {
+    if (ctx.signal?.aborted) {
+      execState.ok = false;
+      execState.halt = true;
+      break;
+    }
+    if (upToStepIdx !== void 0 && execState.counter > upToStepIdx) {
+      execState.halt = true;
+      break;
+    }
+    const stepIdx = execState.counter++;
+    if (node.kind === "step") {
+      const r = await executeStepNode(node.def, ctx, meta, stepIdx);
+      out.push(r);
+      if (!r.ok) {
+        execState.ok = false;
+        execState.halt = true;
+        break;
+      }
+    } else {
+      const r = await executeSubNode(node.def, ctx, meta, stepIdx, upToStepIdx, depth, execState);
+      out.push(r);
+      if (!r.ok) {
+        execState.ok = false;
+        execState.halt = true;
+        break;
+      }
+    }
+  }
+}
+async function runJourney(def, ctx, opts = {}) {
+  const nodes = await collectPipeline(def);
+  const runId = opts.runId ?? newRunId();
+  const journeyIdx = opts.journeyIdx ?? 0;
+  const stepIdxOffset = opts.stepIdxOffset ?? 0;
+  ctx.logger?.onPlanned?.({
+    runId,
+    journeyIdx,
+    journeyName: def.name,
+    stepIdxOffset,
+    steps: await planPipeline(nodes, 0)
+  });
+  const journeyStart = Date.now();
+  const meta = { runId, journeyIdx, journeyName: def.name };
+  const execState = { counter: stepIdxOffset, ok: true, halt: false };
+  const results = [];
+  const prevCtx = state.currentCtx;
+  state.currentCtx = ctx;
+  try {
+    await executePipeline(nodes, ctx, meta, opts.upToStepIdx, 0, execState, results);
+  } finally {
+    state.currentCtx = prevCtx;
+  }
+  return {
+    name: def.name,
+    ok: execState.ok,
+    steps: results,
+    durationMs: Date.now() - journeyStart
+  };
+}
+async function runAllRegistered(ctx, opts = {}) {
+  const defs = state.registry.slice();
+  for (const def of defs) {
+    if (def.options?.inputs !== void 0 || def.options?.outputs !== void 0) {
+      throw new Error(
+        `journey "${def.name}" declares an inputs/outputs schema but is registered as an entry. Mark it { reusable: true } and invoke it via invokeJourney(handle, ...), or remove the schema.`
+      );
+    }
+  }
+  clearRegistry();
+  const runId = opts.runId ?? newRunId();
+  ctx.logger?.onRunStart?.({ runId, journeyNames: defs.map((d) => d.name) });
+  const runStart = Date.now();
+  const results = [];
+  let ok = true;
+  let stepIdxOffset = 0;
+  for (let journeyIdx = 0; journeyIdx < defs.length; journeyIdx++) {
+    const def = defs[journeyIdx];
+    const result = await runJourney(def, ctx, {
+      runId,
+      journeyIdx,
+      stepIdxOffset,
+      ...opts.upToStepIdx !== void 0 ? { upToStepIdx: opts.upToStepIdx } : {}
+    });
+    results.push(result);
+    if (!result.ok) ok = false;
+    stepIdxOffset += countLeaves(result.steps);
+    if (opts.upToStepIdx !== void 0 && stepIdxOffset > opts.upToStepIdx) break;
+    if (ctx.signal?.aborted) {
+      ok = false;
+      break;
+    }
+  }
+  ctx.logger?.onRunEnd?.({
+    runId,
+    ok,
+    durationMs: Date.now() - runStart,
+    results: results.map((r) => ({ name: r.name, ok: r.ok }))
+  });
+  return results;
+}
+function countLeaves(steps) {
+  let n = 0;
+  for (const s of steps) {
+    n += 1;
+    if (s.children) n += countLeaves(s.children);
+  }
+  return n;
+}
+function newRunId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/fetch.ts
+async function fetch2(input, init) {
+  const ctx = getCurrentCtx();
+  const logger = ctx?.logger;
+  const realFetch = globalThis.fetch;
+  const mergedInit = mergeAbortSignal(init, ctx?.signal);
+  if (!logger) {
+    return realFetch(input, mergedInit);
+  }
+  const reqLog = buildRequestLog(input, mergedInit);
+  logger.onRequest?.(reqLog);
+  const started = Date.now();
+  let res;
+  try {
+    res = await realFetch(input, mergedInit);
+  } catch (err) {
+    logger.onError?.(reqLog, err, Date.now() - started);
+    throw err;
+  }
+  logger.onResponse?.(reqLog, await buildResponseLog(res, Date.now() - started));
+  return res;
+}
+function mergeAbortSignal(init, runSignal) {
+  if (!runSignal) return init;
+  const userSignal = init?.signal ?? void 0;
+  const merged = userSignal ? AbortSignal.any([userSignal, runSignal]) : runSignal;
+  return { ...init ?? {}, signal: merged };
+}
+function buildRequestLog(input, init) {
+  const isRequest = typeof Request !== "undefined" && input instanceof Request;
+  const method = (init?.method ?? (isRequest ? input.method : "GET")).toUpperCase();
+  const url = isRequest ? input.url : typeof input === "string" ? input : input instanceof URL ? input.toString() : String(input);
+  const headers = headersToRecord(init?.headers ?? (isRequest ? input.headers : void 0));
+  const log = { method, url, headers };
+  if (init?.body !== void 0 && init?.body !== null) log.body = bodyForLog(init.body);
+  return log;
+}
+async function buildResponseLog(res, durationMs) {
+  const headers = {};
+  res.headers.forEach((v, k) => {
+    headers[k] = v;
+  });
+  const contentType = res.headers.get("content-type") ?? "";
+  let body = "<unreadable>";
+  try {
+    const cloned = res.clone();
+    body = contentType.includes("json") ? await cloned.json().catch(() => null) : await cloned.text();
+  } catch {
+    body = "<unreadable>";
+  }
+  return { status: res.status, headers, body, durationMs };
+}
+function headersToRecord(headers) {
+  if (!headers) return {};
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    const out = {};
+    headers.forEach((v, k) => {
+      out[k] = v;
+    });
+    return out;
+  }
+  if (Array.isArray(headers)) {
+    const out = {};
+    for (const [k, v] of headers) out[k] = v;
+    return out;
+  }
+  return { ...headers };
+}
+function bodyForLog(body) {
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+  return "<binary>";
+}
+
+// src/index.ts
+import { z as z2 } from "zod";
+export {
+  AssertionError,
+  DiskSubJourneyCache,
+  JourneyConfigSchema,
+  MemorySubJourneyCache,
+  SECRET_HEADERS,
+  buildRequest,
+  clearActiveEnvironment,
+  clearRegistry,
+  collectPipeline,
+  collectSubPipeline,
+  createConsoleLogger,
+  createSubJourneyCache,
+  describeError,
+  env,
+  execute,
+  expect,
+  fetch2 as fetch,
+  getCurrentCtx,
+  getRegisteredJourneys,
+  invokeJourney,
+  isEndpointRef,
+  journey,
+  listEnvironments,
+  listRuns,
+  loadConfig,
+  loadEnvironment,
+  loggerFromEnv,
+  maskHeaders,
+  output,
+  planJourney,
+  pruneRuns,
+  readRun,
+  resolveBaseUrl,
+  resolveConfigPaths,
+  resolveUrl,
+  runAllRegistered,
+  runJourney,
+  setActiveEnvironment,
+  step,
+  subJourneyCacheKey,
+  tryEnv,
+  writeRun,
+  z2 as z
+};