@zahid15/mockline 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,3241 @@
+import { createServer } from 'http';
+import path, { resolve, dirname, extname } from 'path';
+import { watch } from 'chokidar';
+import { readFile, mkdir, appendFile, writeFile, rename } from 'fs/promises';
+import { existsSync } from 'fs';
+import { parse } from 'yaml';
+import { z } from 'zod';
+import { isIP } from 'net';
+import { setTimeout as setTimeout$1 } from 'timers/promises';
+import pc from 'picocolors';
+import SwaggerParser from '@apidevtools/swagger-parser';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import Ajv2020 from 'ajv/dist/2020.js';
+import { Faker, en } from '@faker-js/faker';
+import { lookup } from 'dns/promises';
+
+// src/server.ts
+var nonNegative = z.number().finite().min(0);
+var responseShape = z.object({
+  status: z.number().int().min(100).max(599).optional(),
+  body: z.unknown().optional(),
+  headers: z.record(z.string()).optional(),
+  delay: nonNegative.optional()
+});
+var conditionSchema = z.object({
+  location: z.enum(["query", "header", "body"]),
+  name: z.string().min(1),
+  op: z.enum(["eq", "contains", "regex"]).default("eq"),
+  value: z.unknown()
+});
+var overrideSchema = z.object({
+  status: z.number().int().min(100).max(599).optional(),
+  body: z.unknown().optional(),
+  headers: z.record(z.string()).optional(),
+  delay: nonNegative.optional(),
+  sequence: z.array(responseShape).min(1).optional(),
+  loop: z.boolean().default(false),
+  when: conditionSchema.optional(),
+  response: responseShape.optional(),
+  rules: z.array(z.object({ when: conditionSchema, response: responseShape })).optional()
+});
+var latencySchema = z.union([
+  nonNegative,
+  z.tuple([nonNegative, nonNegative]).refine(([min, max]) => min <= max, {
+    message: "range minimum must not exceed maximum"
+  }),
+  z.object({
+    fixed: nonNegative.optional(),
+    min: nonNegative.optional(),
+    max: nonNegative.optional(),
+    distribution: z.enum(["uniform", "normal"]).default("uniform")
+  }).refine(
+    (value) => value.fixed !== void 0 || value.min !== void 0 && value.max !== void 0,
+    {
+      message: "provide fixed or both min and max"
+    }
+  ).refine(
+    (value) => value.min === void 0 || value.max === void 0 || value.min <= value.max,
+    {
+      message: "range minimum must not exceed maximum",
+      path: ["min"]
+    }
+  )
+]);
+var configSchema = z.object({
+  port: z.number().int().min(0).max(65535).default(4010),
+  host: z.string().min(1).default("127.0.0.1"),
+  seed: z.number().int().optional(),
+  prefer: z.enum(["example", "generate"]).default("example"),
+  latency: latencySchema.default(0),
+  errors: z.object({
+    rate: z.number().min(0).max(1).default(0),
+    statuses: z.array(z.number().int().min(400).max(599)).min(1).default([500, 503]),
+    perOperationRates: z.record(z.number().min(0).max(1)).default({})
+  }).default({}),
+  validate: z.enum(["off", "warn", "strict"]).default("warn"),
+  stateful: z.object({
+    enabled: z.boolean().default(false),
+    seedItems: z.number().int().min(0).default(3),
+    idProperty: z.string().min(1).default("id")
+  }).default({}),
+  overrides: z.record(overrideSchema).default({}),
+  proxy: z.object({
+    url: z.string().url().refine((value) => /^https?:\/\//i.test(value), {
+      message: "must use http or https"
+    }).optional(),
+    all: z.boolean().default(false),
+    allowPrivate: z.boolean().default(false),
+    timeoutMs: z.number().int().positive().default(5e3),
+    recordFile: z.string().optional()
+  }).refine((value) => !value.all || Boolean(value.url), {
+    message: "proxy.url is required when proxy.all is true",
+    path: ["url"]
+  }).default({}),
+  cors: z.object({
+    enabled: z.boolean().default(true),
+    origins: z.array(z.string()).default(["*"])
+  }).default({}),
+  recording: z.object({
+    enabled: z.boolean().default(true),
+    file: z.string().optional(),
+    maxRequests: z.number().int().positive().default(500),
+    redactHeaders: z.array(z.string()).default(["authorization", "cookie", "set-cookie", "x-api-key", "api-key", "x-auth-token"])
+  }).default({}),
+  generation: z.object({
+    hints: z.union([
+      z.boolean(),
+      z.record(
+        z.union([
+          z.string(),
+          z.number(),
+          z.boolean(),
+          z.null(),
+          z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))
+        ])
+      )
+    ]).default(true),
+    counter: z.boolean().default(false),
+    maxDepth: z.number().int().min(0).max(20).default(3),
+    minArrayItems: z.number().int().min(0).default(1),
+    maxArrayItems: z.number().int().min(0).default(3)
+  }).refine((value) => value.minArrayItems <= value.maxArrayItems, {
+    message: "minArrayItems must not exceed maxArrayItems",
+    path: ["minArrayItems"]
+  }).default({}),
+  controlHeaders: z.object({ allow: z.boolean().default(true) }).default({}),
+  inspector: z.object({ enabled: z.boolean().optional() }).default({}),
+  enforceAuth: z.boolean().default(false),
+  requestBodyLimit: z.number().int().positive().default(1048576),
+  requestTimeoutMs: z.number().int().positive().default(3e4)
+});
+var defaultConfig = configSchema.parse({});
+
+// src/errors.ts
+var MocklineError = class extends Error {
+  exitCode;
+  details;
+  constructor(message, exitCode = 3, details) {
+    super(message);
+    this.name = "MocklineError";
+    this.exitCode = exitCode;
+    this.details = details;
+  }
+};
+function problem(status, title, detail, extra = {}) {
+  return {
+    type: "about:blank",
+    title,
+    status,
+    ...detail ? { detail } : {},
+    ...extra
+  };
+}
+
+// src/config/load.ts
+function formatConfigErrors(error) {
+  return error.issues.map((issue) => {
+    const path2 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${path2}: ${issue.message}`;
+  }).join("\n");
+}
+async function parseConfigText(text, fileName = "mockline.yaml") {
+  let raw;
+  try {
+    raw = extname(fileName).toLowerCase() === ".json" ? JSON.parse(text) : parse(text);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new MocklineError(`Invalid config ${fileName}: ${reason}`, 1);
+  }
+  const parsed = configSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new MocklineError(
+      `Invalid config ${fileName}:
+${formatConfigErrors(parsed.error)}`,
+      1,
+      parsed.error
+    );
+  }
+  return parsed.data;
+}
+async function loadConfig(file) {
+  const candidates = file ? [resolve(file)] : [resolve("mockline.yaml"), resolve("mockline.yml"), resolve("mockline.json")];
+  const selected = candidates.find((candidate) => existsSync(candidate));
+  if (!selected) {
+    if (file) throw new MocklineError(`Config file not found: ${file}`, 1);
+    return { config: configSchema.parse({}) };
+  }
+  let text;
+  try {
+    text = await readFile(selected, "utf8");
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new MocklineError(`Cannot read config ${selected}: ${reason}`, 1);
+  }
+  return { config: await parseConfigText(text, selected), path: selected };
+}
+function createLogger(options = {}) {
+  const quiet = options.quiet ?? false;
+  const verbose = options.verbose ?? false;
+  const color = options.color ?? process.stdout.isTTY;
+  const paint = (fn, value) => color ? fn(value) : value;
+  return {
+    info(message) {
+      if (!quiet) console.log(paint(pc.cyan, "mockline"), message);
+    },
+    warn(message) {
+      if (!quiet) console.warn(paint(pc.yellow, "warning"), message);
+    },
+    error(message) {
+      console.error(paint(pc.red, "error"), message);
+    },
+    debug(message) {
+      if (verbose && !quiet) console.log(paint(pc.dim, "debug"), message);
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function operationEntries(document) {
+  const entries = [];
+  const paths = document.paths ?? {};
+  const methods = /* @__PURE__ */ new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
+  for (const [routePath, pathItemUnknown] of Object.entries(paths)) {
+    if (!isRecord(pathItemUnknown)) continue;
+    for (const [method, operation] of Object.entries(pathItemUnknown)) {
+      if (methods.has(method.toLowerCase()) && isRecord(operation)) {
+        entries.push({ path: routePath, method: method.toUpperCase(), operation });
+      }
+    }
+  }
+  return entries;
+}
+function getResponseDetails(operation) {
+  const responses = isRecord(operation.responses) ? operation.responses : {};
+  let hasExample2 = false;
+  let hasSchema = false;
+  for (const responseUnknown of Object.values(responses)) {
+    if (!isRecord(responseUnknown) || !isRecord(responseUnknown.content)) continue;
+    for (const mediaUnknown of Object.values(responseUnknown.content)) {
+      if (!isRecord(mediaUnknown)) continue;
+      if ("example" in mediaUnknown || isRecord(mediaUnknown.examples) && Object.keys(mediaUnknown.examples).length > 0) {
+        hasExample2 = true;
+      }
+      if (isRecord(mediaUnknown.schema)) hasSchema = true;
+    }
+  }
+  return { hasExample: hasExample2, hasSchema };
+}
+function inspectSpec(document) {
+  const warnings = [];
+  for (const entry of operationEntries(document)) {
+    const { hasExample: hasExample2, hasSchema } = getResponseDetails(entry.operation);
+    const responses = isRecord(entry.operation.responses) ? entry.operation.responses : {};
+    for (const response of Object.values(responses)) {
+      if (!isRecord(response) || !isRecord(response.content)) continue;
+      for (const [mediaType, media] of Object.entries(response.content)) {
+        if (!isRecord(media)) continue;
+        const json2 = mediaType.toLowerCase().includes("json");
+        const schema = isRecord(media.schema) ? media.schema : void 0;
+        const hasMediaExample = "example" in media || isRecord(media.examples) && Object.keys(media.examples).length > 0 || Boolean(
+          schema && ("example" in schema || Array.isArray(schema.examples) && schema.examples.length > 0)
+        );
+        if (!json2 && !hasMediaExample)
+          warnings.push({
+            message: `Mockline cannot generate ${mediaType} responses; add an example.`,
+            path: entry.path
+          });
+      }
+    }
+    if (!hasExample2 && !hasSchema) {
+      warnings.push({
+        message: "No response schema or example; Mockline can only return an empty/default body.",
+        operationId: typeof entry.operation.operationId === "string" ? entry.operation.operationId : void 0,
+        path: entry.path
+      });
+    }
+    if (entry.operation.callbacks)
+      warnings.push({ message: "Callbacks are not supported.", path: entry.path });
+    if (entry.operation.links)
+      warnings.push({
+        message: "Response links are ignored by the mock server.",
+        path: entry.path
+      });
+  }
+  if (document.webhooks && isRecord(document.webhooks) && Object.keys(document.webhooks).length > 0) {
+    warnings.push({ message: "Webhooks are not served by Mockline." });
+  }
+  return warnings;
+}
+async function loadSpec(file) {
+  const absoluteFile = path.resolve(file);
+  let text;
+  try {
+    text = await readFile(absoluteFile, "utf8");
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new MocklineError(`Cannot read OpenAPI spec ${file}: ${reason}`, 1);
+  }
+  let parsed;
+  try {
+    parsed = /\.json$/i.test(absoluteFile) ? JSON.parse(text) : parse(text);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new MocklineError(`Cannot parse OpenAPI spec ${file}: ${reason}`, 1);
+  }
+  if (!isRecord(parsed))
+    throw new MocklineError("OpenAPI document must be a YAML or JSON object.", 1);
+  if (parsed.swagger === "2.0" || "swagger" in parsed) {
+    throw new MocklineError(
+      "Swagger 2.0 is not supported. Convert the document to OpenAPI 3.x (for example, with swagger2openapi) and try again.",
+      1
+    );
+  }
+  if (typeof parsed.openapi !== "string" || !parsed.openapi.startsWith("3.")) {
+    throw new MocklineError("Only OpenAPI 3.0 and 3.1 documents are supported.", 1);
+  }
+  let dereferenced;
+  try {
+    const parser = new SwaggerParser();
+    dereferenced = await parser.validate(absoluteFile, {
+      dereference: { circular: "ignore" }
+    });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new MocklineError(`Invalid OpenAPI spec ${file}: ${reason}`, 1, error);
+  }
+  const document = dereferenced;
+  const warnings = inspectSpec(document);
+  return { file: absoluteFile, document, dereferenced, warnings };
+}
+
+// src/router.ts
+var HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizePath(value) {
+  if (value === "" || value === "/") return "/";
+  const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
+  const trimmed = withLeadingSlash.replace(/\/+$/, "");
+  return trimmed || "/";
+}
+function replaceServerVariables(url, variables) {
+  return url.replace(
+    /\{([^}]+)\}/g,
+    (_match, name) => encodeURIComponent(variables?.[name]?.default ?? "")
+  );
+}
+function serverPath(url, variables) {
+  const replaced = replaceServerVariables(url, variables);
+  try {
+    return normalizePath(new URL(replaced, "http://mockline.local").pathname);
+  } catch {
+    return "/";
+  }
+}
+function routeForPath(base, pathTemplate) {
+  const cleanBase = base === "/" ? "" : normalizePath(base);
+  const cleanPath = normalizePath(pathTemplate);
+  return normalizePath(`${cleanBase}${cleanPath === "/" ? "" : cleanPath}`);
+}
+function compilePath(template) {
+  const normalized = normalizePath(template);
+  const parts = normalized.split("/").filter(Boolean);
+  const names = [];
+  let staticSegments = 0;
+  const pattern = parts.map((part) => {
+    const match = /^\{([^{}]+)\}$/.exec(part);
+    if (match) {
+      names.push(match[1] ?? "");
+      return "([^/]+)";
+    }
+    staticSegments += 1;
+    return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }).join("/");
+  const regex = new RegExp(`^/${pattern}${parts.length === 0 ? "" : ""}/?$`);
+  return {
+    regex,
+    parameterNames: names,
+    staticSegments,
+    score: staticSegments * 100 + parts.length
+  };
+}
+function toMatchedRoute(route) {
+  return {
+    method: route.method,
+    path: route.path,
+    routePath: route.routePath,
+    operationId: route.operationId,
+    operation: route.operation,
+    pathItem: route.pathItem,
+    parameters: route.parameters,
+    score: route.score
+  };
+}
+function operationId(operation, method, path2) {
+  return typeof operation.operationId === "string" && operation.operationId.length > 0 ? operation.operationId : `${method.toLowerCase()}_${path2.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_|_$/g, "") || "root"}`;
+}
+function combineParameters(pathItem, operation) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const parameter of [...pathItem.parameters ?? [], ...operation.parameters ?? []]) {
+    if (parameter && typeof parameter.name === "string" && typeof parameter.in === "string") {
+      merged.set(
+        `${parameter.in}:${parameter.in === "header" ? parameter.name.toLowerCase() : parameter.name}`,
+        parameter
+      );
+    }
+  }
+  return [...merged.values()];
+}
+function createRouter(document) {
+  const routes = [];
+  const paths = document.paths ?? {};
+  for (const [pathTemplate, pathItemUnknown] of Object.entries(paths)) {
+    if (!isRecord2(pathItemUnknown)) continue;
+    const pathItem = pathItemUnknown;
+    for (const method of HTTP_METHODS) {
+      const operationUnknown = pathItemUnknown[method];
+      if (!isRecord2(operationUnknown)) continue;
+      const operation = operationUnknown;
+      const operationServers = Array.isArray(operation.servers) ? operation.servers : void 0;
+      const pathServers = Array.isArray(pathItem.servers) ? pathItem.servers : void 0;
+      const servers = operationServers ?? pathServers ?? document.servers ?? [];
+      const bases = servers.length > 0 ? servers.map((server) => serverPath(server.url, server.variables)) : ["/"];
+      for (const base of bases) {
+        const routePath = routeForPath(base, pathTemplate);
+        const compiled = compilePath(routePath);
+        routes.push({
+          method: method.toUpperCase(),
+          path: routePath,
+          routePath,
+          operationId: operationId(operation, method, routePath),
+          operation,
+          pathItem,
+          parameters: combineParameters(pathItem, operation),
+          score: compiled.score,
+          regex: compiled.regex,
+          parameterNames: compiled.parameterNames,
+          staticSegments: compiled.staticSegments
+        });
+      }
+    }
+  }
+  routes.sort(
+    (a, b) => b.staticSegments - a.staticSegments || b.score - a.score || a.path.localeCompare(b.path)
+  );
+  const publicRoutes = routes.map(toMatchedRoute);
+  const matchesPath = (route, pathname) => {
+    const normalized = normalizePath(pathname);
+    const match = route.regex.exec(normalized);
+    if (!match) return void 0;
+    const values = {};
+    for (const [index, name] of route.parameterNames.entries()) {
+      const encoded = match[index + 1];
+      if (encoded === void 0) continue;
+      try {
+        values[name] = decodeURIComponent(encoded);
+      } catch {
+        return void 0;
+      }
+    }
+    return values;
+  };
+  return {
+    routes: publicRoutes,
+    match(method, pathname) {
+      const upper = method.toUpperCase();
+      for (const route of routes) {
+        if (route.method !== upper) continue;
+        const params = matchesPath(route, pathname);
+        if (params) {
+          return { route: toMatchedRoute(route), params };
+        }
+      }
+      return void 0;
+    },
+    methodsForPath(pathname) {
+      const methods = /* @__PURE__ */ new Set();
+      for (const route of routes) if (matchesPath(route, pathname)) methods.add(route.method);
+      return [...methods].sort();
+    },
+    nearestPath(pathname) {
+      const normalized = normalizePath(pathname);
+      let best;
+      for (const route of routes) {
+        const routeParts = route.path.split("/").filter(Boolean);
+        const actualParts = normalized.split("/").filter(Boolean);
+        let common = 0;
+        for (let i = 0; i < Math.min(routeParts.length, actualParts.length); i += 1) {
+          if (routeParts[i] === actualParts[i] || /^\{[^{}]+\}$/.test(routeParts[i] ?? ""))
+            common += 1;
+          else break;
+        }
+        const distance = common * 10 - Math.abs(routeParts.length - actualParts.length);
+        if (!best || distance > best.distance) best = { route, distance };
+      }
+      return best?.route.path;
+    }
+  };
+}
+
+// src/generate/rng.ts
+function hashSeed(input) {
+  const text = String(input);
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function deriveSeed(seed, ...parts) {
+  return hashSeed(`${seed ?? 0}|${parts.join("|")}`);
+}
+var SeededRandom = class {
+  state;
+  constructor(seed) {
+    this.state = seed >>> 0 || 1831565813;
+  }
+  next() {
+    this.state = this.state + 1831565813 | 0;
+    let value = this.state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  }
+  int(min, max) {
+    const low = Math.ceil(min);
+    const high = Math.floor(max);
+    if (high <= low) return low;
+    return low + Math.floor(this.next() * (high - low + 1));
+  }
+  float(min, max) {
+    if (max <= min) return min;
+    return min + this.next() * (max - min);
+  }
+  bool(probability = 0.5) {
+    return this.next() < probability;
+  }
+  pick(items) {
+    if (items.length === 0) return void 0;
+    return items[this.int(0, items.length - 1)];
+  }
+};
+var ROOT_ID = "https://mockline.local/openapi.json";
+function cloneSchema(value, rootId, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Array.isArray(value)) return value.map((item) => cloneSchema(item, rootId, seen));
+  if (typeof value !== "object" || value === null) return value;
+  const prior = seen.get(value);
+  if (prior) return prior;
+  const output = {};
+  seen.set(value, output);
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "$ref" && typeof child === "string" && child.startsWith("#/")) {
+      output[key] = `${rootId}${child}`;
+    } else if ((key === "exclusiveMinimum" || key === "exclusiveMaximum") && child === false) {
+      continue;
+    } else if (key === "exclusiveMinimum" && child === true) {
+      const parent = value;
+      if (typeof parent.minimum === "number") output.minimum = void 0;
+      output[key] = typeof parent.minimum === "number" ? parent.minimum : child;
+    } else if (key === "exclusiveMaximum" && child === true) {
+      const parent = value;
+      if (typeof parent.maximum === "number") output.maximum = void 0;
+      output[key] = typeof parent.maximum === "number" ? parent.maximum : child;
+    } else {
+      output[key] = cloneSchema(child, rootId, seen);
+    }
+  }
+  if (output.minimum === void 0) delete output.minimum;
+  if (output.maximum === void 0) delete output.maximum;
+  return output;
+}
+function createValidator(root, schema) {
+  const Validator = root.openapi?.startsWith("3.1") ? Ajv2020 : Ajv;
+  const ajv = new Validator({
+    allErrors: true,
+    strict: false,
+    allowUnionTypes: true,
+    validateFormats: true
+  });
+  addFormats(ajv);
+  try {
+    ajv.addSchema(cloneSchema(root, ROOT_ID), ROOT_ID);
+  } catch {
+  }
+  const normalized = cloneSchema(schema, ROOT_ID);
+  return ajv.compile(normalized);
+}
+function validateSchema(root, schema, value) {
+  try {
+    const validator = createValidator(root, schema);
+    const valid = validator(value) === true;
+    return { valid, errors: validator.errors ?? [] };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        {
+          keyword: "schema",
+          instancePath: "",
+          schemaPath: "",
+          params: {},
+          message: error instanceof Error ? error.message : "Unable to compile schema"
+        }
+      ]
+    };
+  }
+}
+function createFaker(seed) {
+  const faker = new Faker({ locale: [en] });
+  faker.seed(seed);
+  faker.setDefaultRefDate("2020-01-01T00:00:00.000Z");
+  return faker;
+}
+function hintedValue(name, type, faker, rng) {
+  const normalized = name.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().replace(/[^a-z0-9]/g, "");
+  if (type === "string") {
+    if (normalized === "email" || normalized.endsWith("email"))
+      return faker.internet.email().toLowerCase();
+    if (normalized === "firstname" || normalized === "givenname") return faker.person.firstName();
+    if (normalized === "lastname" || normalized === "familyname" || normalized === "surname")
+      return faker.person.lastName();
+    if (normalized === "fullname" || normalized === "name" || normalized === "username")
+      return normalized === "username" ? faker.internet.username() : faker.person.fullName();
+    if (normalized === "phone" || normalized === "phonenumber" || normalized.endsWith("phone"))
+      return faker.phone.number();
+    if (normalized === "createdat" || normalized === "updatedat" || normalized === "timestamp")
+      return faker.date.recent({ days: 10 }).toISOString();
+    if (normalized === "avatarurl" || normalized === "imageurl" || normalized === "photo")
+      return faker.image.urlLoremFlickr({ category: "portrait" });
+    if (normalized === "country") return faker.location.country();
+    if (normalized === "city") return faker.location.city();
+    if (normalized === "url" || normalized.endsWith("url")) return faker.internet.url();
+    if (normalized === "status") return rng.pick(["active", "pending", "inactive"]);
+  }
+  if (type === "number" || type === "integer") {
+    if (normalized === "price" || normalized.endsWith("price") || normalized === "amount")
+      return Number(faker.commerce.price({ min: 1, max: 999, dec: 2 }));
+    if (normalized === "age") return faker.number.int({ min: 18, max: 80 });
+  }
+  if (type === "boolean" && (normalized === "active" || normalized === "enabled" || normalized === "verified")) {
+    return rng.bool();
+  }
+  return void 0;
+}
+
+// src/generate/schema.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function numberValue(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function stringValue(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function getPointer(root, pointer) {
+  if (!pointer.startsWith("#/")) return void 0;
+  return pointer.slice(2).split("/").reduce((current, part) => {
+    const key = part.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (Array.isArray(current)) return current[Number(key)];
+    if (isRecord3(current)) return current[key];
+    return void 0;
+  }, root);
+}
+function resolveSchema(schema, context) {
+  if (typeof schema.$ref !== "string") return schema;
+  const target = getPointer(context.root, schema.$ref);
+  if (!isRecord3(target)) {
+    context.warnings.push({
+      message: `Could not resolve schema reference ${schema.$ref}; using an empty value.`
+    });
+    return {};
+  }
+  return target;
+}
+function mergeSchema(left, right) {
+  const merged = { ...left, ...right };
+  const leftProperties = isRecord3(left.properties) ? left.properties : {};
+  const rightProperties = isRecord3(right.properties) ? right.properties : {};
+  if (Object.keys(leftProperties).length > 0 || Object.keys(rightProperties).length > 0) {
+    merged.properties = { ...leftProperties, ...rightProperties };
+  }
+  const required = [
+    .../* @__PURE__ */ new Set([
+      ...Array.isArray(left.required) ? left.required : [],
+      ...Array.isArray(right.required) ? right.required : []
+    ])
+  ];
+  if (required.length > 0) merged.required = required;
+  for (const key of ["minimum", "exclusiveMinimum"]) {
+    const a = left[key];
+    const b = right[key];
+    if (typeof a === "number" && typeof b === "number") merged[key] = Math.max(a, b);
+  }
+  for (const key of ["maximum", "exclusiveMaximum"]) {
+    const a = left[key];
+    const b = right[key];
+    if (typeof a === "number" && typeof b === "number") merged[key] = Math.min(a, b);
+  }
+  if (Array.isArray(left.enum) && Array.isArray(right.enum)) {
+    merged.enum = left.enum.filter(
+      (value) => right.enum?.some((other) => JSON.stringify(other) === JSON.stringify(value))
+    );
+  }
+  return merged;
+}
+function schemaType(schema, rng) {
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    const alternatives = type.filter(
+      (candidate) => typeof candidate === "string"
+    );
+    return rng.pick(alternatives) ?? "object";
+  }
+  if (typeof type === "string") return type;
+  if (schema.properties || schema.additionalProperties) return "object";
+  if (schema.items) return "array";
+  return "string";
+}
+function isUnconstrained(schema) {
+  return ![
+    "enum",
+    "const",
+    "default",
+    "format",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minLength",
+    "maxLength"
+  ].some((key) => key in schema);
+}
+function expandCharacterClass(value) {
+  let index = 0;
+  const chars = [];
+  while (index < value.length) {
+    const first = value[index] ?? "";
+    if (first === "\\") {
+      const escaped = value[index + 1];
+      if (escaped === "d") chars.push(..."0123456789");
+      else if (escaped === "w")
+        chars.push(..."abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");
+      else if (escaped === "s") chars.push(" ");
+      else if (escaped) chars.push(escaped);
+      index += 2;
+      continue;
+    }
+    const rangeEnd = value[index + 1] === "-" ? value[index + 2] : void 0;
+    if (rangeEnd !== void 0) {
+      const from = first.codePointAt(0) ?? 0;
+      const to = rangeEnd.codePointAt(0) ?? 0;
+      if (to < from || to - from > 200) return void 0;
+      for (let code = from; code <= to; code += 1) chars.push(String.fromCodePoint(code));
+      index += 3;
+      continue;
+    }
+    chars.push(first);
+    index += 1;
+  }
+  return chars.length > 0 ? chars : void 0;
+}
+function generateSimplePattern(pattern, rng) {
+  const source = pattern.replace(/^\^/, "").replace(/\$$/, "");
+  if (source.includes("|") || source.includes("(?") || source.includes(")")) return void 0;
+  let output = "";
+  for (let index = 0; index < source.length; ) {
+    let choices;
+    const char = source[index] ?? "";
+    if (char === "[") {
+      const end = source.indexOf("]", index + 1);
+      if (end < 0 || source[index + 1] === "^") return void 0;
+      choices = expandCharacterClass(source.slice(index + 1, end)) ?? [];
+      if (choices.length === 0) return void 0;
+      index = end + 1;
+    } else if (char === "\\") {
+      const next = source[index + 1];
+      if (next === "d") choices = [..."0123456789"];
+      else if (next === "w")
+        choices = [..."abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"];
+      else if (next === "s") choices = [" "];
+      else if (next) choices = [next];
+      else return void 0;
+      index += 2;
+    } else if (char === ".") {
+      choices = ["a", "b", "x", "7"];
+      index += 1;
+    } else if ("*+?{}[]()".includes(char)) {
+      return void 0;
+    } else {
+      choices = [char];
+      index += 1;
+    }
+    let minimum = 1;
+    let maximum = 1;
+    if (source[index] === "{") {
+      const match = /^\{(\d+)(?:,(\d*))?\}/.exec(source.slice(index));
+      if (!match) return void 0;
+      minimum = Number(match[1]);
+      maximum = match[2] === void 0 ? minimum : match[2] === "" ? minimum + 3 : Number(match[2]);
+      if (maximum < minimum || maximum > 100) return void 0;
+      index += match[0].length;
+    } else if (source[index] === "+") {
+      minimum = 1;
+      maximum = 3;
+      index += 1;
+    } else if (source[index] === "*") {
+      minimum = 0;
+      maximum = 3;
+      index += 1;
+    } else if (source[index] === "?") {
+      minimum = 0;
+      maximum = 1;
+      index += 1;
+    }
+    const count = rng.int(minimum, maximum);
+    for (let repeat = 0; repeat < count; repeat += 1) output += rng.pick(choices) ?? "x";
+  }
+  try {
+    return new RegExp(pattern).test(output) ? output : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function formatString(format, faker) {
+  if (format === "email") return faker.internet.email().toLowerCase();
+  if (format === "uuid") return faker.string.uuid();
+  if (format === "date") return faker.date.anytime().toISOString().slice(0, 10);
+  if (format === "date-time") return faker.date.anytime().toISOString();
+  if (format === "uri" || format === "url") return faker.internet.url();
+  if (format === "hostname") return faker.internet.domainName();
+  if (format === "ipv4") return faker.internet.ipv4();
+  if (format === "ipv6") return faker.internet.ipv6();
+  return void 0;
+}
+function fallbackPatternValue(pattern, context) {
+  try {
+    const expression = new RegExp(pattern);
+    const candidates = [
+      "a",
+      "x",
+      "0",
+      "test",
+      "foo",
+      "abc",
+      "ab",
+      "cd",
+      "abc123",
+      "2020-01-01",
+      context.faker.lorem.word()
+    ];
+    return candidates.find((candidate) => expression.test(candidate));
+  } catch {
+    return void 0;
+  }
+}
+function constrainedString(schema, context, propertyName) {
+  const pattern = stringValue(schema.pattern);
+  if (pattern) {
+    const matching = generateSimplePattern(pattern, context.rng);
+    if (matching !== void 0) return matching;
+    context.warnings.push({
+      message: `Pattern ${JSON.stringify(pattern)} is too complex for the built-in generator; a fallback value was used.`
+    });
+    const fallback = fallbackPatternValue(pattern, context);
+    if (fallback !== void 0) return fallback;
+  }
+  const format = stringValue(schema.format);
+  let candidate = formatString(format, context.faker);
+  const isUnconstrainedSchema = isUnconstrained(schema);
+  const hintOption = context.hints;
+  if (candidate === void 0 && isUnconstrainedSchema && hintOption !== false) {
+    if (isRecord3(hintOption)) {
+      const custom = hintOption[propertyName];
+      if (Array.isArray(custom)) candidate = String(context.rng.pick(custom) ?? "");
+      else if (custom !== void 0) candidate = String(custom);
+    }
+    candidate ??= hintedValue(propertyName, "string", context.faker, context.rng);
+  }
+  candidate ??= context.faker.lorem.word();
+  const minimum = Math.max(0, Math.floor(numberValue(schema.minLength, 0)));
+  const maximum = Math.max(
+    minimum,
+    Math.floor(numberValue(schema.maxLength, Math.max(80, candidate.length)))
+  );
+  if (candidate.length < minimum) candidate = candidate.padEnd(minimum, "x");
+  if (candidate.length > maximum) candidate = candidate.slice(0, maximum);
+  return candidate;
+}
+function generateNumber(schema, context, type, propertyName) {
+  if (context.hints !== false && isUnconstrained(schema)) {
+    const hintOption = context.hints;
+    const custom = isRecord3(hintOption) ? hintOption[propertyName] : void 0;
+    const hinted = custom !== void 0 ? Number(Array.isArray(custom) ? context.rng.pick(custom) : custom) : hintedValue(propertyName, type, context.faker, context.rng);
+    if (typeof hinted === "number" && Number.isFinite(hinted))
+      return type === "integer" ? Math.round(hinted) : hinted;
+  }
+  const minimumValue = schema.minimum;
+  const maximumValue = schema.maximum;
+  let minimum = typeof minimumValue === "number" ? minimumValue : Math.min(-100, numberValue(maximumValue, 100) - 200);
+  let maximum = typeof maximumValue === "number" ? maximumValue : Math.max(100, minimum + 200);
+  if (schema.exclusiveMinimum === true && typeof minimumValue === "number")
+    minimum += type === "integer" ? 1 : 1e-6;
+  else if (typeof schema.exclusiveMinimum === "number")
+    minimum = Math.max(
+      minimum,
+      schema.exclusiveMinimum + (type === "integer" ? 1 : Number.EPSILON)
+    );
+  if (schema.exclusiveMaximum === true && typeof maximumValue === "number")
+    maximum -= type === "integer" ? 1 : 1e-6;
+  else if (typeof schema.exclusiveMaximum === "number")
+    maximum = Math.min(
+      maximum,
+      schema.exclusiveMaximum - (type === "integer" ? 1 : Number.EPSILON)
+    );
+  if (minimum > maximum) minimum = maximum;
+  const multipleOf = numberValue(schema.multipleOf, 0);
+  if (type === "integer") {
+    const low = Math.ceil(minimum);
+    const high = Math.floor(maximum);
+    if (multipleOf > 0) {
+      const first = Math.ceil(low / multipleOf) * multipleOf;
+      const last = Math.floor(high / multipleOf) * multipleOf;
+      if (first <= last)
+        return Math.round(context.rng.int(first / multipleOf, last / multipleOf) * multipleOf);
+      return Math.round(first);
+    }
+    return context.rng.int(low, high);
+  }
+  let number = context.rng.float(minimum, maximum);
+  if (multipleOf > 0) number = Math.round(number / multipleOf) * multipleOf;
+  number = Math.min(maximum, Math.max(minimum, number));
+  return Number(number.toPrecision(8));
+}
+function generateArray(schema, context, depth, propertyName) {
+  const minimum = Math.max(0, Math.floor(numberValue(schema.minItems, context.minArrayItems)));
+  const maximum = Math.max(
+    minimum,
+    Math.floor(numberValue(schema.maxItems, context.maxArrayItems))
+  );
+  const count = context.rng.int(minimum, maximum);
+  const itemSchema = isRecord3(schema.items) ? schema.items : {};
+  const values = [];
+  const unique = schema.uniqueItems === true;
+  let attempts = 0;
+  while (values.length < count && attempts < Math.max(count * 10, 10)) {
+    attempts += 1;
+    const value = generateNode(itemSchema, context, depth + 1, `${propertyName}Item`);
+    if (!unique || !values.some((existing) => JSON.stringify(existing) === JSON.stringify(value)))
+      values.push(value);
+  }
+  return values;
+}
+function generateObject(schema, context, depth) {
+  const properties = isRecord3(schema.properties) ? schema.properties : {};
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.filter((v) => typeof v === "string") : []
+  );
+  const result = {};
+  for (const [name, childSchema] of Object.entries(properties)) {
+    if (context.mode === "response" && childSchema.writeOnly === true) continue;
+    if (context.mode === "request" && childSchema.readOnly === true) continue;
+    const isRequired = required.has(name);
+    if (!isRequired && depth >= context.maxDepth) continue;
+    if (!isRequired && !context.rng.bool(0.72)) continue;
+    result[name] = generateNode(childSchema, context, depth + 1, name);
+  }
+  if (schema.additionalProperties && isRecord3(schema.additionalProperties)) {
+    const extensionName = properties.extension ? "extra" : "extension";
+    result[extensionName] = generateNode(
+      schema.additionalProperties,
+      context,
+      depth + 1,
+      extensionName
+    );
+  }
+  return result;
+}
+function discriminatorValue(schema, branch, context) {
+  const discriminator = isRecord3(schema.discriminator) ? schema.discriminator : void 0;
+  const propertyName = typeof discriminator?.propertyName === "string" ? discriminator.propertyName : void 0;
+  if (!propertyName) return void 0;
+  const mapping = isRecord3(discriminator?.mapping) ? discriminator.mapping : void 0;
+  if (mapping) {
+    const match = Object.entries(mapping).find(
+      ([, ref]) => typeof ref === "string" && ref === branch.$ref
+    );
+    if (match) return { name: propertyName, value: match[0] };
+  }
+  const resolved = resolveSchema(branch, context);
+  const properties = isRecord3(resolved.properties) ? resolved.properties : {};
+  const propertySchema = isRecord3(properties[propertyName]) ? properties[propertyName] : void 0;
+  if (propertySchema && "const" in propertySchema)
+    return { name: propertyName, value: propertySchema.const };
+  if (Array.isArray(propertySchema?.enum))
+    return { name: propertyName, value: propertySchema.enum[0] };
+  if (typeof branch.$ref === "string")
+    return { name: propertyName, value: branch.$ref.split("/").pop() ?? "variant" };
+  return void 0;
+}
+function chooseCompositionBranch(schema, context) {
+  const branches = Array.isArray(schema.oneOf) ? schema.oneOf : Array.isArray(schema.anyOf) ? schema.anyOf : void 0;
+  if (!branches || branches.length === 0) return void 0;
+  const usable = branches.filter(isRecord3);
+  if (usable.length === 0) return void 0;
+  const discriminator = isRecord3(schema.discriminator) ? schema.discriminator : void 0;
+  if (typeof discriminator?.propertyName === "string" && isRecord3(discriminator.mapping)) {
+    const mappedRefs = Object.values(discriminator.mapping).filter(
+      (value) => typeof value === "string"
+    );
+    const selectedRef = context.rng.pick(mappedRefs);
+    const found = usable.find((branch) => branch.$ref === selectedRef);
+    if (found) return found;
+  }
+  return context.rng.pick(usable);
+}
+function generateNode(rawSchema, context, depth, propertyName) {
+  if (depth > context.maxDepth + 8) {
+    throw new Error("Recursive schema has no finite value within the generation depth limit.");
+  }
+  let schema = resolveSchema(rawSchema, context);
+  if (rawSchema.$ref && context.refTrail.has(rawSchema.$ref)) {
+    if (depth >= context.maxDepth) {
+      const resolved = resolveSchema(rawSchema, context);
+      if (resolved.nullable === true || Array.isArray(resolved.type) && resolved.type.includes("null"))
+        return null;
+      if (resolved.default !== void 0) return resolved.default;
+      if (resolved.const !== void 0) return resolved.const;
+      const type = schemaType(resolved, context.rng);
+      if (type === "array")
+        return numberValue(resolved.minItems, 0) === 0 ? [] : generateArray(resolved, context, depth, propertyName);
+      if (type === "object") return generateObject(resolved, context, depth);
+      if (type === "integer" || type === "number")
+        return generateNumber(resolved, context, type, propertyName);
+      if (type === "boolean") return context.rng.bool();
+      if (type === "string") return constrainedString(resolved, context, propertyName);
+      return null;
+    }
+  }
+  if (rawSchema.$ref) context.refTrail.add(rawSchema.$ref);
+  try {
+    if ("const" in schema) return schema.const;
+    if (schema.default !== void 0) return schema.default;
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) return context.rng.pick(schema.enum);
+    if (schema.nullable === true && context.rng.bool(0.12)) return null;
+    const allOf = Array.isArray(schema.allOf) ? schema.allOf.filter(isRecord3) : [];
+    if (allOf.length > 0) {
+      let merged = { ...schema };
+      delete merged.allOf;
+      for (const item of allOf) merged = mergeSchema(merged, resolveSchema(item, context));
+      schema = merged;
+    }
+    const branch = chooseCompositionBranch(schema, context);
+    if (branch) {
+      const generated = generateNode(branch, context, depth + 1, propertyName);
+      const disc = discriminatorValue(schema, branch, context);
+      const base = { ...schema };
+      delete base.oneOf;
+      delete base.anyOf;
+      delete base.discriminator;
+      const generatedBase = generateNode(base, context, depth, propertyName);
+      if (isRecord3(generated)) {
+        const combined = { ...isRecord3(generatedBase) ? generatedBase : {}, ...generated };
+        if (disc) combined[disc.name] = disc.value;
+        return combined;
+      }
+      return generated;
+    }
+    const type = schemaType(schema, context.rng);
+    if (type === "null") return null;
+    if (type === "object") return generateObject(schema, context, depth);
+    if (type === "array") return generateArray(schema, context, depth, propertyName);
+    if (type === "integer" || type === "number")
+      return generateNumber(schema, context, type, propertyName);
+    if (type === "boolean") return context.rng.bool();
+    if (type === "string") {
+      const typeArray = Array.isArray(schema.type) ? schema.type : [];
+      if (typeArray.includes("null") && context.rng.bool(0.08)) return null;
+      return constrainedString(schema, context, propertyName);
+    }
+    return null;
+  } finally {
+    if (rawSchema.$ref) context.refTrail.delete(rawSchema.$ref);
+  }
+}
+function createContext(options, seed) {
+  return {
+    root: options.root ?? {},
+    rng: new SeededRandom(seed),
+    faker: createFaker(seed),
+    maxDepth: options.maxDepth ?? 3,
+    minArrayItems: options.minArrayItems ?? 1,
+    maxArrayItems: options.maxArrayItems ?? 3,
+    hints: options.hints ?? true,
+    mode: options.mode ?? "response",
+    warnings: [],
+    refTrail: /* @__PURE__ */ new Set()
+  };
+}
+function stripModeOnlyFields(value, field, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Array.isArray(value)) return value.map((item) => stripModeOnlyFields(item, field, seen));
+  if (!isRecord3(value)) return value;
+  const known = seen.get(value);
+  if (known) return known;
+  const output = {};
+  seen.set(value, output);
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "properties" && isRecord3(child)) {
+      const properties = {};
+      for (const [name, schemaValue] of Object.entries(child)) {
+        if (isRecord3(schemaValue) && schemaValue[field] === true) continue;
+        properties[name] = stripModeOnlyFields(schemaValue, field, seen);
+      }
+      output[key] = properties;
+    } else if (key === "required" && Array.isArray(child)) {
+      const properties = isRecord3(value.properties) ? value.properties : {};
+      output[key] = child.filter(
+        (name) => typeof name !== "string" || !isRecord3(properties[name]) || properties[name]?.[field] !== true
+      );
+    } else {
+      output[key] = stripModeOnlyFields(child, field, seen);
+    }
+  }
+  return output;
+}
+function generateFromSchema(schema, options = {}) {
+  const baseSeed = options.seed ?? 0;
+  const mode = options.mode ?? "response";
+  const field = mode === "response" ? "writeOnly" : "readOnly";
+  const validationRoot = stripModeOnlyFields(options.root ?? {}, field);
+  const validationSchema = stripModeOnlyFields(schema, field);
+  let last;
+  const warnings = [];
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    const seed = deriveSeed(baseSeed, "generate", attempt);
+    const context = createContext(options, seed);
+    last = generateNode(schema, context, 0, "");
+    warnings.push(...context.warnings);
+    const validation = validateSchema(validationRoot, validationSchema, last);
+    if (validation.valid) {
+      return { value: last, warnings: dedupeWarnings(warnings) };
+    }
+  }
+  const reason = warnings.map((warning) => warning.message).join("; ");
+  throw new Error(
+    `Mockline could not generate a value satisfying its schema.${reason ? ` ${reason}` : ""}`
+  );
+}
+function generateValue(schema, options = {}) {
+  return generateFromSchema(schema, options).value;
+}
+function dedupeWarnings(warnings) {
+  const unique = new Map(warnings.map((warning) => [warning.message, warning]));
+  return [...unique.values()];
+}
+
+// src/spec/summary.ts
+function defaultStatus(responses) {
+  if (!responses || Object.keys(responses).length === 0) return "200";
+  const success = Object.keys(responses).filter((key) => /^2\d\d$/.test(key)).sort((a, b) => Number(a) - Number(b));
+  if (success[0]) return success[0];
+  if (responses.default) return "default";
+  return "200";
+}
+function hasExample(response) {
+  if (!response?.content) return false;
+  return Object.values(response.content).some(
+    (media) => "example" in media || Boolean(media.examples && Object.keys(media.examples).length > 0) || Boolean(
+      media.schema && ("example" in media.schema || Array.isArray(media.schema.examples) && media.schema.examples.length > 0)
+    )
+  );
+}
+function summarizeSpec(spec, overrideKeys = []) {
+  const router = createRouter(spec.document);
+  return router.routes.map((route) => {
+    const responses = route.operation.responses;
+    const status = defaultStatus(responses);
+    const response = responses?.[status] ?? responses?.default;
+    const override = overrideKeys.some(
+      (key) => key === route.operationId || key.toUpperCase() === `${route.method} ${route.path}`.toUpperCase()
+    );
+    const source = override ? "override" : hasExample(response) ? "example" : "schema generation";
+    return {
+      method: route.method,
+      path: route.path,
+      operationId: route.operationId,
+      defaultStatus: status,
+      source
+    };
+  });
+}
+
+// src/select.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function headerValue(headers, name) {
+  const value = headers[name.toLowerCase()] ?? headers[name];
+  return Array.isArray(value) ? value.join(",") : value;
+}
+function parseControls(input) {
+  const allow = input.config.controlHeaders.allow;
+  if (!allow) return { forceError: false, active: false };
+  const prefer = headerValue(input.headers, "prefer") ?? "";
+  const statusMatch = /(?:^|[,;]\s*)code\s*=\s*(\d{3})/i.exec(prefer);
+  const exampleMatch = /(?:^|[,;]\s*)example\s*=\s*"?([^,;"\s]+)"?/i.exec(prefer);
+  const headerStatus = Number(headerValue(input.headers, "x-mockline-status"));
+  const status = Number.isInteger(headerStatus) && headerStatus >= 100 && headerStatus <= 599 ? headerStatus : statusMatch?.[1] ? Number(statusMatch[1]) : void 0;
+  const delayValue = Number(headerValue(input.headers, "x-mockline-delay"));
+  const delay = Number.isFinite(delayValue) && delayValue >= 0 ? delayValue : void 0;
+  const forceError = /^(true|1|yes)$/i.test(headerValue(input.headers, "x-mockline-error") ?? "");
+  const example = exampleMatch?.[1];
+  return {
+    status,
+    example,
+    delay,
+    forceError,
+    active: status !== void 0 || example !== void 0 || forceError
+  };
+}
+function responseForStatus(responses, requestedStatus) {
+  const standardStatus = defaultStatus(responses);
+  const status = requestedStatus ?? (standardStatus === "default" ? 200 : Number(standardStatus));
+  return {
+    status,
+    response: responses?.[String(status)] ?? responses?.default ?? (requestedStatus === void 0 ? responses?.[standardStatus] : void 0)
+  };
+}
+function jsonMediaType(media) {
+  const normalized = media.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/json" || normalized.endsWith("+json") || normalized === "application/problem+json";
+}
+function parseAccept(header) {
+  if (!header || header.trim() === "") return [{ value: "*/*", q: 1, index: 0 }];
+  return header.split(",").map((part, index) => {
+    const [value = "*/*", ...parameters] = part.trim().split(";");
+    const qValue = parameters.find((parameter) => parameter.trim().startsWith("q="))?.trim().slice(2);
+    const parsedQ = qValue === void 0 ? 1 : Number(qValue);
+    return {
+      value: value.trim().toLowerCase(),
+      q: Number.isFinite(parsedQ) ? parsedQ : 0,
+      index
+    };
+  }).filter((item) => item.q > 0).sort((a, b) => b.q - a.q || a.index - b.index);
+}
+function mediaMatches(accept, media) {
+  const accepted = accept.split(";")[0]?.trim().toLowerCase() ?? "";
+  const offered = media.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (accepted === "*/*" || accepted === offered) return true;
+  const [acceptedType, acceptedSubtype] = accepted.split("/");
+  const [offeredType, offeredSubtype] = offered.split("/");
+  if (acceptedType === offeredType && acceptedSubtype === "*") return true;
+  if (acceptedType === "*" && Boolean(acceptedSubtype)) return false;
+  if (acceptedSubtype?.startsWith("*+"))
+    return offeredSubtype?.endsWith(acceptedSubtype.slice(1)) ?? false;
+  return false;
+}
+function negotiateMedia(content, accept) {
+  const available = Object.keys(content);
+  if (available.length === 0) return void 0;
+  const preferences = parseAccept(accept);
+  for (const preference of preferences) {
+    const compatible = available.filter((media) => mediaMatches(preference.value, media));
+    if (compatible.length > 0) {
+      return compatible.find(jsonMediaType) ?? compatible[0];
+    }
+  }
+  return void 0;
+}
+function exampleValue(value) {
+  if (isRecord4(value) && "value" in value) return value.value;
+  return value;
+}
+function findExample(media, preferredName) {
+  const examples = isRecord4(media.examples) ? media.examples : void 0;
+  if (examples) {
+    if (preferredName && preferredName in examples)
+      return { found: true, value: exampleValue(examples[preferredName]) };
+    const first = Object.values(examples)[0];
+    if (first !== void 0) return { found: true, value: exampleValue(first) };
+  }
+  if ("example" in media) return { found: true, value: media.example };
+  const schema = isRecord4(media.schema) ? media.schema : void 0;
+  if (schema) {
+    if ("example" in schema) return { found: true, value: schema.example };
+    if (Array.isArray(schema.examples) && schema.examples.length > 0)
+      return { found: true, value: schema.examples[0] };
+  }
+  return { found: false };
+}
+function matchesCondition(condition, input) {
+  let actual;
+  if (condition.location === "query")
+    actual = input.url.searchParams.get(condition.name) ?? void 0;
+  else if (condition.location === "header")
+    actual = headerValue(input.headers, condition.name.toLowerCase());
+  else {
+    const path2 = condition.name.startsWith("/") ? condition.name.slice(1).split("/") : condition.name.split(".");
+    actual = path2.reduce((current, part) => {
+      const key = part.replace(/~1/g, "/").replace(/~0/g, "~");
+      return isRecord4(current) ? current[key] : void 0;
+    }, input.body);
+  }
+  const operation = condition.op ?? "eq";
+  if (operation === "eq") return String(actual) === String(condition.value);
+  if (operation === "contains") {
+    if (Array.isArray(actual))
+      return actual.some((item) => String(item).includes(String(condition.value)));
+    return typeof actual === "string" && actual.includes(String(condition.value));
+  }
+  try {
+    return typeof actual === "string" && new RegExp(String(condition.value)).test(actual);
+  } catch {
+    return false;
+  }
+}
+function overrideKey(input) {
+  const entries = Object.entries(input.config.overrides);
+  return entries.find(([key]) => key === input.route.operationId)?.[0] ?? entries.find(
+    ([key]) => key.toUpperCase() === `${input.route.method} ${input.route.path}`.toUpperCase()
+  )?.[0];
+}
+function selectOverride(override, key, input) {
+  if (override.rules?.length) {
+    const matching = override.rules.find((rule) => matchesCondition(rule.when, input));
+    if (matching) return { value: matching.response };
+  }
+  if (override.when && override.response && matchesCondition(override.when, input))
+    return { value: override.response };
+  if (override.sequence?.length) {
+    const index = input.sequenceIndexes?.get(key) ?? 0;
+    const selectedIndex = override.loop ? index % override.sequence.length : Math.min(index, override.sequence.length - 1);
+    const selected = override.sequence[selectedIndex];
+    if (selected) return { value: selected, sequenceKey: key };
+  }
+  if (!override.when && !override.rules?.length) {
+    const fixed = {};
+    if (override.status !== void 0) fixed.status = override.status;
+    if ("body" in override) fixed.body = override.body;
+    if (override.headers) fixed.headers = override.headers;
+    if (override.delay !== void 0) fixed.delay = override.delay;
+    return { value: fixed };
+  }
+  return void 0;
+}
+function calculateDelay(config, overrideDelay, controlDelay, seed, requestCounter) {
+  if (controlDelay !== void 0) return controlDelay;
+  if (overrideDelay !== void 0) return overrideDelay;
+  const latency = config.latency;
+  const rng = new SeededRandom(deriveSeed(seed, "latency", requestCounter));
+  if (typeof latency === "number") return latency > 0 ? latency : void 0;
+  if (Array.isArray(latency)) return rng.int(latency[0], latency[1]);
+  if ("fixed" in latency && latency.fixed !== void 0)
+    return latency.fixed > 0 ? latency.fixed : void 0;
+  if ("min" in latency && latency.min !== void 0 && latency.max !== void 0) {
+    if (latency.distribution === "normal") {
+      const u1 = Math.max(rng.next(), Number.EPSILON);
+      const u2 = rng.next();
+      const normal = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+      const midpoint = (latency.min + latency.max) / 2;
+      const spread = (latency.max - latency.min) / 6;
+      return Math.max(latency.min, Math.min(latency.max, Math.round(midpoint + normal * spread)));
+    }
+    return rng.int(latency.min, latency.max);
+  }
+  return void 0;
+}
+function injectedFailure(status, seed, input, force) {
+  const rate = input.config.errors.perOperationRates[input.route.operationId] ?? input.config.errors.rate;
+  const rng = new SeededRandom(deriveSeed(seed, "failure", input.requestCounter ?? 0));
+  if (!force && rng.next() >= rate) return void 0;
+  const failureStatus = force ? input.config.errors.statuses[0] ?? 500 : rng.pick(input.config.errors.statuses) ?? 500;
+  return {
+    status: failureStatus,
+    body: problem(
+      failureStatus,
+      failureStatus >= 500 ? "Mock upstream failure" : "Mock error",
+      "A failure was injected by Mockline.",
+      { originalStatus: status }
+    ),
+    headers: { "content-type": "application/problem+json" },
+    source: "generated"
+  };
+}
+function responseWithStatusAndMedia(input, requestedStatus, exampleName, forceSelection, seed) {
+  const warnings = [];
+  const responses = input.route.operation.responses;
+  const selected = responseForStatus(responses, requestedStatus);
+  const status = selected.status;
+  const responseDefinition = selected.response;
+  const content = responseDefinition?.content ?? {};
+  const mediaType = negotiateMedia(content, headerValue(input.headers, "accept"));
+  if (Object.keys(content).length > 0 && mediaType === void 0) {
+    return {
+      response: {
+        status: 406,
+        body: problem(
+          406,
+          "Not Acceptable",
+          "The requested Accept header does not match any response media type declared by this operation."
+        ),
+        headers: { "content-type": "application/problem+json" },
+        source: "generated"
+      },
+      warnings
+    };
+  }
+  const media = mediaType && isRecord4(content[mediaType]) ? content[mediaType] : void 0;
+  const preferredExample = exampleName;
+  const found = media ? findExample(media, preferredExample) : { found: false };
+  const allowExample = input.config.prefer === "example" || forceSelection || Boolean(exampleName);
+  if (found.found && allowExample) {
+    const exampleHeaders = mediaType ? { "content-type": mediaType } : void 0;
+    return {
+      response: { status, body: found.value, headers: exampleHeaders, source: "example" },
+      warnings
+    };
+  }
+  if (!media) return { response: { status, source: "generated" }, warnings };
+  if (mediaType && !jsonMediaType(mediaType)) {
+    if (found.found)
+      return {
+        response: {
+          status,
+          body: found.value,
+          headers: { "content-type": mediaType },
+          source: "example"
+        },
+        warnings
+      };
+    const body = problem(
+      501,
+      "Not Implemented",
+      `Mockline cannot synthesize ${mediaType} responses. Add an example to the OpenAPI document.`
+    );
+    return {
+      response: {
+        status: 501,
+        body,
+        headers: { "content-type": "application/problem+json" },
+        source: "generated"
+      },
+      warnings
+    };
+  }
+  const schema = isRecord4(media.schema) ? media.schema : void 0;
+  if (!schema)
+    return {
+      response: {
+        status,
+        headers: mediaType ? { "content-type": mediaType } : void 0,
+        source: "generated"
+      },
+      warnings
+    };
+  const generated = generateFromSchema(schema, {
+    seed,
+    root: input.root,
+    hints: input.config.generation.hints,
+    maxDepth: input.config.generation.maxDepth,
+    minArrayItems: input.config.generation.minArrayItems,
+    maxArrayItems: input.config.generation.maxArrayItems,
+    mode: "response"
+  });
+  warnings.push(...generated.warnings.map((warning) => warning.message));
+  return {
+    response: {
+      status,
+      body: generated.value,
+      headers: mediaType ? { "content-type": mediaType } : void 0,
+      source: "generated"
+    },
+    warnings
+  };
+}
+function applyAcceptNegotiation(input, response) {
+  const responses = input.route.operation.responses;
+  const definition = responses?.[String(response.status)] ?? responses?.default;
+  const content = definition?.content;
+  if (!content || Object.keys(content).length === 0 || response.status === 406) return response;
+  const mediaType = negotiateMedia(content, headerValue(input.headers, "accept"));
+  if (!mediaType) {
+    return {
+      status: 406,
+      body: problem(
+        406,
+        "Not Acceptable",
+        "The requested Accept header does not match any response media type declared by this operation."
+      ),
+      headers: { "content-type": "application/problem+json" },
+      source: "generated"
+    };
+  }
+  return { ...response, headers: { ...response.headers, "content-type": mediaType } };
+}
+function selectResponse(input) {
+  const controls = parseControls(input);
+  const baseSeed = input.config.seed ?? 0;
+  const counter = input.config.generation.counter ? input.requestCounter ?? 0 : 0;
+  const seed = deriveSeed(baseSeed, input.route.method, input.route.path, counter);
+  let response;
+  let warnings = [];
+  let sequenceKey;
+  let overrideDelay;
+  const controlSelection = controls.status !== void 0 || controls.example !== void 0 || controls.forceError;
+  if (controlSelection) {
+    const selected = responseWithStatusAndMedia(
+      input,
+      controls.status,
+      controls.example,
+      true,
+      seed
+    );
+    response = selected.response;
+    warnings = selected.warnings;
+  } else {
+    const key = overrideKey(input);
+    const override = key ? input.config.overrides[key] : void 0;
+    const chosenOverride = override && key ? selectOverride(override, key, input) : void 0;
+    if (chosenOverride) {
+      const value = chosenOverride.value;
+      sequenceKey = chosenOverride.sequenceKey;
+      overrideDelay = value.delay;
+      const operationStatus = defaultStatus(input.route.operation.responses);
+      const fallbackStatus = operationStatus === "default" ? 200 : Number(operationStatus);
+      response = {
+        status: value.status ?? fallbackStatus,
+        ...value.body !== void 0 ? { body: value.body } : {},
+        ...value.headers ? { headers: value.headers } : {},
+        ...value.delay !== void 0 ? { delay: value.delay } : {},
+        source: "override"
+      };
+    } else {
+      const failurePending = injectedFailure(200, seed, input, false);
+      const acceptsState = applyAcceptNegotiation(input, {
+        status: Number(defaultStatus(input.route.operation.responses)) || 200,
+        source: "state"
+      }).status !== 406;
+      const stateResponse = !failurePending && acceptsState ? typeof input.stateResponse === "function" ? input.stateResponse() : input.stateResponse : void 0;
+      if (stateResponse) response = stateResponse;
+      else {
+        const selected = responseWithStatusAndMedia(input, void 0, void 0, false, seed);
+        response = selected.response;
+        warnings = selected.warnings;
+      }
+    }
+  }
+  const failure = injectedFailure(response.status, seed, input, controls.forceError);
+  if (failure) response = failure;
+  response = applyAcceptNegotiation(input, response);
+  const delay = calculateDelay(
+    input.config,
+    overrideDelay ?? response.delay,
+    controls.delay,
+    seed,
+    input.requestCounter ?? 0
+  );
+  if (delay !== void 0) response = { ...response, delay };
+  return { response, warnings, ...sequenceKey ? { sequenceKey } : {} };
+}
+function redactHeaders(headers, extraRedacted) {
+  const redacted = /* @__PURE__ */ new Set([
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "proxy-authorization",
+    "x-api-key",
+    "api-key",
+    "x-auth-token",
+    "x-access-token",
+    ...extraRedacted.map((name) => name.toLowerCase())
+  ]);
+  const result = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (value === void 0) continue;
+    result[name] = redacted.has(name.toLowerCase()) ? "[REDACTED]" : value;
+  }
+  return result;
+}
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+var RequestRecorder = class {
+  buffer = [];
+  maxRequests;
+  file;
+  redact;
+  clock;
+  nextId = 1;
+  writeQueue = Promise.resolve();
+  constructor(config, clock = () => /* @__PURE__ */ new Date()) {
+    this.maxRequests = config.recording.maxRequests;
+    this.file = config.recording.file ? resolve(config.recording.file) : void 0;
+    this.redact = config.recording.redactHeaders;
+    this.clock = clock;
+  }
+  record(input) {
+    const entry = {
+      id: String(this.nextId++),
+      timestamp: this.clock().toISOString(),
+      method: input.method,
+      url: input.url,
+      ...input.operationId ? { operationId: input.operationId } : {},
+      ...input.matchedPath ? { matchedPath: input.matchedPath } : {},
+      headers: redactHeaders(input.headers, this.redact),
+      ...input.body !== void 0 ? { body: input.body } : {},
+      responseStatus: input.responseStatus,
+      responseSource: input.responseSource,
+      durationMs: input.durationMs,
+      validationErrors: [...input.validationErrors]
+    };
+    if (this.buffer.length >= this.maxRequests) this.buffer.shift();
+    this.buffer.push(entry);
+    if (this.file) {
+      this.writeQueue = this.writeQueue.then(async () => {
+        await mkdir(dirname(this.file), { recursive: true });
+        await appendFile(this.file, `${JSON.stringify(entry)}
+`, "utf8");
+      }).catch((error) => {
+        console.error(
+          `mockline: could not append request record: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }
+    return cloneRecord(entry);
+  }
+  setConfig(config) {
+    this.maxRequests = config.recording.maxRequests;
+    this.file = config.recording.file ? resolve(config.recording.file) : void 0;
+    this.redact = config.recording.redactHeaders;
+    while (this.buffer.length > this.maxRequests) this.buffer.shift();
+  }
+  list(filter = {}) {
+    const since = filter.since ? new Date(filter.since).getTime() : void 0;
+    let entries = this.buffer.filter((entry) => {
+      if (filter.method && entry.method.toUpperCase() !== filter.method.toUpperCase()) return false;
+      if (filter.path && !entry.url.includes(filter.path)) return false;
+      if (filter.status !== void 0 && entry.responseStatus !== filter.status) return false;
+      if (filter.operationId && entry.operationId !== filter.operationId) return false;
+      if (since !== void 0 && Number.isFinite(since) && new Date(entry.timestamp).getTime() < since)
+        return false;
+      return true;
+    });
+    if (filter.limit !== void 0) entries = filter.limit <= 0 ? [] : entries.slice(-filter.limit);
+    return entries.map(cloneRecord);
+  }
+  get(id) {
+    const entry = this.buffer.find((request) => request.id === id);
+    return entry ? cloneRecord(entry) : void 0;
+  }
+  clear() {
+    this.buffer.length = 0;
+  }
+  async flush() {
+    await this.writeQueue;
+  }
+};
+
+// src/inspector.ts
+function json(status, body) {
+  return { status, body, headers: { "content-type": "application/json; charset=utf-8" } };
+}
+function problemResult(status, title, detail) {
+  return {
+    status,
+    body: problem(status, title, detail),
+    headers: { "content-type": "application/problem+json; charset=utf-8" }
+  };
+}
+function redactConfig(config) {
+  const copy = structuredClone(config);
+  const proxy = copy.proxy;
+  if (typeof proxy === "object" && proxy !== null && !Array.isArray(proxy)) {
+    proxy.url = proxy.url ? "[REDACTED UPSTREAM URL]" : void 0;
+    proxy.recordFile = proxy.recordFile ? "[PATH REDACTED]" : void 0;
+  }
+  const recording = copy.recording;
+  if (typeof recording === "object" && recording !== null && !Array.isArray(recording) && recording.file) {
+    recording.file = "[PATH REDACTED]";
+  }
+  return copy;
+}
+function parseInteger(searchParams, key) {
+  const value = searchParams.get(key);
+  if (value === null) return void 0;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+function requestFilter(url) {
+  const status = parseInteger(url.searchParams, "status");
+  const limit = parseInteger(url.searchParams, "limit");
+  if (status === null || limit === null || status !== void 0 && (status < 100 || status > 599))
+    return null;
+  const since = url.searchParams.get("since") ?? void 0;
+  if (since && !Number.isFinite(new Date(since).getTime())) return null;
+  return {
+    ...url.searchParams.get("method") ? { method: url.searchParams.get("method") ?? void 0 } : {},
+    ...url.searchParams.get("path") ? { path: url.searchParams.get("path") ?? void 0 } : {},
+    ...status !== void 0 ? { status } : {},
+    ...url.searchParams.get("operationId") ? { operationId: url.searchParams.get("operationId") ?? void 0 } : {},
+    ...since ? { since } : {},
+    ...limit !== void 0 ? { limit } : {}
+  };
+}
+function specSummary(context) {
+  const resolvedSpec = { ...context.spec, document: context.spec.dereferenced };
+  const operations = summarizeSpec(resolvedSpec);
+  const schemas = Object.keys(context.spec.document.components?.schemas ?? {});
+  const info = context.spec.document.info ?? {};
+  return {
+    openapi: context.spec.document.openapi,
+    title: typeof info.title === "string" ? info.title : void 0,
+    version: typeof info.version === "string" ? info.version : void 0,
+    operations,
+    schemas,
+    warnings: context.spec.warnings
+  };
+}
+function outputRequest(record) {
+  return record;
+}
+async function handleInspector(method, url, context) {
+  if (url.pathname !== "/__mockline" && !url.pathname.startsWith("/__mockline/")) return void 0;
+  if (!context.enabled)
+    return problemResult(404, "Not Found", "The inspector API is disabled for this bind address.");
+  const pathname = url.pathname.replace(/\/+$/, "") || "/";
+  if (pathname === "/__mockline/health" && method === "GET") {
+    return json(200, {
+      status: "ok",
+      uptimeSeconds: Number(process.uptime().toFixed(3)),
+      openapi: context.spec.document.openapi,
+      operationCount: summarizeSpec(context.spec).length,
+      startedAt: context.startedAt.toISOString()
+    });
+  }
+  if (pathname === "/__mockline/spec" && method === "GET") return json(200, specSummary(context));
+  if (pathname === "/__mockline/config" && method === "GET")
+    return json(200, redactConfig(context.config));
+  if (pathname === "/__mockline/requests" && method === "GET") {
+    const filter = requestFilter(url);
+    if (filter === null)
+      return problemResult(
+        400,
+        "Bad Request",
+        "Invalid request filter. limit must be a non-negative integer, status must be an HTTP status code, and since must be a date."
+      );
+    return json(200, context.recorder.list(filter ?? {}));
+  }
+  if (pathname === "/__mockline/requests" && method === "DELETE") {
+    context.recorder.clear();
+    return json(200, { deleted: true });
+  }
+  const requestMatch = /^\/__mockline\/requests\/([^/]+)$/.exec(pathname);
+  if (requestMatch && method === "GET") {
+    let id = requestMatch[1] ?? "";
+    try {
+      id = decodeURIComponent(id);
+    } catch {
+      return problemResult(400, "Bad Request", "Request ID contains invalid percent encoding.");
+    }
+    const request = outputRequest(context.recorder.get(id));
+    return request ? json(200, request) : problemResult(404, "Not Found", `No recorded request has ID ${id}.`);
+  }
+  if (requestMatch)
+    return {
+      ...problemResult(
+        405,
+        "Method Not Allowed",
+        `Method ${method} is not allowed for ${pathname}.`
+      ),
+      headers: { "content-type": "application/problem+json", allow: "GET" }
+    };
+  if (pathname === "/__mockline/reset" && method === "POST") {
+    await context.reset();
+    return json(200, { reset: true });
+  }
+  const allowByPath = {
+    "/__mockline/health": ["GET"],
+    "/__mockline/spec": ["GET"],
+    "/__mockline/config": ["GET"],
+    "/__mockline/requests": ["GET", "DELETE"],
+    "/__mockline/reset": ["POST"]
+  };
+  const allowed = allowByPath[pathname];
+  if (allowed)
+    return {
+      ...problemResult(
+        405,
+        "Method Not Allowed",
+        `Method ${method} is not allowed for ${pathname}.`
+      ),
+      headers: { "content-type": "application/problem+json", allow: allowed.join(", ") }
+    };
+  return problemResult(404, "Not Found", `No inspector endpoint matched ${pathname}.`);
+}
+
+// src/state/collections.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function responseSchema(operation) {
+  const responses = operation.responses;
+  if (!responses) return void 0;
+  const status = defaultStatus(responses);
+  const response = responses[status] ?? responses.default;
+  const content = response?.content;
+  if (!content) return void 0;
+  const media = content["application/json"] ?? Object.entries(content).find(([type]) => type.endsWith("+json"))?.[1];
+  return media?.schema;
+}
+function resolveSchema2(schema, root) {
+  if (!schema || typeof schema.$ref !== "string" || !schema.$ref.startsWith("#/")) return schema;
+  const resolved = schema.$ref.slice(2).split("/").reduce((current, part) => {
+    const key = part.replace(/~1/g, "/").replace(/~0/g, "~");
+    return isRecord5(current) ? current[key] : void 0;
+  }, root);
+  return isRecord5(resolved) ? resolved : schema;
+}
+function schemaProperties(schema, root, seen = /* @__PURE__ */ new Set()) {
+  if (!schema || seen.has(schema)) return {};
+  seen.add(schema);
+  const resolved = resolveSchema2(schema, root) ?? schema;
+  const output = isRecord5(resolved.properties) ? { ...resolved.properties } : {};
+  if (Array.isArray(resolved.allOf)) {
+    for (const branch of resolved.allOf) {
+      if (isRecord5(branch))
+        Object.assign(output, schemaProperties(branch, root, seen));
+    }
+  }
+  return output;
+}
+function schemaFingerprint(schema, root) {
+  if (!schema) return void 0;
+  if (schema.$ref) return `ref:${schema.$ref}`;
+  return JSON.stringify(resolveSchema2(schema, root));
+}
+function listItemSchema(schema) {
+  if (!schema) return void 0;
+  if (schema.type === "array" && isRecord5(schema.items)) return schema.items;
+  if (Array.isArray(schema.type) && schema.type.includes("array") && isRecord5(schema.items))
+    return schema.items;
+  return void 0;
+}
+function requestBodySchema(operation) {
+  const body = isRecord5(operation.requestBody) ? operation.requestBody : void 0;
+  const content = isRecord5(body?.content) ? body.content : {};
+  const media = isRecord5(content["application/json"]) ? content["application/json"] : Object.entries(content).find(([type]) => type.endsWith("+json"))?.[1];
+  return isRecord5(media) && isRecord5(media.schema) ? media.schema : void 0;
+}
+function pathId(path2, collectionPath) {
+  if (!path2.startsWith(`${collectionPath}/`)) return void 0;
+  const tail = path2.slice(collectionPath.length + 1);
+  const match = /^\{([^{}]+)\}$/.exec(tail);
+  return match?.[1];
+}
+function declaredQueryName(route, name) {
+  return route.parameters.some((parameter) => parameter.in === "query" && parameter.name === name) ? name : void 0;
+}
+function detectCollections(router, root, idProperty = "id") {
+  const collections = [];
+  const listRoutes = router.routes.filter(
+    (route) => route.method === "GET" && !route.path.includes("{")
+  );
+  for (const listRoute of listRoutes) {
+    const createRoute = router.routes.find(
+      (route) => route.method === "POST" && route.path === listRoute.path
+    );
+    if (!createRoute) continue;
+    const listItem = listItemSchema(responseSchema(listRoute.operation));
+    if (!listItem) continue;
+    const itemCandidates = router.routes.filter(
+      (route) => pathId(route.path, listRoute.path) !== void 0
+    );
+    const getItem = itemCandidates.find((route) => route.method === "GET");
+    if (!getItem) continue;
+    const getSchema = responseSchema(getItem.operation);
+    if (!getSchema || schemaFingerprint(listItem, root) !== schemaFingerprint(getSchema, root))
+      continue;
+    const properties = schemaProperties(listItem, root);
+    const idSchema = isRecord5(properties[idProperty]) ? properties[idProperty] : void 0;
+    if (!idSchema) continue;
+    const itemRoutes = /* @__PURE__ */ new Map();
+    for (const route of itemCandidates) {
+      const routeIdParam = pathId(route.path, listRoute.path);
+      if (routeIdParam && routeIdParam === pathId(getItem.path, listRoute.path))
+        itemRoutes.set(route.method, route);
+    }
+    collections.push({
+      path: listRoute.path,
+      idParam: pathId(getItem.path, listRoute.path) ?? idProperty,
+      idProperty,
+      listRoute,
+      createRoute,
+      itemRoutes,
+      itemSchema: listItem,
+      ...requestBodySchema(createRoute.operation) ? { createSchema: requestBodySchema(createRoute.operation) } : {},
+      ...declaredQueryName(listRoute, "limit") ? { limitParam: "limit" } : {},
+      ...declaredQueryName(listRoute, "offset") ? { offsetParam: "offset" } : {}
+    });
+  }
+  return collections;
+}
+
+// src/state/store.ts
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveSchema3(schema, root) {
+  if (!schema || typeof schema.$ref !== "string" || !schema.$ref.startsWith("#/")) return schema;
+  const resolved = schema.$ref.slice(2).split("/").reduce((current, part) => {
+    const key = part.replace(/~1/g, "/").replace(/~0/g, "~");
+    return isRecord6(current) ? current[key] : void 0;
+  }, root);
+  return isRecord6(resolved) ? resolved : schema;
+}
+function mergedProperties(schema, root, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(schema)) return {};
+  seen.add(schema);
+  const resolved = resolveSchema3(schema, root) ?? schema;
+  const properties = isRecord6(resolved.properties) ? resolved.properties : {};
+  const merged = { ...properties };
+  if (Array.isArray(resolved.allOf)) {
+    for (const branch of resolved.allOf) {
+      if (isRecord6(branch))
+        Object.assign(merged, mergedProperties(branch, root, seen));
+    }
+  }
+  return merged;
+}
+function defaultSuccessStatus(route) {
+  const value = defaultStatus(route.operation.responses);
+  const status = Number(value);
+  return Number.isInteger(status) ? status : 200;
+}
+function asResponse(status, body, contentType = "application/json; charset=utf-8") {
+  return { status, body, headers: { "content-type": contentType }, source: "state" };
+}
+function parseId(value) {
+  return String(value);
+}
+function cleanResponseFields(item, definition, root) {
+  const properties = mergedProperties(definition.itemSchema, root);
+  const output = { ...item };
+  for (const [name, schema] of Object.entries(properties)) {
+    if (schema.writeOnly === true) delete output[name];
+  }
+  return output;
+}
+var ResourceStore = class {
+  collections;
+  root;
+  seed;
+  config;
+  data = /* @__PURE__ */ new Map();
+  routeIndex = /* @__PURE__ */ new Map();
+  constructor(router, root, config) {
+    this.root = root;
+    this.config = config;
+    this.seed = config.seed ?? 0;
+    this.collections = detectCollections(router, root, config.stateful.idProperty);
+    for (const definition of this.collections) {
+      const state = { definition, items: [], nextNumericId: 1 };
+      this.data.set(definition.path, state);
+      this.routeIndex.set(`${definition.listRoute.method} ${definition.listRoute.path}`, {
+        state,
+        kind: "list",
+        route: definition.listRoute
+      });
+      this.routeIndex.set(`${definition.createRoute.method} ${definition.createRoute.path}`, {
+        state,
+        kind: "create",
+        route: definition.createRoute
+      });
+      for (const [method, route] of definition.itemRoutes) {
+        this.routeIndex.set(`${method} ${route.path}`, { state, kind: "item", route });
+      }
+    }
+    this.reset();
+  }
+  setConfig(config) {
+    this.config = config;
+    this.seed = config.seed ?? 0;
+  }
+  reset() {
+    for (const state of this.data.values()) {
+      state.items = [];
+      if (!this.config.stateful.enabled) continue;
+      state.nextNumericId = 1;
+      for (let index = 0; index < this.config.stateful.seedItems; index += 1) {
+        const seed = deriveSeed(this.seed, state.definition.path, index, "initial");
+        const generated = generateValue(state.definition.itemSchema, {
+          root: this.root,
+          seed,
+          hints: this.config.generation.hints,
+          maxDepth: this.config.generation.maxDepth,
+          minArrayItems: this.config.generation.minArrayItems,
+          maxArrayItems: this.config.generation.maxArrayItems,
+          mode: "response"
+        });
+        const item = isRecord6(generated) ? { ...generated } : {};
+        const assignedId = this.ensureId(item, state, seed, true);
+        item[state.definition.idProperty] = assignedId;
+        state.items.push(cleanResponseFields(item, state.definition, this.root));
+      }
+      const numericIds = state.items.map((item) => item[state.definition.idProperty]).filter((value) => typeof value === "number" && Number.isFinite(value));
+      if (numericIds.length > 0) state.nextNumericId = Math.max(...numericIds) + 1;
+    }
+  }
+  handle(route, params, url, body) {
+    const match = this.routeIndex.get(`${route.method} ${route.path}`);
+    if (!match) return void 0;
+    const { state, kind } = match;
+    const definition = state.definition;
+    if (kind === "list") {
+      let items = state.items.map((item) => ({ ...item }));
+      const offset = definition.offsetParam ? Math.max(0, Number(url.searchParams.get(definition.offsetParam) ?? 0) || 0) : 0;
+      const limitRaw = definition.limitParam ? url.searchParams.get(definition.limitParam) : null;
+      const limit = limitRaw === null ? void 0 : Math.max(0, Number(limitRaw) || 0);
+      items = items.slice(offset, limit === void 0 ? void 0 : offset + limit);
+      return asResponse(defaultSuccessStatus(route), items);
+    }
+    if (kind === "create") {
+      let item;
+      if (isRecord6(body)) item = { ...body };
+      else {
+        const schema = definition.createSchema ?? definition.itemSchema;
+        const generated = generateValue(schema, {
+          root: this.root,
+          seed: deriveSeed(this.seed, route.method, route.path, state.items.length, "post"),
+          hints: this.config.generation.hints,
+          maxDepth: this.config.generation.maxDepth,
+          minArrayItems: this.config.generation.minArrayItems,
+          maxArrayItems: this.config.generation.maxArrayItems,
+          mode: "request"
+        });
+        item = isRecord6(generated) ? { ...generated } : {};
+      }
+      const id = this.ensureId(
+        item,
+        state,
+        deriveSeed(this.seed, route.path, state.items.length, "create"),
+        false
+      );
+      item[definition.idProperty] = id;
+      const saved = cleanResponseFields(item, definition, this.root);
+      state.items.push(saved);
+      return asResponse(defaultSuccessStatus(route), { ...saved });
+    }
+    const rawId = params[definition.idParam];
+    const index = state.items.findIndex(
+      (item) => parseId(item[definition.idProperty]) === String(rawId)
+    );
+    if (route.method === "GET") {
+      if (index < 0)
+        return {
+          status: 404,
+          body: problem(
+            404,
+            "Not Found",
+            `No resource with ${definition.idProperty} ${rawId} exists.`
+          ),
+          headers: { "content-type": "application/problem+json" },
+          source: "state"
+        };
+      return asResponse(defaultSuccessStatus(route), { ...state.items[index] });
+    }
+    if (route.method === "DELETE") {
+      if (index < 0) return { status: 204, source: "state" };
+      state.items.splice(index, 1);
+      return { status: 204, source: "state" };
+    }
+    if (route.method === "PUT" || route.method === "PATCH") {
+      if (index < 0)
+        return {
+          status: 404,
+          body: problem(
+            404,
+            "Not Found",
+            `No resource with ${definition.idProperty} ${rawId} exists.`
+          ),
+          headers: { "content-type": "application/problem+json" },
+          source: "state"
+        };
+      const current = state.items[index] ?? {};
+      const replacement = isRecord6(body) ? { ...body } : {};
+      const item = route.method === "PATCH" ? { ...current, ...replacement } : replacement;
+      item[definition.idProperty] = current[definition.idProperty] ?? rawId;
+      state.items[index] = cleanResponseFields(item, definition, this.root);
+      return asResponse(defaultSuccessStatus(route), { ...state.items[index] });
+    }
+    return void 0;
+  }
+  ensureId(item, state, seed, seedItem) {
+    const definition = state.definition;
+    const properties = mergedProperties(definition.itemSchema, this.root);
+    const schema = properties[definition.idProperty] ?? { type: "string" };
+    const current = item[definition.idProperty];
+    const duplicate = current !== void 0 && state.items.some((existing) => parseId(existing[definition.idProperty]) === parseId(current));
+    const valid = current !== void 0 && validateSchema(this.root, schema, current).valid;
+    if (valid && !duplicate) return current;
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+      let candidate;
+      if (schema.type === "integer" || schema.type === "number") {
+        candidate = state.nextNumericId++;
+      } else {
+        candidate = generateValue(schema, {
+          root: this.root,
+          seed: deriveSeed(seed, "id", attempt),
+          hints: false,
+          maxDepth: 1,
+          minArrayItems: 0,
+          maxArrayItems: 0
+        });
+        if (typeof candidate === "string" && !("format" in schema) && !("pattern" in schema) && !("enum" in schema) && !("const" in schema)) {
+          candidate = seedItem ? candidate : `${candidate}-${state.items.length + 1}`;
+        }
+      }
+      const alreadyUsed = state.items.some(
+        (existing) => parseId(existing[definition.idProperty]) === parseId(candidate)
+      );
+      if (!alreadyUsed && validateSchema(this.root, schema, candidate).valid) return candidate;
+    }
+    return schema.type === "integer" || schema.type === "number" ? state.nextNumericId++ : `${definition.path.replace(/\W/g, "")}-${state.items.length + 1}`;
+  }
+};
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "host",
+  "content-length",
+  "expect"
+]);
+function isPrivateIpv4(address) {
+  const parts = address.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255))
+    return true;
+  const [a = 0, b = 0] = parts;
+  return a === 0 || a === 10 || a === 127 || a >= 224 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127 || a === 198 && (b === 18 || b === 19) || a === 192 && b === 0 || a === 198 && b === 51 || a === 203 && b === 0;
+}
+function ipv4FromMappedIpv6(address) {
+  const lowered = address.toLowerCase().split("%")[0] ?? "";
+  if (!lowered.startsWith("::ffff:")) return void 0;
+  const tail = lowered.slice("::ffff:".length);
+  if (tail.includes(".")) return tail;
+  const parts = tail.split(":");
+  if (parts.length !== 2 || parts.some((part) => !/^[0-9a-f]{1,4}$/.test(part))) return void 0;
+  const first = Number.parseInt(parts[0] ?? "0", 16);
+  const second = Number.parseInt(parts[1] ?? "0", 16);
+  return `${first >> 8}.${first & 255}.${second >> 8}.${second & 255}`;
+}
+function isPrivateAddress(address) {
+  const version = isIP(address);
+  if (version === 4) return isPrivateIpv4(address);
+  if (version !== 6) return true;
+  const normalized = address.toLowerCase().split("%")[0] ?? "";
+  const mapped = ipv4FromMappedIpv6(normalized);
+  if (mapped) return isPrivateIpv4(mapped);
+  return normalized === "::" || normalized === "::1" || /^f[cd]/.test(normalized) || /^fe[89ab]/.test(normalized) || normalized.startsWith("ff") || normalized.startsWith("2001:db8:");
+}
+function stripHopByHop(headers) {
+  const blocked = new Set(HOP_BY_HOP);
+  const connection = headers.connection;
+  if (connection)
+    for (const header of connection.split(",")) blocked.add(header.trim().toLowerCase());
+  const output = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (!blocked.has(name.toLowerCase())) output[name] = value;
+  }
+  return output;
+}
+function requestHeaders(headers) {
+  const output = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (value !== void 0)
+      output[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return stripHopByHop(output);
+}
+function targetUrl(upstream, requestUrl) {
+  const basePath = upstream.pathname.replace(/\/+$/, "");
+  const requestedPath = requestUrl.pathname.startsWith("/") ? requestUrl.pathname : `/${requestUrl.pathname}`;
+  const target = new URL(upstream);
+  target.pathname = `${basePath}${requestedPath}` || "/";
+  target.search = requestUrl.search;
+  target.hash = "";
+  return target;
+}
+async function resolvesPrivate(hostname, timeoutMs) {
+  const unbracketedHost = hostname.replace(/^\[(.*)\]$/, "$1");
+  if (isIP(unbracketedHost)) return isPrivateAddress(unbracketedHost);
+  const normalizedHost = unbracketedHost.toLowerCase().replace(/\.$/, "");
+  if (normalizedHost === "localhost" || [".localhost", ".local", ".internal", ".lan", ".home.arpa"].some(
+    (suffix) => normalizedHost.endsWith(suffix)
+  ))
+    return true;
+  let timer;
+  try {
+    const addresses = await Promise.race([
+      lookup(unbracketedHost, { all: true, verbatim: true }),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("DNS lookup timed out")), timeoutMs);
+      })
+    ]);
+    return addresses.length === 0 || addresses.some((entry) => isPrivateAddress(entry.address));
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function proxyProblem(status, title, detail) {
+  const body = Buffer.from(JSON.stringify(problem(status, title, detail)));
+  return {
+    status,
+    headers: {
+      "content-type": "application/problem+json; charset=utf-8",
+      "content-length": String(body.byteLength)
+    },
+    body,
+    blocked: status === 403
+  };
+}
+async function forwardRequest(input) {
+  let upstream;
+  try {
+    upstream = new URL(input.upstream);
+  } catch {
+    return proxyProblem(502, "Bad Gateway", "The configured proxy URL is invalid.");
+  }
+  if (upstream.protocol !== "http:" && upstream.protocol !== "https:") {
+    return proxyProblem(502, "Bad Gateway", "Mockline proxy URLs must use http or https.");
+  }
+  if (!input.config.allowPrivate) {
+    try {
+      if (await resolvesPrivate(upstream.hostname, input.config.timeoutMs)) {
+        return proxyProblem(
+          403,
+          "Forbidden",
+          "Proxying to private, loopback, or link-local addresses is disabled. Use --proxy-allow-private only for a trusted local upstream."
+        );
+      }
+    } catch (error) {
+      return proxyProblem(
+        502,
+        "Bad Gateway",
+        `Could not safely resolve proxy host: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const target = targetUrl(upstream, input.requestUrl);
+  const fetchImpl = input.fetchImpl ?? globalThis.fetch;
+  const headers = requestHeaders(input.headers);
+  try {
+    const copiedBody = input.body && input.body.byteLength > 0 && input.method !== "GET" && input.method !== "HEAD" ? Uint8Array.from(input.body) : void 0;
+    const response = await fetchImpl(target, {
+      method: input.method,
+      headers,
+      ...copiedBody ? { body: copiedBody.buffer } : {},
+      redirect: "manual",
+      signal: AbortSignal.timeout(input.config.timeoutMs)
+    });
+    const body = Buffer.from(await response.arrayBuffer());
+    const responseHeaders = {};
+    response.headers.forEach((value, name) => {
+      responseHeaders[name.toLowerCase()] = value;
+    });
+    const filtered = stripHopByHop(responseHeaders);
+    delete filtered["content-length"];
+    delete filtered["content-encoding"];
+    return { status: response.status, headers: filtered, body, blocked: false };
+  } catch (error) {
+    const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+    return proxyProblem(
+      timedOut ? 504 : 502,
+      timedOut ? "Gateway Timeout" : "Bad Gateway",
+      timedOut ? "The upstream request timed out." : `The upstream request failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function decodeExample(input) {
+  const mediaType = input.headers["content-type"]?.split(";")[0]?.trim();
+  const base = {
+    method: input.method,
+    path: input.path,
+    ...input.operationId ? { operationId: input.operationId } : {},
+    status: input.status,
+    ...mediaType ? { mediaType } : {},
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (mediaType === "application/json" || mediaType?.endsWith("+json")) {
+    try {
+      return { ...base, example: JSON.parse(input.body.toString("utf8")) };
+    } catch {
+      return { ...base, example: input.body.toString("utf8") };
+    }
+  }
+  if (mediaType?.startsWith("text/")) return { ...base, example: input.body.toString("utf8") };
+  return { ...base, bodyBase64: input.body.toString("base64") };
+}
+var ProxyExampleRecorder = class {
+  file;
+  queue = Promise.resolve();
+  constructor(file) {
+    this.file = file ? resolve(file) : void 0;
+  }
+  setFile(file) {
+    this.file = file ? resolve(file) : void 0;
+  }
+  record(input) {
+    if (!this.file) return;
+    const example = decodeExample(input);
+    this.queue = this.queue.then(async () => {
+      await mkdir(dirname(this.file), { recursive: true });
+      let examples = [];
+      try {
+        const existing = JSON.parse(await readFile(this.file, "utf8"));
+        if (typeof existing === "object" && existing !== null && !Array.isArray(existing) && Array.isArray(existing.examples)) {
+          examples = existing.examples;
+        }
+      } catch {
+      }
+      examples.push(example);
+      const destination = this.file;
+      const temporary = `${destination}.tmp`;
+      await writeFile(
+        temporary,
+        `${JSON.stringify({ format: "mockline-proxy-examples-v1", examples }, null, 2)}
+`,
+        "utf8"
+      );
+      await rename(temporary, destination);
+    }).catch((error) => {
+      console.error(
+        `mockline: could not save proxy example: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+  }
+  async flush() {
+    await this.queue;
+  }
+};
+
+// src/validate.ts
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function headerValue2(headers, name) {
+  const value = headers[name.toLowerCase()] ?? headers[name];
+  return Array.isArray(value) ? value.join(",") : value;
+}
+function cookieValues(header) {
+  const result = /* @__PURE__ */ new Map();
+  if (!header) return result;
+  for (const entry of header.split(";")) {
+    const separator = entry.indexOf("=");
+    if (separator < 0) continue;
+    const name = entry.slice(0, separator).trim();
+    const value = entry.slice(separator + 1).trim();
+    if (name) result.set(name, decodeURIComponentSafe(value));
+  }
+  return result;
+}
+function decodeURIComponentSafe(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function schemaType2(schema) {
+  if (Array.isArray(schema.type))
+    return schema.type.find((item) => typeof item === "string" && item !== "null") ?? "string";
+  return typeof schema.type === "string" ? schema.type : "string";
+}
+function coerceScalar(value, schema) {
+  const type = schemaType2(schema);
+  if (type === "integer") {
+    if (!/^[+-]?\d+$/.test(value.trim())) return value;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : value;
+  }
+  if (type === "number") {
+    if (value.trim() === "") return value;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : value;
+  }
+  if (type === "boolean") {
+    if (value.toLowerCase() === "true") return true;
+    if (value.toLowerCase() === "false") return false;
+  }
+  if (type === "null" && value === "null") return null;
+  return value;
+}
+function coerceTyped(value, schema) {
+  const type = schemaType2(schema);
+  if (type === "array" && Array.isArray(value)) {
+    const items = isRecord7(schema.items) ? schema.items : {};
+    return value.map((item) => coerceTyped(item, items));
+  }
+  if (type === "object" && isRecord7(value)) {
+    const properties = isRecord7(schema.properties) ? schema.properties : {};
+    return Object.fromEntries(
+      Object.entries(value).map(([name, item]) => [
+        name,
+        properties[name] ? coerceTyped(item, properties[name]) : item
+      ])
+    );
+  }
+  return typeof value === "string" ? coerceScalar(value, schema) : value;
+}
+function coerceValue(raw, schema, parameter) {
+  if (raw === void 0) return void 0;
+  const type = schemaType2(schema);
+  if (type === "array") {
+    const items = isRecord7(schema.items) ? schema.items : {};
+    const style = parameter?.style ?? (parameter?.in === "query" ? "form" : "simple");
+    const explode = parameter?.explode ?? style === "form";
+    const separator = style === "spaceDelimited" ? " " : style === "pipeDelimited" ? "|" : ",";
+    const values = Array.isArray(raw) ? raw : raw.includes(separator) && !explode ? raw.split(separator) : [raw];
+    return values.map((item) => coerceTyped(item, items));
+  }
+  if (type === "object") {
+    let value;
+    if (Array.isArray(raw)) return raw;
+    if (raw.trim().startsWith("{")) {
+      try {
+        const parsed = JSON.parse(raw);
+        value = isRecord7(parsed) ? parsed : {};
+      } catch {
+        value = {};
+      }
+    } else {
+      value = {};
+      const separator = parameter?.style === "simple" ? "," : "&";
+      for (const pair of raw.split(separator)) {
+        const [name, ...rest] = pair.split("=");
+        if (name) value[name] = rest.join("=");
+      }
+    }
+    return coerceTyped(value, schema);
+  }
+  return typeof raw === "string" ? coerceScalar(raw, schema) : raw.map((item) => coerceScalar(item, schema));
+}
+function parameterRawValue(parameter, input) {
+  if (parameter.in === "path") return input.params[parameter.name];
+  if (parameter.in === "query") {
+    const values = input.url.searchParams.getAll(parameter.name);
+    if (values.length > 1) return values;
+    if (values.length === 1) return values[0];
+    if (parameter.style === "deepObject") {
+      const object = {};
+      for (const [key, value] of input.url.searchParams.entries()) {
+        const match = new RegExp(`^${escapeRegExp(parameter.name)}\\[([^\\]]+)\\]$`).exec(key);
+        if (match?.[1]) object[match[1]] = value;
+      }
+      if (Object.keys(object).length > 0) return JSON.stringify(object);
+    }
+    if (schemaType2(parameter.schema ?? {}) === "object" && parameter.explode !== false) {
+      const properties = isRecord7(parameter.schema?.properties) ? parameter.schema.properties : {};
+      const object = {};
+      for (const name of Object.keys(properties)) {
+        const value = input.url.searchParams.get(name);
+        if (value !== null) object[name] = value;
+      }
+      if (Object.keys(object).length > 0) return JSON.stringify(object);
+    }
+    return void 0;
+  }
+  if (parameter.in === "header") return headerValue2(input.headers, parameter.name);
+  return cookieValues(headerValue2(input.headers, "cookie")).get(parameter.name);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatAjvIssue(issue, location) {
+  const pointer = issue.instancePath.split("/").filter(Boolean).map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~")).join("/");
+  const at = pointer ? `${location}/${pointer}` : location;
+  const suffix = issue.message ? `: ${issue.message}` : "";
+  return { location: at, message: `${at}${suffix}`, keyword: issue.keyword };
+}
+function stripReadOnly(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Array.isArray(value)) return value.map((item) => stripReadOnly(item, seen));
+  if (!isRecord7(value)) return value;
+  const known = seen.get(value);
+  if (known) return known;
+  const copy = {};
+  seen.set(value, copy);
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "properties" && isRecord7(child)) {
+      const properties = {};
+      for (const [property, propertySchema] of Object.entries(child)) {
+        if (isRecord7(propertySchema) && propertySchema.readOnly === true) continue;
+        properties[property] = stripReadOnly(propertySchema, seen);
+      }
+      copy[key] = properties;
+    } else if (key === "required" && Array.isArray(child)) {
+      const parentProperties = isRecord7(value.properties) ? value.properties : {};
+      copy[key] = child.filter(
+        (property) => typeof property !== "string" || !isRecord7(parentProperties[property]) || parentProperties[property]?.readOnly !== true
+      );
+    } else {
+      copy[key] = stripReadOnly(child, seen);
+    }
+  }
+  return copy;
+}
+function requestRootWithoutReadOnly(root) {
+  return stripReadOnly(root);
+}
+function contentTypeMatches(declared, actual) {
+  const expected = declared.split(";")[0]?.trim().toLowerCase() ?? "";
+  const received = actual.split(";")[0]?.trim().toLowerCase() ?? "";
+  return expected === received || expected === "application/*" && received.startsWith("application/") || expected === "application/json" && received.endsWith("+json");
+}
+function validateParameters(input) {
+  const issues = [];
+  for (const parameter of input.route.parameters) {
+    if (!parameter.schema) continue;
+    const location = `${parameter.in}.${parameter.name}`;
+    const raw = parameterRawValue(parameter, input);
+    if (raw === void 0) {
+      if (parameter.required)
+        issues.push({
+          location,
+          message: `${location}: required parameter is missing`,
+          keyword: "required"
+        });
+      continue;
+    }
+    const value = coerceValue(raw, parameter.schema, parameter);
+    const validation = validateSchema(input.root, parameter.schema, value);
+    issues.push(...validation.errors.map((error) => formatAjvIssue(error, location)));
+  }
+  return issues;
+}
+function requestBodyContent(operation) {
+  const body = isRecord7(operation.requestBody) ? operation.requestBody : void 0;
+  const content = isRecord7(body?.content) ? body.content : {};
+  return { content, contentTypes: Object.keys(content), required: body?.required === true };
+}
+function validateBody(input) {
+  const issues = [];
+  const details = requestBodyContent(input.route.operation);
+  if (details.contentTypes.length === 0) return { issues, bodyInvalid: false };
+  const contentType = headerValue2(input.headers, "content-type");
+  if (input.bodyPresent && !contentType) {
+    issues.push({
+      location: "header.content-type",
+      message: "header.content-type: Content-Type is required for this operation",
+      keyword: "contentType"
+    });
+  }
+  const selectedType = contentType && details.contentTypes.find((declared) => contentTypeMatches(declared, contentType));
+  if (input.bodyPresent && contentType && !selectedType) {
+    issues.push({
+      location: "header.content-type",
+      message: `header.content-type: expected ${details.contentTypes.join(" or ")}`,
+      keyword: "contentType"
+    });
+  }
+  if (!input.bodyPresent) {
+    if (details.required)
+      issues.push({
+        location: "body",
+        message: "body: required request body is missing",
+        keyword: "required"
+      });
+    return { issues, bodyInvalid: issues.length > 0 };
+  }
+  const mediaObject = selectedType && isRecord7(details.content[selectedType]) ? details.content[selectedType] : void 0;
+  const bodySchema = isRecord7(mediaObject?.schema) ? mediaObject.schema : void 0;
+  if (!selectedType || !bodySchema) return { issues, bodyInvalid: issues.length > 0 };
+  const root = requestRootWithoutReadOnly(input.root);
+  const validation = validateSchema(root, stripReadOnly(bodySchema), input.body);
+  issues.push(...validation.errors.map((error) => formatAjvIssue(error, "/body")));
+  return { issues, bodyInvalid: !validation.valid || issues.length > 0 };
+}
+function validateRequest(input) {
+  const parameterIssues = validateParameters(input);
+  const bodyResult = validateBody(input);
+  return {
+    valid: parameterIssues.length === 0 && bodyResult.issues.length === 0,
+    issues: [...parameterIssues, ...bodyResult.issues],
+    bodyInvalid: bodyResult.bodyInvalid
+  };
+}
+function checkSecurityPresence(root, operation, headers, url) {
+  const requirements = operation.security ?? root.security ?? [];
+  if (requirements.length === 0) return { authorized: true, missing: [] };
+  const schemes = root.components?.securitySchemes ?? {};
+  const missingAll = [];
+  for (const requirement of requirements) {
+    const missing = [];
+    for (const name of Object.keys(requirement)) {
+      const scheme = schemes[name];
+      if (!isRecord7(scheme)) {
+        missing.push(name);
+        continue;
+      }
+      const type = String(scheme.type ?? "");
+      if (type === "apiKey") {
+        const location = String(scheme.in ?? "");
+        const credentialName = String(scheme.name ?? "");
+        const headerCredential = location === "header" ? headerValue2(headers, credentialName) : void 0;
+        const present = location === "header" ? headerCredential !== void 0 : location === "query" ? url.searchParams.has(credentialName) : location === "cookie" ? cookieValues(headerValue2(headers, "cookie")).has(credentialName) : false;
+        if (!present) missing.push(`${name} (${location} ${credentialName})`);
+      } else if (type === "http" || type === "oauth2" || type === "openIdConnect" || type === "mutualTLS") {
+        if (headerValue2(headers, "authorization") === void 0)
+          missing.push(`${name} (Authorization)`);
+      } else {
+        missing.push(name);
+      }
+    }
+    if (missing.length === 0) return { authorized: true, missing: [] };
+    missingAll.push(...missing);
+  }
+  return { authorized: false, missing: [...new Set(missingAll)] };
+}
+function strictValidationStatus(result) {
+  return result.bodyInvalid ? 422 : 400;
+}
+
+// src/server.ts
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var BodyTooLargeError = class extends Error {
+  constructor() {
+    super("Request body exceeded the configured size limit.");
+    this.name = "BodyTooLargeError";
+  }
+};
+var InvalidJsonError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidJsonError";
+  }
+};
+function asHeaders(headers) {
+  return headers;
+}
+function isLoopback(host) {
+  const value = host.toLowerCase().replace(/^\[|\]$/g, "");
+  return value === "localhost" || value === "::1" || value.startsWith("127.") || value.startsWith("::ffff:127.") || isIP(value) === 0 && value.endsWith(".localhost");
+}
+function hostnameForUrl(host) {
+  const value = host.replace(/^\[|\]$/g, "");
+  return value.includes(":") ? `[${value}]` : value;
+}
+function applyCors(req, res, config) {
+  if (!config.cors.enabled) return;
+  const origin = req.headers.origin;
+  const allowed = config.cors.origins;
+  if (allowed.includes("*")) res.setHeader("Access-Control-Allow-Origin", "*");
+  else if (origin && allowed.includes(origin)) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+  }
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD");
+  const requestHeaders2 = req.headers["access-control-request-headers"];
+  res.setHeader(
+    "Access-Control-Allow-Headers",
+    requestHeaders2 ?? "Content-Type, Authorization, Prefer, X-Mockline-Status, X-Mockline-Delay, X-Mockline-Error"
+  );
+  res.setHeader("Access-Control-Max-Age", "600");
+}
+function writeJson(res, status, body, headers = {}, head = false) {
+  if (res.destroyed || res.writableEnded) return;
+  const safeStatus = Number.isInteger(status) && status >= 100 && status <= 599 ? status : 500;
+  res.statusCode = safeStatus;
+  for (const [name, value] of Object.entries(headers)) {
+    try {
+      res.setHeader(name, value);
+    } catch {
+    }
+  }
+  if (!res.hasHeader("content-type"))
+    res.setHeader("content-type", "application/json; charset=utf-8");
+  if (head || safeStatus === 204 || safeStatus === 304) {
+    res.end();
+    return;
+  }
+  const contentType = String(res.getHeader("content-type") ?? "").toLowerCase();
+  let serialized;
+  if (Buffer.isBuffer(body)) serialized = body;
+  else if (typeof body === "string" && !contentType.includes("json")) serialized = body;
+  else if (body === void 0) serialized = "";
+  else {
+    try {
+      serialized = JSON.stringify(body);
+    } catch {
+      res.statusCode = 500;
+      serialized = JSON.stringify(
+        problem(
+          500,
+          "Internal Server Error",
+          "The selected response body could not be serialized."
+        )
+      );
+      res.setHeader("content-type", "application/problem+json; charset=utf-8");
+    }
+  }
+  res.setHeader(
+    "content-length",
+    Buffer.isBuffer(serialized) ? serialized.byteLength : Buffer.byteLength(serialized)
+  );
+  try {
+    res.end(serialized);
+  } catch {
+    res.destroy();
+  }
+}
+async function readBody(req, limit) {
+  const declaredLength = req.headers["content-length"];
+  if (typeof declaredLength === "string") {
+    const parsedLength = Number(declaredLength);
+    if (!Number.isFinite(parsedLength) || parsedLength < 0)
+      throw new InvalidJsonError("Invalid Content-Length header.");
+    if (parsedLength > limit) {
+      req.resume();
+      throw new BodyTooLargeError();
+    }
+  }
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of req) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk) : Buffer.from(String(chunk));
+      size += buffer.byteLength;
+      if (size > limit) {
+        req.resume();
+        throw new BodyTooLargeError();
+      }
+      chunks.push(buffer);
+    }
+  } catch (error) {
+    if (error instanceof BodyTooLargeError) throw error;
+    if (req.destroyed) throw error;
+    throw new InvalidJsonError("Could not read request body.");
+  }
+  if (size === 0) return { present: false, raw: Buffer.alloc(0) };
+  const raw = Buffer.concat(chunks);
+  const text = raw.toString("utf8");
+  const contentType = String(req.headers["content-type"] ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  if (contentType === "application/json" || contentType.endsWith("+json")) {
+    try {
+      return { present: true, value: JSON.parse(text), raw };
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : "invalid JSON";
+      return { present: true, raw, parseError: `Malformed JSON request body: ${reason}` };
+    }
+  }
+  return { present: true, value: text, raw };
+}
+function issueStrings(issues) {
+  return issues.map((issue) => issue.message);
+}
+function problemResponse(status, title, detail, extra = {}) {
+  return {
+    status,
+    body: problem(status, title, detail, extra),
+    headers: { "content-type": "application/problem+json" },
+    source: "generated"
+  };
+}
+function createRequestAccessor(recorder) {
+  const accessor = ((filter = {}) => recorder.list(filter));
+  accessor.get = (id) => recorder.get(id);
+  accessor.clear = () => recorder.clear();
+  return accessor;
+}
+function routeUrl(req, host) {
+  const headerHost = req.headers.host;
+  const fallbackHost = hostnameForUrl(host);
+  return new URL(req.url ?? "/", `http://${headerHost ?? fallbackHost}`);
+}
+function setServerRequestTimeout(server, timeout) {
+  server.requestTimeout = timeout;
+  server.headersTimeout = Math.min(timeout, 6e4);
+}
+async function createMockServer(options) {
+  const loaded = await loadSpec(options.spec);
+  let config = configSchema.parse({
+    ...options.config ?? {},
+    ...options.port !== void 0 ? { port: options.port } : {},
+    ...options.host !== void 0 ? { host: options.host } : {},
+    ...options.seed !== void 0 ? { seed: options.seed } : {}
+  });
+  const logger = options.logger ?? createLogger();
+  const inspectorRequested = options.inspector ?? config.inspector.enabled;
+  const inspectorEnabled = inspectorRequested === void 0 ? isLoopback(config.host) : inspectorRequested;
+  if (!isLoopback(config.host)) {
+    if (inspectorEnabled)
+      logger.warn(
+        "The inspector API is enabled on a non-loopback bind; use it only on a trusted network."
+      );
+    else
+      logger.warn(
+        "The inspector API is disabled for a non-loopback bind. Use --inspector only on a trusted network."
+      );
+  }
+  if (["0.0.0.0", "::"].includes(config.host))
+    logger.warn(`Binding to ${config.host} exposes this mock server to the network.`);
+  const routerState = { current: createRouter(loaded.document) };
+  const specState = { current: loaded };
+  const stateStoreState = {
+    current: new ResourceStore(routerState.current, loaded.document, config)
+  };
+  const recorder = new RequestRecorder(config, options.clock);
+  const proxyExamples = new ProxyExampleRecorder(config.proxy.recordFile);
+  const requestCounters = /* @__PURE__ */ new Map();
+  const sequenceIndexes = /* @__PURE__ */ new Map();
+  const startedAt = options.clock?.() ?? /* @__PURE__ */ new Date();
+  const boundPort = config.port;
+  const boundHost = config.host;
+  const resetRuntime = async () => {
+    requestCounters.clear();
+    sequenceIndexes.clear();
+    stateStoreState.current.reset();
+  };
+  let closing = false;
+  let watcher;
+  let specReloadTimer;
+  let configReloadTimer;
+  const handler = async (req, res) => {
+    const started = (options.clock ?? (() => /* @__PURE__ */ new Date()))().getTime();
+    const method = (req.method ?? "GET").toUpperCase();
+    let url2;
+    try {
+      url2 = routeUrl(req, config.host);
+    } catch {
+      url2 = new URL("/", "http://mockline.local");
+      applyCors(req, res, config);
+      const failure = problemResponse(400, "Bad Request", "The request URL is malformed.");
+      writeJson(res, failure.status, failure.body, failure.headers);
+      if (config.recording.enabled)
+        recorder.record({
+          method,
+          url: req.url ?? "/",
+          headers: asHeaders(req.headers),
+          responseStatus: failure.status,
+          responseSource: "error",
+          durationMs: Math.max(0, (options.clock ?? (() => /* @__PURE__ */ new Date()))().getTime() - started),
+          validationErrors: ["Malformed request URL"]
+        });
+      return;
+    }
+    applyCors(req, res, config);
+    const pathname = normalizePath(url2.pathname);
+    let body;
+    let bodyPresent;
+    let rawBody = Buffer.alloc(0);
+    let route;
+    let response = problemResponse(
+      500,
+      "Internal Server Error",
+      "Request processing did not complete."
+    );
+    let validationErrors = [];
+    let source = "error";
+    let responseHeaders = {};
+    const forward = async (matchedRoute) => {
+      if (!config.proxy.url)
+        return problemResponse(502, "Bad Gateway", "No proxy upstream is configured.");
+      const proxied = await forwardRequest({
+        upstream: config.proxy.url,
+        method,
+        requestUrl: url2,
+        headers: asHeaders(req.headers),
+        body: rawBody,
+        config: config.proxy,
+        fetchImpl: options.fetch
+      });
+      if (!proxied.blocked && config.proxy.recordFile) {
+        proxyExamples.record({
+          method,
+          path: `${url2.pathname}${url2.search}`,
+          ...{},
+          status: proxied.status,
+          headers: proxied.headers,
+          body: proxied.body
+        });
+      }
+      return {
+        status: proxied.status,
+        body: proxied.body,
+        headers: proxied.headers,
+        source: "proxy"
+      };
+    };
+    try {
+      if (pathname === "/__mockline" || pathname.startsWith("/__mockline/")) {
+        const inspectorResponse = await handleInspector(method, url2, {
+          enabled: inspectorEnabled,
+          recorder,
+          config,
+          spec: specState.current,
+          startedAt,
+          reset: resetRuntime
+        });
+        response = inspectorResponse ? {
+          status: inspectorResponse.status,
+          ...inspectorResponse.body !== void 0 ? { body: inspectorResponse.body } : {},
+          ...inspectorResponse.headers ? { headers: inspectorResponse.headers } : {},
+          source: "generated"
+        } : problemResponse(404, "Not Found", "The inspector endpoint does not exist.");
+        source = "inspector";
+      } else if (method === "OPTIONS" && config.cors.enabled && req.headers["access-control-request-method"]) {
+        response = { status: 204, source: "generated" };
+        source = "generated";
+      } else {
+        const read = await readBody(req, config.requestBodyLimit);
+        body = read.value;
+        bodyPresent = read.present;
+        rawBody = read.raw;
+        if (config.proxy.all && config.proxy.url) {
+          response = await forward();
+          source = "proxy";
+        } else {
+          const match = routerState.current.match(method, pathname);
+          if (!match) {
+            if (read.parseError && !config.proxy.url) throw new InvalidJsonError(read.parseError);
+            if (config.proxy.url) {
+              response = await forward();
+              source = "proxy";
+            } else {
+              const methods = routerState.current.methodsForPath(pathname);
+              const nearest = routerState.current.nearestPath(pathname);
+              if (methods.length > 0) {
+                response = problemResponse(
+                  405,
+                  "Method Not Allowed",
+                  `Method ${method} is not allowed for ${pathname}.`,
+                  nearest ? { nearestPath: nearest } : {}
+                );
+                responseHeaders = { Allow: methods.join(", ") };
+              } else {
+                response = problemResponse(
+                  404,
+                  "Not Found",
+                  nearest ? `No route matched. Nearest path: ${nearest}.` : `No route matched ${pathname}.`,
+                  nearest ? { nearestPath: nearest } : {}
+                );
+              }
+              source = "error";
+            }
+          } else {
+            if (read.parseError) throw new InvalidJsonError(read.parseError);
+            route = match.route;
+            let authorized = true;
+            if (config.enforceAuth) {
+              const auth = checkSecurityPresence(
+                specState.current.document,
+                route.operation,
+                asHeaders(req.headers),
+                url2
+              );
+              authorized = auth.authorized;
+              if (!authorized) {
+                response = problemResponse(
+                  401,
+                  "Unauthorized",
+                  "A credential declared by the OpenAPI security scheme is required.",
+                  { errors: auth.missing }
+                );
+                responseHeaders = { "www-authenticate": 'Bearer realm="Bearer"' };
+                source = "error";
+              }
+            }
+            if (authorized) {
+              const validation = config.validate === "off" ? { valid: true, issues: [], bodyInvalid: false } : validateRequest({
+                root: specState.current.document,
+                route,
+                params: match.params,
+                url: url2,
+                headers: asHeaders(req.headers),
+                body,
+                bodyPresent
+              });
+              const strictFailure = !validation.valid && config.validate === "strict";
+              if (!validation.valid) {
+                validationErrors = issueStrings(validation.issues);
+                if (strictFailure) {
+                  const status = strictValidationStatus(validation);
+                  response = problemResponse(
+                    status,
+                    status === 422 ? "Unprocessable Content" : "Bad Request",
+                    "Request validation failed.",
+                    {
+                      errors: validation.issues.map((issue) => ({
+                        location: issue.location,
+                        message: issue.message
+                      }))
+                    }
+                  );
+                  source = "error";
+                } else if (config.validate === "warn") {
+                  responseHeaders["X-Mockline-Validation"] = "failed";
+                  for (const error of validationErrors)
+                    logger.warn(`${route.operationId}: ${error}`);
+                }
+              }
+              if (!strictFailure) {
+                const key = `${route.method} ${route.path}`;
+                const counter = requestCounters.get(key) ?? 0;
+                requestCounters.set(key, counter + 1);
+                const stateResponse = config.stateful.enabled ? () => stateStoreState.current.handle(match.route, match.params, url2, body) : void 0;
+                const selected = selectResponse({
+                  root: specState.current.document,
+                  route,
+                  config,
+                  headers: asHeaders(req.headers),
+                  url: url2,
+                  body,
+                  requestCounter: counter,
+                  sequenceIndexes,
+                  stateResponse
+                });
+                response = selected.response;
+                if (selected.sequenceKey) {
+                  const index = sequenceIndexes.get(selected.sequenceKey) ?? 0;
+                  sequenceIndexes.set(selected.sequenceKey, index + 1);
+                }
+                for (const warning of selected.warnings)
+                  logger.warn(`${route.operationId}: ${warning}`);
+                source = response.source;
+                if (responseHeaders["X-Mockline-Validation"])
+                  response = {
+                    ...response,
+                    headers: { ...response.headers, "X-Mockline-Validation": "failed" }
+                  };
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof BodyTooLargeError) {
+        response = problemResponse(413, "Content Too Large", error.message);
+        validationErrors = [error.message];
+      } else if (error instanceof InvalidJsonError) {
+        response = problemResponse(400, "Bad Request", error.message);
+        validationErrors = [error.message];
+      } else {
+        logger.error(error instanceof Error ? error.message : String(error));
+        response = problemResponse(
+          500,
+          "Internal Server Error",
+          "Mockline could not process this request."
+        );
+      }
+      source = "error";
+    }
+    const headers = { ...response.headers, ...responseHeaders };
+    response = { ...response, headers };
+    try {
+      if (response.delay && response.delay > 0) await setTimeout$1(response.delay);
+      writeJson(res, response.status, response.body, headers, method === "HEAD");
+    } catch (error) {
+      if (!res.destroyed && !res.headersSent) {
+        const failure = problem(
+          500,
+          "Internal Server Error",
+          error instanceof Error ? error.message : "Response failed."
+        );
+        writeJson(res, 500, failure, { "content-type": "application/problem+json" });
+        source = "error";
+      }
+    } finally {
+      const ended = (options.clock ?? (() => /* @__PURE__ */ new Date()))().getTime();
+      if (config.recording.enabled) {
+        recorder.record({
+          method,
+          url: `${url2.pathname}${url2.search}`,
+          ...route ? { operationId: route.operationId, matchedPath: route.path } : {},
+          headers: asHeaders(req.headers),
+          ...body !== void 0 ? { body } : {},
+          responseStatus: res.statusCode || response.status,
+          responseSource: source,
+          durationMs: Math.max(0, ended - started),
+          validationErrors
+        });
+      }
+    }
+  };
+  const httpServer = createServer((req, res) => {
+    void handler(req, res).catch((error) => {
+      if (!res.destroyed && !res.headersSent) {
+        const detail = error instanceof Error ? error.message : "Unexpected request failure.";
+        writeJson(res, 500, problem(500, "Internal Server Error", detail), {
+          "content-type": "application/problem+json"
+        });
+      }
+    });
+  });
+  setServerRequestTimeout(httpServer, config.requestTimeoutMs);
+  httpServer.on("clientError", (_error, socket) => {
+    if (socket.writable && !socket.destroyed)
+      socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+    else socket.destroy();
+  });
+  try {
+    await new Promise((resolve5, reject) => {
+      const onError = (error) => {
+        httpServer.off("listening", onListening);
+        reject(error);
+      };
+      const onListening = () => {
+        httpServer.off("error", onError);
+        resolve5();
+      };
+      httpServer.once("error", onError);
+      httpServer.once("listening", onListening);
+      httpServer.listen(config.port, config.host);
+    });
+  } catch (error) {
+    const code = isRecord8(error) && error.code === "EADDRINUSE" ? "Port is already in use" : "Could not start server";
+    throw new MocklineError(
+      `${code} (${config.host}:${config.port}): ${error instanceof Error ? error.message : String(error)}`,
+      3,
+      error
+    );
+  }
+  const address = httpServer.address();
+  const actualPort = address && typeof address !== "string" ? address.port : config.port;
+  const url = `http://${hostnameForUrl(config.host)}:${actualPort}`;
+  const requests = createRequestAccessor(recorder);
+  if (options.watch) {
+    const specPath = resolve(options.spec);
+    const configPaths = options.configFile ? [resolve(options.configFile)] : [resolve("mockline.yaml"), resolve("mockline.yml"), resolve("mockline.json")];
+    const watchedPaths = [.../* @__PURE__ */ new Set([specPath, ...configPaths])];
+    const reloadSpec = async () => {
+      try {
+        const nextSpec = await loadSpec(options.spec);
+        const nextRouter = createRouter(nextSpec.document);
+        const nextStore = new ResourceStore(nextRouter, nextSpec.document, config);
+        specState.current = nextSpec;
+        routerState.current = nextRouter;
+        stateStoreState.current = nextStore;
+        requestCounters.clear();
+        sequenceIndexes.clear();
+        logger.info(`Reloaded OpenAPI spec ${options.spec}`);
+      } catch (error) {
+        logger.error(
+          `Invalid OpenAPI change; keeping the last good spec: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+    const reloadConfiguration = async () => {
+      try {
+        const loadedConfig = options.reloadConfig ? await options.reloadConfig() : (await loadConfig(options.configFile)).config;
+        if (loadedConfig.port !== boundPort || loadedConfig.host !== boundHost) {
+          logger.warn(
+            "Hot reload cannot change the bound host or port; keeping the original listener address."
+          );
+        }
+        const nextConfig = configSchema.parse({
+          ...loadedConfig,
+          port: boundPort,
+          host: boundHost
+        });
+        const stateChanged = config.seed !== nextConfig.seed || JSON.stringify(config.stateful) !== JSON.stringify(nextConfig.stateful) || JSON.stringify(config.generation) !== JSON.stringify(nextConfig.generation);
+        config = nextConfig;
+        recorder.setConfig(config);
+        proxyExamples.setFile(config.proxy.recordFile);
+        stateStoreState.current.setConfig(config);
+        if (stateChanged) stateStoreState.current.reset();
+        setServerRequestTimeout(httpServer, config.requestTimeoutMs);
+        logger.info("Reloaded Mockline configuration");
+      } catch (error) {
+        logger.error(
+          `Invalid config change; keeping the last good config: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+    const schedule = (kind) => {
+      if (closing) return;
+      const previous = kind === "spec" ? specReloadTimer : configReloadTimer;
+      if (previous) clearTimeout(previous);
+      const timer = setTimeout(() => {
+        if (kind === "spec") void reloadSpec();
+        else void reloadConfiguration();
+      }, 120);
+      timer.unref();
+      if (kind === "spec") specReloadTimer = timer;
+      else configReloadTimer = timer;
+    };
+    watcher = watch(watchedPaths, {
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 120, pollInterval: 30 }
+    });
+    watcher.on("all", (event, changedPath) => {
+      if (!["add", "change", "unlink"].includes(event)) return;
+      const absolutePath = resolve(changedPath);
+      if (absolutePath === specPath) schedule("spec");
+      if (configPaths.includes(absolutePath)) schedule("config");
+    });
+    watcher.on("error", (error) => {
+      logger.error(`Watch error: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  }
+  return {
+    url,
+    requests,
+    async reset() {
+      await resetRuntime();
+    },
+    setOverride(key, override) {
+      const parsed = configSchema.parse({ overrides: { [key]: override } }).overrides[key];
+      if (!parsed) throw new MocklineError(`Invalid override for ${key}`, 1);
+      config = { ...config, overrides: { ...config.overrides, [key]: parsed } };
+      stateStoreState.current.setConfig(config);
+    },
+    async close() {
+      if (closing) return;
+      closing = true;
+      if (specReloadTimer) clearTimeout(specReloadTimer);
+      if (configReloadTimer) clearTimeout(configReloadTimer);
+      await watcher?.close();
+      await new Promise((resolve5, reject) => {
+        httpServer.close((error) => error ? reject(error) : resolve5());
+      });
+      await recorder.flush();
+      await proxyExamples.flush();
+    }
+  };
+}
+
+export { ResourceStore, SeededRandom, checkSecurityPresence, configSchema, createMockServer, createRouter, defaultConfig, defaultStatus, deriveSeed, detectCollections, generateFromSchema, generateValue, hashSeed, inspectSpec, loadSpec, normalizePath, summarizeSpec, validateRequest };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map