@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.10

package/dist/chunk-XEG3FE2R.js

@@ -0,0 +1,766 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  require_dist
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/stubs/dist/spec.js
+var import_yaml = __toESM(require_dist(), 1);
+
+// packages/stubs/dist/schema.js
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isSchema = (s) => typeof s === "object" && s !== null && !Array.isArray(s);
+var types = (s) => {
+  const t = s.type === void 0 ? [] : Array.isArray(s.type) ? s.type : [s.type];
+  return s.nullable && t.length > 0 && !t.includes("null") ? [...t, "null"] : t;
+};
+var FORMATS = {
+  date: {
+    test: (s) => /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/.test(s),
+    message: "must be a date (YYYY-MM-DD)"
+  },
+  "date-time": {
+    test: (s) => /^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/.test(s) && !Number.isNaN(Date.parse(s)),
+    message: "must be a date-time (RFC 3339)"
+  },
+  uuid: {
+    test: (s) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s),
+    message: "must be a UUID"
+  },
+  email: { test: (s) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s), message: "must be an email address" },
+  uri: { test: (s) => /^[a-z][a-z0-9+.-]*:\S*$/i.test(s), message: "must be a URI" },
+  ipv4: {
+    test: (s) => /^((25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(25[0-5]|2[0-4]\d|1?\d?\d)$/.test(s),
+    message: "must be an IPv4 address"
+  }
+};
+var TYPE_MESSAGE = {
+  string: "must be a string",
+  integer: "must be an integer",
+  number: "must be a number",
+  boolean: "must be true or false",
+  object: "must be an object",
+  array: "must be an array",
+  null: "must be null"
+};
+function hasType(v, t) {
+  switch (t) {
+    case "string":
+      return typeof v === "string";
+    case "integer":
+      return typeof v === "number" && Number.isInteger(v);
+    case "number":
+      return typeof v === "number" && Number.isFinite(v);
+    case "boolean":
+      return typeof v === "boolean";
+    case "object":
+      return isObj(v);
+    case "array":
+      return Array.isArray(v);
+    case "null":
+      return v === null;
+    default:
+      return true;
+  }
+}
+var pointerPart = (k) => k.replace(/~/g, "~0").replace(/\//g, "~1");
+var show = (v) => typeof v === "string" ? v : JSON.stringify(v);
+function validate(value, schema, pointer = "", direction = "request") {
+  if (!isSchema(schema))
+    return [];
+  const errors = [];
+  const err = (message, p = pointer) => errors.push({ pointer: p, message });
+  for (const sub of schema.allOf ?? [])
+    errors.push(...validate(value, sub, pointer, direction));
+  const alts = schema.oneOf ?? schema.anyOf;
+  if (alts && alts.length > 0 && !alts.some((a) => validate(value, a, pointer, direction).length === 0))
+    err("doesn't match any of the allowed shapes");
+  const t = types(schema);
+  if (t.length > 0 && !t.some((x) => hasType(value, x))) {
+    err(TYPE_MESSAGE[t.find((x) => x !== "null") ?? "null"] ?? `must be ${t.join(" or ")}`);
+    return errors;
+  }
+  if (value === null)
+    return errors;
+  if (schema.const !== void 0 && JSON.stringify(schema.const) !== JSON.stringify(value))
+    err(`must be ${show(schema.const)}`);
+  if (schema.enum && !schema.enum.some((e) => JSON.stringify(e) === JSON.stringify(value)))
+    err(`must be one of ${schema.enum.map(show).join(", ")}`);
+  if (typeof value === "string") {
+    const f = schema.format ? FORMATS[schema.format] : void 0;
+    if (f && !f.test(value))
+      err(f.message);
+    if (schema.minLength !== void 0 && value.length < schema.minLength)
+      err(`must be at least ${schema.minLength} character${schema.minLength === 1 ? "" : "s"} long`);
+    if (schema.maxLength !== void 0 && value.length > schema.maxLength)
+      err(`must be at most ${schema.maxLength} character${schema.maxLength === 1 ? "" : "s"} long`);
+  }
+  if (typeof value === "number") {
+    if (schema.format === "int32" && (value < -2147483648 || value > 2147483647))
+      err("must fit in 32 bits");
+    const exMin = typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : schema.exclusiveMinimum === true ? schema.minimum : void 0;
+    const exMax = typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : schema.exclusiveMaximum === true ? schema.maximum : void 0;
+    if (exMin !== void 0 && value <= exMin)
+      err(`must be more than ${exMin}`);
+    else if (schema.minimum !== void 0 && value < schema.minimum)
+      err(`must be at least ${schema.minimum}`);
+    if (exMax !== void 0 && value >= exMax)
+      err(`must be less than ${exMax}`);
+    else if (schema.maximum !== void 0 && value > schema.maximum)
+      err(`must be at most ${schema.maximum}`);
+  }
+  if (Array.isArray(value)) {
+    if (schema.minItems !== void 0 && value.length < schema.minItems)
+      err(`must have at least ${schema.minItems} item${schema.minItems === 1 ? "" : "s"}`);
+    if (schema.items)
+      value.forEach((v, i) => errors.push(...validate(v, schema.items, `${pointer}/${i}`, direction)));
+  }
+  if (isObj(value)) {
+    const props = schema.properties ?? {};
+    const skip = (k) => direction === "request" ? props[k]?.readOnly === true : props[k]?.writeOnly === true;
+    for (const k of schema.required ?? [])
+      if (value[k] === void 0 && !skip(k))
+        err("is required", `${pointer}/${pointerPart(k)}`);
+    for (const [k, sub] of Object.entries(props))
+      if (value[k] !== void 0)
+        errors.push(...validate(value[k], sub, `${pointer}/${pointerPart(k)}`, direction));
+  }
+  return errors;
+}
+function coerce(text, schema) {
+  const t = schema ? types(schema) : [];
+  if (t.includes("string") || t.length === 0)
+    return text;
+  if ((t.includes("integer") || t.includes("number")) && /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(text))
+    return Number(text);
+  if (t.includes("boolean") && (text === "true" || text === "false"))
+    return text === "true";
+  if (t.includes("null") && text === "null")
+    return null;
+  return text;
+}
+var FORMAT_SAMPLES = {
+  date: "2024-01-01",
+  "date-time": "2024-01-01T00:00:00Z",
+  uuid: "00000000-0000-4000-8000-000000000000",
+  email: "user@example.com",
+  uri: "https://example.com/",
+  ipv4: "192.0.2.1",
+  byte: "AA=="
+};
+function schemaExample(schema) {
+  if (!isSchema(schema))
+    return void 0;
+  if (schema.example !== void 0)
+    return { value: schema.example, source: "schema-example" };
+  if (Array.isArray(schema.examples) && schema.examples.length > 0)
+    return { value: schema.examples[0], source: "schema-example" };
+  if (schema.default !== void 0)
+    return { value: schema.default, source: "schema-default" };
+  return void 0;
+}
+function generate(schema, depth = 0) {
+  if (!isSchema(schema) || depth > 12)
+    return null;
+  const own = schemaExample(schema);
+  if (own)
+    return own.value;
+  if (schema.const !== void 0)
+    return schema.const;
+  if (schema.enum && schema.enum.length > 0)
+    return schema.enum[0];
+  if (schema.allOf && schema.allOf.length > 0) {
+    const parts = schema.allOf.map((s) => generate(s, depth + 1));
+    const mine = schema.properties ? generate({ ...schema, allOf: void 0 }, depth + 1) : {};
+    if (parts.every(isObj) && isObj(mine))
+      return Object.assign({}, ...parts, mine);
+    return parts[0];
+  }
+  const alts = schema.oneOf ?? schema.anyOf;
+  if (alts && alts.length > 0)
+    return generate(alts[0], depth + 1);
+  const t = types(schema).find((x) => x !== "null") ?? (schema.properties ? "object" : schema.items ? "array" : void 0);
+  switch (t) {
+    case "object": {
+      const out = {};
+      for (const [k, sub] of Object.entries(schema.properties ?? {}))
+        if (!sub.writeOnly)
+          out[k] = generate(sub, depth + 1);
+      return out;
+    }
+    case "array": {
+      const n = Math.max(1, schema.minItems ?? 1);
+      return Array.from({ length: n }, () => generate(schema.items, depth + 1));
+    }
+    case "string": {
+      const s = (schema.format && FORMAT_SAMPLES[schema.format]) ?? "string";
+      return schema.minLength && s.length < schema.minLength ? s.padEnd(schema.minLength, "x") : s;
+    }
+    case "integer":
+    case "number": {
+      let n = schema.minimum ?? (typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : 0);
+      if (schema.minimum === void 0 && schema.maximum !== void 0 && schema.maximum < n)
+        n = schema.maximum;
+      if (schema.exclusiveMinimum === true || typeof schema.exclusiveMinimum === "number")
+        n += 1;
+      return t === "integer" ? Math.ceil(n) : n;
+    }
+    case "boolean":
+      return true;
+    case "null":
+      return null;
+    default:
+      return {};
+  }
+}
+
+// packages/stubs/dist/spec.js
+var METHODS = ["get", "put", "post", "delete", "patch", "head", "options", "trace"];
+var isObj2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isJson = (mediaType) => /(^|\/|\+)json($|;)/i.test(mediaType) || mediaType === "*/*";
+function parseSpec(text) {
+  let doc;
+  try {
+    doc = (0, import_yaml.parse)(text);
+  } catch (e) {
+    throw new Error(`Can't read the spec: ${e.message.split("\n")[0]}`, { cause: e });
+  }
+  if (!isObj2(doc))
+    throw new Error("This file is not an OpenAPI 3 or Swagger 2.0 spec.");
+  return doc;
+}
+function derefAll(doc, warnings) {
+  const lookup = (ref) => {
+    let cur = doc;
+    for (const raw of ref.slice(2).split("/")) {
+      const key = decodeURIComponent(raw).replace(/~1/g, "/").replace(/~0/g, "~");
+      cur = isObj2(cur) ? cur[key] : void 0;
+    }
+    return cur;
+  };
+  const walk = (node, stack) => {
+    if (Array.isArray(node))
+      return node.map((n) => walk(n, stack));
+    if (!isObj2(node))
+      return node;
+    if (typeof node.$ref === "string") {
+      const ref = node.$ref;
+      if (!ref.startsWith("#/")) {
+        warnings.add(`Can't follow ${ref}: only refs inside the spec are read.`);
+        return {};
+      }
+      if (stack.includes(ref))
+        return {};
+      const target = lookup(ref);
+      if (target === void 0) {
+        warnings.add(`${ref} points at nothing.`);
+        return {};
+      }
+      return walk(target, [...stack, ref]);
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(node))
+      out[k] = walk(v, stack);
+    return out;
+  };
+  return walk(doc, []);
+}
+function statusOrder(s) {
+  if (/^\d{3}$/.test(s))
+    return Number(s);
+  if (/^[1-5]XX$/i.test(s))
+    return Number(s[0]) * 100 + 99.5;
+  return 1e3;
+}
+function pickMedia(content) {
+  if (!isObj2(content))
+    return void 0;
+  const entries = Object.entries(content).filter((e) => isObj2(e[1]));
+  return entries.find(([m]) => m.toLowerCase() === "application/json") ?? entries.find(([m]) => isJson(m)) ?? entries[0];
+}
+function responseBody(example, examples, schema) {
+  const named = {};
+  if (isObj2(examples))
+    for (const [k, v] of Object.entries(examples))
+      named[k] = isObj2(v) && "value" in v ? v.value : v;
+  if (example !== void 0)
+    return { body: example, example: "example", named };
+  const first = Object.values(named)[0];
+  if (first !== void 0)
+    return { body: first, example: "examples", named };
+  const own = schemaExample(schema);
+  if (own)
+    return { body: own.value, example: own.source, named };
+  if (schema)
+    return { body: generate(schema), example: "generated", named };
+  return { example: "none", named };
+}
+var SCHEMA_KEYS = [
+  "type",
+  "format",
+  "enum",
+  "items",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "minLength",
+  "maxLength",
+  "default"
+];
+var inlineSchema = (p) => Object.fromEntries(SCHEMA_KEYS.filter((k) => p[k] !== void 0).map((k) => [k, p[k]]));
+function basePathsOf(doc, swagger) {
+  const raw = [];
+  if (swagger) {
+    if (typeof doc.basePath === "string")
+      raw.push(doc.basePath);
+  } else if (Array.isArray(doc.servers)) {
+    for (const s of doc.servers) {
+      if (!isObj2(s) || typeof s.url !== "string")
+        continue;
+      const vars = isObj2(s.variables) ? s.variables : {};
+      const url = s.url.replace(/\{([^}]+)\}/g, (m, v) => {
+        const d = isObj2(vars[v]) ? vars[v].default : void 0;
+        return typeof d === "string" ? d : m;
+      });
+      if (/\{/.test(url))
+        continue;
+      try {
+        raw.push(new URL(url, "http://stub.invalid").pathname);
+      } catch {
+      }
+    }
+  }
+  return [...new Set(raw.map((p) => p.replace(/\/+$/, "")).filter((p) => p && p !== "/"))].sort();
+}
+function buildStub(spec) {
+  const input = typeof spec === "string" ? parseSpec(spec) : spec;
+  if (!isObj2(input))
+    throw new Error("This file is not an OpenAPI 3 or Swagger 2.0 spec.");
+  const swagger = String(input.swagger ?? "") === "2.0";
+  if (!swagger && !/^3\./.test(String(input.openapi ?? "")))
+    throw new Error("This file is not an OpenAPI 3 or Swagger 2.0 spec.");
+  const warnings = /* @__PURE__ */ new Set();
+  const doc = derefAll(input, warnings);
+  const info = isObj2(doc.info) ? doc.info : {};
+  const routes = [];
+  const paths = isObj2(doc.paths) ? doc.paths : {};
+  const produces = Array.isArray(doc.produces) ? doc.produces.map(String) : [];
+  for (const [path, item] of Object.entries(paths)) {
+    if (!isObj2(item))
+      continue;
+    const shared = Array.isArray(item.parameters) ? item.parameters.filter(isObj2) : [];
+    for (const m of METHODS) {
+      const op = item[m];
+      if (!isObj2(op))
+        continue;
+      const own = Array.isArray(op.parameters) ? op.parameters.filter(isObj2) : [];
+      const merged = [
+        ...shared.filter((s) => !own.some((o) => o.name === s.name && o.in === s.in)),
+        ...own
+      ];
+      const params = [];
+      let body;
+      for (const p of merged) {
+        const where = String(p.in ?? "");
+        if (where === "path" || where === "query" || where === "header") {
+          const schema = swagger ? inlineSchema(p) : isObj2(p.schema) ? p.schema : void 0;
+          params.push({
+            name: String(p.name ?? ""),
+            in: where,
+            required: where === "path" || p.required === true,
+            ...schema ? { schema } : {}
+          });
+        } else if (where === "body")
+          body = {
+            required: p.required === true,
+            json: true,
+            ...isObj2(p.schema) ? { schema: p.schema } : {}
+          };
+        else if (where === "formData")
+          body = { required: p.required === true, json: false };
+      }
+      if (!swagger && isObj2(op.requestBody)) {
+        const media = pickMedia(op.requestBody.content);
+        const json = media ? isJson(media[0]) : false;
+        body = {
+          required: op.requestBody.required === true,
+          json,
+          ...json && media && isObj2(media[1].schema) ? { schema: media[1].schema } : {}
+        };
+      }
+      const responses = [];
+      for (const [status, r] of Object.entries(isObj2(op.responses) ? op.responses : {})) {
+        if (!isObj2(r))
+          continue;
+        const description = typeof r.description === "string" ? r.description : void 0;
+        let mediaType;
+        let picked;
+        if (swagger) {
+          const ex = isObj2(r.examples) ? r.examples : {};
+          const exType = Object.keys(ex).find((k) => k.toLowerCase() === "application/json") ?? Object.keys(ex).find(isJson);
+          const schema = isObj2(r.schema) ? r.schema : void 0;
+          mediaType = exType ?? produces.find(isJson) ?? (schema ? "application/json" : void 0);
+          picked = exType ? { body: ex[exType], example: "examples", named: {} } : responseBody(void 0, void 0, schema);
+        } else {
+          const media = pickMedia(r.content);
+          mediaType = media?.[0];
+          picked = media ? responseBody(media[1].example, media[1].examples, isObj2(media[1].schema) ? media[1].schema : void 0) : responseBody(void 0, void 0, void 0);
+        }
+        responses.push({
+          status: status.toUpperCase() === "DEFAULT" ? "default" : status.toUpperCase(),
+          ...description !== void 0 ? { description } : {},
+          ...mediaType ? { mediaType } : {},
+          ...picked
+        });
+      }
+      responses.sort((a, b) => statusOrder(a.status) - statusOrder(b.status));
+      const ok = responses.find((r) => /^2\d\d$/.test(r.status)) ?? responses.find((r) => r.status === "2XX") ?? responses.find((r) => r.status === "default");
+      routes.push({
+        method: m.toUpperCase(),
+        path,
+        ...typeof op.operationId === "string" ? { operationId: op.operationId } : {},
+        params,
+        ...body ? { body } : {},
+        responses,
+        status: ok && /^\d{3}$/.test(ok.status) ? Number(ok.status) : 200,
+        example: ok?.example ?? "none"
+      });
+    }
+  }
+  return {
+    title: typeof info.title === "string" ? info.title : "Stub",
+    ...info.version !== void 0 ? { version: String(info.version) } : {},
+    basePaths: basePathsOf(doc, swagger),
+    routes: sortRoutes(routes),
+    warnings: [...warnings].sort()
+  };
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => a.path === b.path ? a.method < b.method ? -1 : 1 : a.path < b.path ? -1 : 1);
+}
+
+// packages/stubs/dist/stub.js
+import { createServer } from "node:http";
+var NO_BODY = /* @__PURE__ */ new Set([204, 205, 304]);
+var IGNORED_HEADERS = /* @__PURE__ */ new Set(["accept", "content-type", "authorization"]);
+var either = (items) => items.length <= 1 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`;
+function compile(route) {
+  const parts = route.path.split("/").filter(Boolean);
+  let literalSegments = 0;
+  let literalChars = 0;
+  const segments = parts.map((seg) => {
+    const names = [];
+    const src = seg.split(/(\{[^}]+\})/).map((piece) => {
+      const m = /^\{([^}]+)\}$/.exec(piece);
+      if (m) {
+        names.push(m[1]);
+        return "([^/]+)";
+      }
+      literalChars += piece.length;
+      return piece.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }).join("");
+    if (names.length === 0)
+      literalSegments++;
+    return { re: new RegExp(`^${src}$`), names };
+  });
+  return { route, segments, literalSegments, literalChars };
+}
+function matchPath(c, parts) {
+  if (parts.length !== c.segments.length)
+    return void 0;
+  const params = {};
+  for (let i = 0; i < parts.length; i++) {
+    const m = c.segments[i].re.exec(parts[i]);
+    if (!m)
+      return void 0;
+    c.segments[i].names.forEach((n, j) => params[n] = m[j + 1]);
+  }
+  return params;
+}
+function splitPath(pathname) {
+  return pathname.split("/").filter(Boolean).map((p) => {
+    try {
+      return decodeURIComponent(p);
+    } catch {
+      return p;
+    }
+  });
+}
+async function readBody(req) {
+  if (typeof req[Symbol.asyncIterator] !== "function")
+    return "";
+  const chunks = [];
+  for await (const c of req)
+    chunks.push(typeof c === "string" ? Buffer.from(c) : c);
+  return Buffer.concat(chunks).toString("utf8");
+}
+var header = (req, name) => {
+  const want = name.toLowerCase();
+  for (const [k, v] of Object.entries(req.headers))
+    if (k.toLowerCase() === want && v !== void 0)
+      return Array.isArray(v) ? v.join(", ") : v;
+  return void 0;
+};
+function preferences(req) {
+  const out = {};
+  for (const part of (header(req, "prefer") ?? "").split(/[,;]/)) {
+    const eq = part.indexOf("=");
+    if (eq > 0)
+      out[part.slice(0, eq).trim().toLowerCase()] = part.slice(eq + 1).trim().replace(/^"|"$/g, "");
+  }
+  return out;
+}
+function send(res, status, body, headers) {
+  if (NO_BODY.has(status) || body === void 0) {
+    res.writeHead(status, headers);
+    res.end();
+    return;
+  }
+  const text = JSON.stringify(body);
+  res.writeHead(status, {
+    ...headers,
+    "content-length": String(Buffer.byteLength(text))
+  });
+  res.end(text);
+}
+function problem(res, status, body, headers = {}) {
+  send(res, status, { type: body.type, title: body.title, status, ...body }, {
+    "content-type": "application/problem+json",
+    ...headers
+  });
+}
+function check(route, pathParams, query, req, text) {
+  const errors = [];
+  for (const p of route.params) {
+    let value;
+    if (p.in === "path") {
+      const raw = pathParams[p.name];
+      if (raw === void 0)
+        continue;
+      value = coerce(raw, p.schema);
+    } else if (p.in === "query") {
+      const all = query.getAll(p.name);
+      if (all.length === 0) {
+        if (p.required)
+          errors.push({ in: "query", name: p.name, message: "is required" });
+        continue;
+      }
+      const t = p.schema?.type;
+      value = t === "array" || Array.isArray(t) && t.includes("array") ? all.flatMap((v) => v.split(",")).map((v) => coerce(v, p.schema?.items)) : coerce(all[0], p.schema);
+    } else {
+      if (IGNORED_HEADERS.has(p.name.toLowerCase()))
+        continue;
+      const raw = header(req, p.name);
+      if (raw === void 0) {
+        if (p.required)
+          errors.push({ in: "header", name: p.name, message: "is required" });
+        continue;
+      }
+      value = coerce(raw, p.schema);
+    }
+    for (const e of validate(value, p.schema))
+      errors.push({ in: p.in, name: p.name, message: e.message });
+  }
+  const b = route.body;
+  if (b) {
+    if (text.trim() === "") {
+      if (b.required)
+        errors.push({ in: "body", pointer: "", message: "is required" });
+    } else if (b.json) {
+      const type = header(req, "content-type");
+      if (type && !/json/i.test(type))
+        errors.push({ in: "body", pointer: "", message: "must be sent as application/json" });
+      else {
+        let value;
+        try {
+          value = JSON.parse(text);
+        } catch {
+          errors.push({ in: "body", pointer: "", message: "isn't valid JSON" });
+          return errors;
+        }
+        for (const e of validate(value, b.schema, "", "request"))
+          errors.push({ in: "body", pointer: e.pointer, message: e.message });
+      }
+    }
+  }
+  return errors;
+}
+function documented(route, code) {
+  return route.responses.find((r) => r.status === code) ?? route.responses.find((r) => r.status === `${code[0]}XX`) ?? route.responses.find((r) => r.status === "default");
+}
+function stubHandler(stub) {
+  const compiled = stub.routes.map(compile);
+  const operations = stub.routes.map((r) => `${r.method} ${r.path}`);
+  return async (req, res) => {
+    const method = (req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "/", "http://stub.invalid");
+    const pathname = url.pathname.replace(/(.)\/+$/, "$1");
+    const text = await readBody(req);
+    const candidates = [
+      pathname,
+      ...stub.basePaths.filter((b) => pathname === b || pathname.startsWith(`${b}/`)).map((b) => pathname.slice(b.length) || "/")
+    ];
+    let hits = [];
+    for (const p of candidates) {
+      const parts = splitPath(p);
+      hits = compiled.flatMap((c) => {
+        const params = matchPath(c, parts);
+        return params ? [{ c, params }] : [];
+      });
+      if (hits.length > 0)
+        break;
+    }
+    const specific = (a, b) => b.literalSegments - a.literalSegments || b.literalChars - a.literalChars;
+    hits.sort((a, b) => specific(a.c, b.c));
+    if (hits.length === 0)
+      return problem(res, 404, {
+        type: "urn:atticus:stub:no-route",
+        title: "No such operation",
+        detail: `The spec has no operation for ${method} ${url.pathname}.`,
+        instance: url.pathname,
+        operations
+      });
+    const hit = hits.find((h) => h.c.route.method === method);
+    if (!hit) {
+      const allow = [...new Set(hits.map((h) => h.c.route.method))].sort();
+      return problem(res, 405, {
+        type: "urn:atticus:stub:method-not-allowed",
+        title: "Method not allowed",
+        detail: `${hits[0].c.route.path} takes ${either(allow)}, not ${method}.`,
+        instance: url.pathname,
+        allow
+      }, { allow: allow.join(", ") });
+    }
+    const route = hit.c.route;
+    const name = `${route.method} ${route.path}`;
+    const errors = check(route, hit.params, url.searchParams, req, text);
+    if (errors.length > 0)
+      return problem(res, 400, {
+        type: "urn:atticus:stub:invalid-request",
+        title: "The request doesn't match the spec",
+        detail: `${errors.length} problem${errors.length === 1 ? "" : "s"} with ${name}.`,
+        instance: url.pathname,
+        errors
+      });
+    const prefs = preferences(req);
+    const asked = header(req, "x-stub-status")?.trim() ?? prefs.code;
+    let status = route.status;
+    let response = documented(route, String(route.status));
+    if (asked !== void 0) {
+      response = /^[1-5]\d\d$/.test(asked) ? documented(route, asked) : void 0;
+      if (!response)
+        return problem(res, 400, {
+          type: "urn:atticus:stub:unknown-scenario",
+          title: "No such response in the spec",
+          detail: `${name} documents ${route.responses.map((r) => r.status).join(", ")}, not ${asked}.`,
+          instance: url.pathname,
+          documented: route.responses.map((r) => r.status)
+        });
+      status = Number(asked);
+    }
+    const named = prefs.example !== void 0 ? response?.named[prefs.example] : void 0;
+    const body = named ?? response?.body ?? {};
+    const mediaType = response?.mediaType && /json/i.test(response.mediaType) ? response.mediaType : "application/json";
+    send(res, status, NO_BODY.has(status) ? void 0 : body, {
+      ...NO_BODY.has(status) ? {} : { "content-type": mediaType },
+      "x-stub-route": name
+    });
+  };
+}
+function checkStub(stub) {
+  return stub.routes.map((r) => ({
+    method: r.method,
+    path: r.path,
+    ...r.operationId ? { operationId: r.operationId } : {},
+    status: r.status,
+    example: r.example
+  }));
+}
+function stubFromCatalog(records, componentOrSystem) {
+  const id = componentOrSystem;
+  const components = records.filter((r) => r.kind === "Component");
+  const isComponent = components.some((c) => c.id === id);
+  const isSystem = records.some((r) => r.kind === "System" && r.id === id);
+  const endpoints = records.filter((r) => r.kind === "Endpoint");
+  const owners = /* @__PURE__ */ new Set([
+    id,
+    ...isComponent ? [] : components.filter((c) => c.system === id).map((c) => c.id)
+  ]);
+  if (!isComponent && !isSystem && !endpoints.some((e) => e.component === id))
+    throw new Error(`No component or system "${id}" in the catalog.`);
+  const mine = endpoints.filter((e) => owners.has(e.component) && e.endpointType === "rest" && e.status !== "retired").sort((a, b) => a.id < b.id ? -1 : 1);
+  const seen = /* @__PURE__ */ new Set();
+  const routes = [];
+  for (const e of mine) {
+    const method = (e.method ?? "GET").toUpperCase();
+    const key = `${method} ${e.pathOrTopic}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    routes.push({
+      method,
+      path: e.pathOrTopic,
+      operationId: e.id,
+      params: [...e.pathOrTopic.matchAll(/\{([^}]+)\}/g)].map((m) => ({
+        name: m[1],
+        in: "path",
+        required: true
+      })),
+      responses: [{ status: "200", body: {}, example: "catalog", named: {} }],
+      status: 200,
+      example: "catalog"
+    });
+  }
+  const ids = new Set(mine.map((e) => e.id));
+  const basepaths = new Map(records.filter((r) => r.kind === "GatewayRoute").map((r) => [r.id, r.basepath]));
+  const basePaths = /* @__PURE__ */ new Set();
+  for (const r of records)
+    if (r.kind === "Interface" && r.endpoint && ids.has(r.endpoint) && r.route) {
+      const b = basepaths.get(r.route)?.replace(/\/+$/, "");
+      if (b)
+        basePaths.add(b);
+    }
+  return {
+    title: `Catalog stub for ${id}`,
+    basePaths: [...basePaths].sort(),
+    routes: sortRoutes(routes),
+    warnings: []
+  };
+}
+async function startStub(handler, o) {
+  const host = o.host ?? "127.0.0.1";
+  const server = createServer((req, res) => {
+    handler(req, res).catch(() => {
+      if (!res.headersSent)
+        res.writeHead(500, { "content-type": "application/problem+json" });
+      res.end(JSON.stringify({ title: "The stub failed", status: 500 }));
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(o.port, host, () => resolve());
+  });
+  const port = server.address().port;
+  return {
+    url: `http://${host}:${port}`,
+    port,
+    close: () => new Promise((resolve) => server.close(() => resolve()))
+  };
+}
+
+export {
+  generate,
+  parseSpec,
+  buildStub,
+  stubHandler,
+  checkStub,
+  stubFromCatalog,
+  startStub
+};