@afora/core 0.0.9 → 0.0.12

package/dist/{index-hg1z2s2v.js → core/output/openapi-sink.js}

@@ -1,509 +1,27 @@
+import { isBlueprint } from "../blueprint/is-blueprint.js";
+import { isBlueprintList } from "../blueprint/list.js";
+import { recordFieldOf } from "../blueprint/record-field.js";
+import { isBlueprintVariant } from "../blueprint/variant.js";
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import { Exception } from "../exception/exception.js";
+import { toOpenAPI } from "../openapi/openapi.js";
+import { isProperty } from "../property/is-property.js";
+import { recordNameOf } from "../record/name.js";
 import {
-  isProperty,
-  isBlueprint,
-  recordFieldOf,
-  Exception2,
-  isBlueprintVariant,
-  recordNameOf2,
-  isBlueprintList,
-  toOpenAPI2,
   HEADER_NAME,
-  isRoutePath,
-  parametersOfPath,
+  isRoutePath as isPath,
+  isScalarKey as isScalarInputKey,
   isScalarSchema,
-  isScalarKey,
-  InvalidOutputStage2,
-  sinkOf2
-} from "./index-xegv6a1p.js";
-
-// src/core/application/schema.ts
-var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function sorted(value) {
-  if (Array.isArray(value))
-    return value.map(sorted);
-  if (!isObject(value))
-    return value;
-  return Object.fromEntries(Object.keys(value).filter((key) => !key.startsWith("~") && value[key] !== undefined).sort().map((key) => [key, sorted(value[key])]));
-}
-function evolutionOf(property, description, found = {}, depth = 0) {
-  if (property === undefined || depth > 64)
-    return found;
-  const resolved = "ref" in property ? description.properties[property.ref] : property;
-  const lineage = resolved?.lineage;
-  if (lineage === undefined || lineage.kind === "factory")
-    return found;
-  if (lineage.kind === "refined") {
-    const { fill, renamedFrom } = lineage.options;
-    if (!("fill" in found) && fill !== undefined)
-      found.fill = fill;
-    if (found.renamedFrom === undefined && typeof renamedFrom === "string") {
-      found.renamedFrom = renamedFrom;
-    }
-  }
-  return evolutionOf(lineage.base, description, found, depth + 1);
-}
-function fieldsOf(fields, description) {
-  if (fields === undefined)
-    return;
-  return Object.fromEntries(Object.keys(fields).sort().map((key) => [
-    key,
-    lockFieldOf(fields[key], description)
-  ]));
-}
-function lockFieldOf(field, description) {
-  switch (field.kind) {
-    case "property": {
-      const property = "ref" in field ? description.properties[field.ref] : field;
-      const evolution = evolutionOf("ref" in field ? { ref: field.ref } : field, description);
-      return {
-        schema: sorted(property?.schema ?? {}),
-        optional: field.optional,
-        ...property?.unique ? { unique: true } : {},
-        ..."fill" in evolution ? { fill: sorted(evolution.fill) } : {},
-        ...evolution.renamedFrom === undefined ? {} : { renamedFrom: evolution.renamedFrom }
-      };
-    }
-    case "list": {
-      const item = lockFieldOf(field.item, description);
-      return {
-        schema: sorted({
-          type: "array",
-          items: item.schema,
-          minItems: field.minItems,
-          maxItems: field.maxItems
-        }),
-        optional: field.optional,
-        ...item.fields === undefined ? {} : { fields: item.fields }
-      };
-    }
-    case "blueprint": {
-      const fields = "ref" in field ? description.blueprints[field.ref]?.fields : field.fields;
-      return {
-        schema: { type: "object" },
-        optional: field.optional,
-        fields: fieldsOf(fields, description) ?? {}
-      };
-    }
-    case "record": {
-      const fields = description.records[field.ref]?.fields;
-      return {
-        schema: { type: "object" },
-        optional: field.optional,
-        fields: fieldsOf(fields, description) ?? {}
-      };
-    }
-    case "variant":
-      return {
-        schema: { discriminator: field.key, type: "object" },
-        optional: field.optional,
-        fields: Object.fromEntries(Object.keys(field.variants).sort().map((tag) => [
-          tag,
-          {
-            ...lockFieldOf(field.variants[tag], description),
-            optional: true
-          }
-        ]))
-      };
-    case "entity":
-      return {
-        schema: { entity: field.ref, type: "string" },
-        optional: field.optional
-      };
-  }
-}
-function lockEntityOf(entity, description) {
-  const declared = fieldsOf(entity.fields, description) ?? {};
-  const unique = new Set(entity.options.unique.filter((key) => key !== "id"));
-  for (const [key, field] of Object.entries(declared)) {
-    if (field.unique)
-      unique.add(key);
-  }
-  const fields = Object.fromEntries(Object.entries(declared).map(([key, field]) => [
-    key,
-    unique.has(key) ? { ...field, unique: true } : field
-  ]));
-  return {
-    schemaVersion: entity.schemaVersion ?? 1,
-    previousNames: [...entity.previousNames ?? []].sort(),
-    unique: [...unique].sort(),
-    fields,
-    ...entity.upgrade === undefined || entity.upgrade.length === 0 ? {} : { upgrade: [...entity.upgrade].sort((a, b) => a - b) }
-  };
-}
-function schemaLockOf2(description) {
-  return {
-    lockVersion: 1,
-    entities: sorted(Object.fromEntries(Object.keys(description.entities).map((name) => [
-      name,
-      lockEntityOf(description.entities[name], description)
-    ])))
-  };
-}
-var METADATA = new Set([
-  "title",
-  "description",
-  "examples",
-  "default",
-  "deprecated",
-  "readOnly",
-  "writeOnly",
-  "$comment"
-]);
-var UPPER = new Set([
-  "maximum",
-  "exclusiveMaximum",
-  "maxLength",
-  "maxItems",
-  "maxProperties"
-]);
-var LOWER = new Set([
-  "minimum",
-  "exclusiveMinimum",
-  "minLength",
-  "minItems",
-  "minProperties"
-]);
-var NARROWING = new Set([
-  "pattern",
-  "format",
-  "multipleOf",
-  "allOf",
-  "const"
-]);
-var same = (a, b) => JSON.stringify(sorted(a)) === JSON.stringify(sorted(b));
-function literalsOf(schema) {
-  if (Array.isArray(schema.enum)) {
-    return schema.enum.map((value) => JSON.stringify(value));
-  }
-  if (Array.isArray(schema.anyOf) && schema.anyOf.every((item) => isObject(item) && ("const" in item))) {
-    return schema.anyOf.map((item) => JSON.stringify(item.const));
-  }
-  return;
-}
-function compareSchemas(previous, next) {
-  if (same(previous, next))
-    return "same";
-  const strip = (schema) => Object.fromEntries(Object.entries(schema).filter(([key]) => !METADATA.has(key)));
-  const [a, b] = [strip(previous), strip(next)];
-  if (same(a, b))
-    return "metadata";
-  if (!same(a.type, b.type) || !same(a.entity, b.entity))
-    return "type-changed";
-  const [before, after] = [literalsOf(a), literalsOf(b)];
-  let loosened = false;
-  let tightened = false;
-  if (before !== undefined || after !== undefined) {
-    if (before === undefined || after === undefined)
-      return "type-changed";
-    const kept = before.every((value) => after.includes(value));
-    const gained = after.some((value) => !before.includes(value));
-    if (!kept)
-      tightened = true;
-    if (gained)
-      loosened = true;
-  }
-  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
-  for (const key of keys) {
-    if (["type", "entity", "enum", "anyOf"].includes(key))
-      continue;
-    if (same(a[key], b[key]))
-      continue;
-    const [x, y] = [a[key], b[key]];
-    if (key === "items") {
-      const items = compareSchemas(isObject(x) ? x : {}, isObject(y) ? y : {});
-      if (items === "type-changed")
-        return "type-changed";
-      if (items === "tightened")
-        tightened = true;
-      if (items === "loosened")
-        loosened = true;
-    } else if (UPPER.has(key) || LOWER.has(key)) {
-      if (x === undefined)
-        tightened = true;
-      else if (y === undefined)
-        loosened = true;
-      else if (typeof x !== "number" || typeof y !== "number")
-        return "type-changed";
-      else if (UPPER.has(key) ? y > x : y < x)
-        loosened = true;
-      else
-        tightened = true;
-    } else if (NARROWING.has(key)) {
-      if (y === undefined)
-        loosened = true;
-      else
-        tightened = true;
-    } else {
-      return "type-changed";
-    }
-  }
-  if (tightened)
-    return "tightened";
-  return loosened ? "loosened" : "metadata";
-}
-function push(context, change, klass, satisfied, extra = {}) {
-  context.changes.push({
-    entity: context.entity,
-    ...extra.key === undefined ? {} : { key: extra.key },
-    change,
-    class: klass,
-    satisfied,
-    destructive: extra.destructive ?? false,
-    ...extra.from === undefined ? {} : { from: extra.from },
-    ...extra.detail === undefined ? {} : { detail: extra.detail }
-  });
-}
-var STEP = "an upgrade step (bump schemaVersion and add upgrade[n])";
-function diffFields(context, previous, next, path) {
-  const join = (key) => path ? `${path}.${key}` : key;
-  const renamedFrom = new Map;
-  for (const [key, field] of Object.entries(next)) {
-    const from = field.renamedFrom;
-    if (from !== undefined && !(key in previous) && from in previous && !(from in next)) {
-      renamedFrom.set(key, from);
-    }
-  }
-  const moved = new Set(renamedFrom.values());
-  const keys = [...new Set([...Object.keys(previous), ...Object.keys(next)])].filter((key) => !moved.has(key)).sort();
-  for (const key of keys) {
-    const was = previous[key];
-    const is = next[key];
-    if (is === undefined) {
-      push(context, "removed", "automatic", true, {
-        key: join(key),
-        destructive: true,
-        detail: "Left out on read; a backfill removes it only with destructive: true. Rename it with renamedFrom to keep the data."
-      });
-      continue;
-    }
-    const from = renamedFrom.get(key);
-    if (from !== undefined) {
-      push(context, "renamed", "declared", true, {
-        key: join(key),
-        from: join(from)
-      });
-      diffField(context, previous[from], is, join(key));
-      continue;
-    }
-    if (was === undefined) {
-      if (is.optional) {
-        push(context, "added-optional", "automatic", true, { key: join(key) });
-      } else {
-        const satisfied = "fill" in is || context.stepped;
-        push(context, "added-required", "declared", satisfied, {
-          key: join(key),
-          ...satisfied ? {} : {
-            detail: `Needs a fill (.with({ fill })) or ${STEP} that sets it.`
-          }
-        });
-      }
-      continue;
-    }
-    diffField(context, was, is, join(key));
-  }
-}
-function diffField(context, was, is, key) {
-  const compared = compareSchemas(was.schema, is.schema);
-  if (compared === "type-changed") {
-    push(context, "type-changed", "declared", context.stepped, {
-      key,
-      ...context.stepped ? {} : { detail: `Needs ${STEP} that converts the stored values.` }
-    });
-  } else if (compared === "tightened") {
-    const satisfied = context.stepped || "fill" in is;
-    push(context, "tightened", "declared", satisfied, {
-      key,
-      detail: satisfied ? "Run app.migrate({ mode: 'check' }) to list the rows that violate it." : `Needs ${STEP} or a fill; app.migrate({ mode: 'check' }) lists the rows that violate it.`
-    });
-  } else if (compared === "loosened") {
-    push(context, "loosened", "automatic", true, { key });
-  } else if (compared === "metadata") {
-    push(context, "metadata", "automatic", true, { key });
-  }
-  if (was.optional && !is.optional) {
-    const satisfied = context.stepped || "fill" in is;
-    push(context, "made-required", "declared", satisfied, {
-      key,
-      ...satisfied ? {} : {
-        detail: `Needs a fill (.with({ fill })) or ${STEP} for the rows without it.`
-      }
-    });
-  } else if (!was.optional && is.optional) {
-    push(context, "made-optional", "automatic", true, { key });
-  }
-  if (!was.unique && is.unique) {
-    push(context, "unique-added", "check", true, {
-      key,
-      detail: "Run app.migrate({ mode: 'check' }) and look for duplicates before it is enforced."
-    });
-  } else if (was.unique && !is.unique) {
-    push(context, "unique-removed", "automatic", true, { key });
-  }
-  if (was.fields !== undefined || is.fields !== undefined) {
-    diffFields(context, was.fields ?? {}, is.fields ?? {}, key);
-  }
-}
-function diffEntity(entity, from, to, changes) {
-  const stepped = to.schemaVersion > from.schemaVersion && (to.upgrade ?? []).some((version) => version > from.schemaVersion && version <= to.schemaVersion);
-  const context = { entity, from, to, stepped, changes };
-  diffFields(context, from.fields, to.fields, "");
-}
-function diffSchemas2(lock, current) {
-  const changes = [];
-  const claimed = new Set;
-  for (const name of Object.keys(current.entities).sort()) {
-    const to = current.entities[name];
-    let from = lock.entities[name];
-    if (from === undefined) {
-      const previous = to.previousNames.find((old) => lock.entities[old] !== undefined && !current.entities[old]);
-      if (previous === undefined) {
-        changes.push({
-          entity: name,
-          change: "entity-added",
-          class: "automatic",
-          satisfied: true,
-          destructive: false
-        });
-        continue;
-      }
-      claimed.add(previous);
-      from = lock.entities[previous];
-      changes.push({
-        entity: name,
-        change: "entity-renamed",
-        class: "declared",
-        satisfied: true,
-        destructive: true,
-        from: previous,
-        detail: "app.migrate moves its rows; it removes them from the previous name only with destructive: true."
-      });
-    }
-    diffEntity(name, from, to, changes);
-  }
-  for (const name of Object.keys(lock.entities).sort()) {
-    if (current.entities[name] !== undefined || claimed.has(name))
-      continue;
-    changes.push({
-      entity: name,
-      change: "entity-removed",
-      class: "declared",
-      satisfied: false,
-      destructive: true,
-      detail: `No entity is named "${name}": list it in the previousNames of the entity that replaces it, or remove it from the lock if it is gone.`
-    });
-  }
-  return changes;
-}
-function schemaLockProblemsOf2(lock, current) {
-  const problems = [];
-  const renamed = new Map;
-  for (const [name, entity] of Object.entries(current.entities)) {
-    for (const old of entity.previousNames) {
-      if (!renamed.has(old))
-        renamed.set(old, name);
-    }
-  }
-  for (const name of Object.keys(lock.entities).sort()) {
-    const locked = lock.entities[name];
-    const now = current.entities[name] === undefined ? renamed.get(name) : name;
-    const entity = now === undefined ? undefined : current.entities[now];
-    if (entity === undefined) {
-      problems.push(`The lock holds the entity "${name}", which no entity is named or lists in previousNames.`);
-    } else if (entity.schemaVersion < locked.schemaVersion) {
-      problems.push(`The schemaVersion of "${now}" (${entity.schemaVersion}) is lower than the lock's (${locked.schemaVersion}).`);
-    }
-  }
-  return problems;
-}
-
-// src/core/output/status.ts
-var INVALID_INPUT = new Set([
-  "InvalidUseCaseInput",
-  "InvalidUseCaseContext",
-  "InvalidCommandContext"
-]);
-var CONFIGURATION = new Set(["InvalidCommandEnvironment"]);
-var NOT_FOUND = new Set([
-  "RepositoryEntityNotFound",
-  "UnknownCommandOperation",
-  "UseCaseEntityNotFound"
-]);
-var CONFLICT = new Set([
-  "RepositoryUniqueViolation",
-  "RepositoryConcurrencyConflict",
-  "UseCaseEntityConflict"
-]);
-function raisedOf(error) {
-  let raised = error;
-  for (let current = error.cause;current instanceof Exception2; current = current.cause) {
-    if (current.name === error.name)
-      raised = current;
-  }
-  return raised;
-}
-function statusOf2(error, operation, statuses) {
-  if (!(error instanceof Exception2))
-    return 500;
-  const { name } = error;
-  if (statuses && Object.hasOwn(statuses, name))
-    return statuses[name];
-  if (INVALID_INPUT.has(name))
-    return 400;
-  if (CONFIGURATION.has(name))
-    return 500;
-  if (Array.isArray(raisedOf(error).details?.issues)) {
-    return 400;
-  }
-  if (NOT_FOUND.has(name))
-    return 404;
-  if (CONFLICT.has(name))
-    return 409;
-  if (name === "UseCaseInvalidCredentials" || name === "Unauthenticated") {
-    return 401;
-  }
-  if (name === "Forbidden")
-    return 403;
-  if (operation?.errors.some((Declared) => error.is(Declared) || Declared.name === name)) {
-    return 422;
-  }
-  return 500;
-}
-
-// src/core/output/problem.ts
-var PROBLEM_MEDIA_TYPE2 = "application/problem+json";
-var INTERNAL = "Internal error.";
-function problemOf2(error, options) {
-  const { status, debug = false } = options;
-  const exception = error instanceof Exception2 ? error : undefined;
-  const title = exception?.name ?? "UnexpectedError";
-  const message = exception?.message ?? (error instanceof Error ? error.message : String(error));
-  const raised = exception && raisedOf(exception);
-  const rawIssues = raised?.details?.issues;
-  const issues = status === 400 && Array.isArray(rawIssues) ? rawIssues.map((issue) => ({
-    path: [...issue.path],
-    code: issue.code,
-    message: issue.message
-  })) : undefined;
-  return {
-    type: `urn:afora:exception:${title}`,
-    title,
-    status,
-    detail: status >= 500 && !debug ? INTERNAL : message,
-    ...raised ? { layer: raised.layer } : {},
-    ...issues ? { issues } : {},
-    ...debug ? { trace: exception ? exception.toString() : String(error) } : {}
-  };
-}
-function outputValueOf2(value) {
-  const text = JSON.stringify(value);
-  return text === undefined ? undefined : JSON.parse(text);
-}
-
-// src/core/output/openapi-sink.ts
-var METHODS = ["get", "post", "put", "patch", "delete"];
-var SUCCESS_STATUSES = [200, 201, 202, 204];
-var REQUEST_ID_HEADER = "x-request-id";
-function isObject2(value) {
+  parametersOfPath
+} from "../use-case/route.js";
+import { InvalidOutputStage } from "./exceptions.js";
+import { PROBLEM_MEDIA_TYPE } from "./problem.js";
+import { sinkOf } from "./stage.js";
+import { statusOf } from "./status.js";
+const METHODS = ["get", "post", "put", "patch", "delete"];
+const SUCCESS_STATUSES = [200, 201, 202, 204];
+const REQUEST_ID_HEADER = "x-request-id";
+function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function onlyKeys(value, allowed, where) {
@@ -513,7 +31,7 @@ function onlyKeys(value, allowed, where) {
   }
   return;
 }
-var COMPONENT_NAME = /^[A-Za-z0-9._-]+$/;
+const COMPONENT_NAME = /^[A-Za-z0-9._-]+$/;
 function isHeaderValue(value) {
   if (typeof value !== "string")
     return false;
@@ -527,7 +45,7 @@ function isHeaderValue(value) {
 function isScopes(value) {
   return value === undefined || Array.isArray(value) && value.every((scope) => typeof scope === "string" && scope !== "");
 }
-var SCHEME_KEYS = {
+const SCHEME_KEYS = {
   http: ["scheme", "bearerFormat"],
   apiKey: ["name", "in"],
   oauth2: ["flows"],
@@ -535,7 +53,7 @@ var SCHEME_KEYS = {
   mutualTLS: []
 };
 function schemeIssue(scheme, where) {
-  if (!isObject2(scheme) || typeof scheme.type !== "string") {
+  if (!isObject(scheme) || typeof scheme.type !== "string") {
     return `Expected ${where} to be a security scheme with a "type".`;
   }
   const keys = Object.hasOwn(SCHEME_KEYS, scheme.type) ? SCHEME_KEYS[scheme.type] : undefined;
@@ -566,7 +84,7 @@ function schemeIssue(scheme, where) {
       }
       return;
     case "oauth2":
-      return isObject2(scheme.flows) ? undefined : `Expected ${where}.flows to be an object.`;
+      return isObject(scheme.flows) ? undefined : `Expected ${where}.flows to be an object.`;
     case "openIdConnect":
       return typeof scheme.openIdConnectUrl === "string" && scheme.openIdConnectUrl ? undefined : `Expected ${where}.openIdConnectUrl to be a URL.`;
     default:
@@ -574,7 +92,7 @@ function schemeIssue(scheme, where) {
   }
 }
 function requirementIssue(requirement, schemes, where) {
-  if (!isObject2(requirement) || onlyKeys(requirement, ["scheme", "scopes"], where) || typeof requirement.scheme !== "string" || !isScopes(requirement.scopes)) {
+  if (!isObject(requirement) || onlyKeys(requirement, ["scheme", "scopes"], where) || typeof requirement.scheme !== "string" || !isScopes(requirement.scopes)) {
     return `Expected ${where} to be { scheme, scopes? }.`;
   }
   if (!Object.hasOwn(schemes, requirement.scheme)) {
@@ -583,13 +101,13 @@ function requirementIssue(requirement, schemes, where) {
   return;
 }
 function securityIssue(security, where) {
-  if (!isObject2(security))
+  if (!isObject(security))
     return `Expected ${where} to be an object.`;
   const bad = onlyKeys(security, ["schemes", "operations", "default"], where);
   if (bad)
     return bad;
   const { schemes, operations } = security;
-  if (!isObject2(schemes))
+  if (!isObject(schemes))
     return `Expected ${where}.schemes to be an object.`;
   for (const [name, scheme] of Object.entries(schemes)) {
     if (!COMPONENT_NAME.test(name)) {
@@ -600,7 +118,7 @@ function securityIssue(security, where) {
       return schemeBad;
   }
   if (operations !== undefined) {
-    if (!isObject2(operations)) {
+    if (!isObject(operations)) {
       return `Expected ${where}.operations to be an object.`;
     }
     for (const [id, requirement] of Object.entries(operations)) {
@@ -616,30 +134,30 @@ function securityIssue(security, where) {
   }
   return;
 }
-var ROUTE_OPTION_KEYS2 = [
+export const ROUTE_OPTION_KEYS = [
   "basePath",
   "route",
   "responses",
   "requestId",
   "security"
 ];
-function routeOptionsIssue2(options, where) {
+export function routeOptionsIssue(options, where) {
   const { basePath, route, responses, requestId, security } = options;
-  if (basePath !== undefined && (typeof basePath !== "string" || basePath !== "" && !isRoutePath(basePath, false))) {
+  if (basePath !== undefined && (typeof basePath !== "string" || basePath !== "" && !isPath(basePath, false))) {
     return `Expected ${where}.basePath to be "" or a path such as "/api".`;
   }
   if (route !== undefined) {
-    if (!isObject2(route))
+    if (!isObject(route))
       return `Expected ${where}.route to be an object.`;
     for (const [id, entry] of Object.entries(route)) {
-      if (!isObject2(entry) || onlyKeys(entry, ["method", "path", "status"], "route")) {
+      if (!isObject(entry) || onlyKeys(entry, ["method", "path", "status"], "route")) {
         return `Expected ${where}.route["${id}"] to be { method?, path?, status? }.`;
       }
       if (entry.method !== undefined && !METHODS.includes(entry.method)) {
         return `Expected ${where}.route["${id}"].method to be one of ${METHODS.join(", ")}.`;
       }
       if (entry.path !== undefined) {
-        if (!isRoutePath(entry.path)) {
+        if (!isPath(entry.path)) {
           return `Expected ${where}.route["${id}"].path to start with "/", with parameters only as whole "{name}" segments and no query.`;
         }
         const names = parametersOfPath(entry.path);
@@ -653,12 +171,12 @@ function routeOptionsIssue2(options, where) {
     }
   }
   if (responses !== undefined) {
-    if (!isObject2(responses)) {
+    if (!isObject(responses)) {
       return `Expected ${where}.responses to be an object.`;
     }
     for (const [id, entry] of Object.entries(responses)) {
       const at = `${where}.responses["${id}"]`;
-      if (!isObject2(entry) || onlyKeys(entry, ["headers"], at) || entry.headers !== undefined && !isObject2(entry.headers)) {
+      if (!isObject(entry) || onlyKeys(entry, ["headers"], at) || entry.headers !== undefined && !isObject(entry.headers)) {
         return `Expected ${at} to be { headers?: { name: value } }.`;
       }
       for (const [name, value] of Object.entries(entry.headers ?? {})) {
@@ -682,15 +200,15 @@ function routeOptionsIssue2(options, where) {
   }
   return;
 }
-function requestIdHeaderOf2(options) {
+export function requestIdHeaderOf(options) {
   return options.requestId === true ? REQUEST_ID_HEADER : options.requestId ?? undefined;
 }
 function validate(options) {
-  const bad = onlyKeys(options, ["info", "servers", ...ROUTE_OPTION_KEYS2], "openapi");
+  const bad = onlyKeys(options, ["info", "servers", ...ROUTE_OPTION_KEYS], "openapi");
   if (bad)
     return bad;
   const { info, servers } = options;
-  if (!isObject2(info))
+  if (!isObject(info))
     return "Expected openapi.info to be an object.";
   const infoBad = onlyKeys(info, ["title", "version", "description"], "info");
   if (infoBad)
@@ -707,23 +225,23 @@ function validate(options) {
     if (!Array.isArray(servers))
       return "Expected openapi.servers to be a list.";
     for (const server of servers) {
-      if (!isObject2(server) || typeof server.url !== "string" || !server.url || server.description !== undefined && typeof server.description !== "string" || onlyKeys(server, ["url", "description"], "server")) {
+      if (!isObject(server) || typeof server.url !== "string" || !server.url || server.description !== undefined && typeof server.description !== "string" || onlyKeys(server, ["url", "description"], "server")) {
         return "Expected each openapi.servers entry to be { url, description? }.";
       }
     }
   }
-  return routeOptionsIssue2(options, "openapi");
+  return routeOptionsIssue(options, "openapi");
 }
 function invalid(reason, source = "openapi") {
-  throw new InvalidOutputStage2({ source, details: { reason } });
+  throw new InvalidOutputStage({ source, details: { reason } });
 }
 function kebab(text) {
   return text.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function isScalarKey2(operation, name) {
-  return isScalarKey(operation.input, name);
+function isScalarKey(operation, name) {
+  return isScalarInputKey(operation.input, name);
 }
-function operationRoutes2(operations, options, source = "openapi") {
+export function operationRoutes(operations, options, source = "openapi") {
   const base = options.basePath ?? "";
   const route = options.route ?? {};
   const responses = options.responses ?? {};
@@ -751,7 +269,7 @@ function operationRoutes2(operations, options, source = "openapi") {
     const requestHeaders = declared?.headers ?? {};
     const cookies = declared?.cookie ?? {};
     for (const name of parameters) {
-      if (!isScalarKey2(operation, name)) {
+      if (!isScalarKey(operation, name)) {
         invalid(`${source}.route["${operation.id}"].path has the parameter "{${name}}", which is not a scalar key of the input of ${operation.id}.`, source);
       }
       if (query.includes(name) || Object.hasOwn(requestHeaders, name) || Object.hasOwn(cookies, name)) {
@@ -833,11 +351,11 @@ function problemSchema() {
     required: ["type", "title", "status", "detail"]
   };
 }
-var PROBLEM_REF = "#/components/schemas/Problem";
-var problemContent = {
-  [PROBLEM_MEDIA_TYPE2]: { schema: { $ref: PROBLEM_REF } }
+const PROBLEM_REF = "#/components/schemas/Problem";
+const problemContent = {
+  [PROBLEM_MEDIA_TYPE]: { schema: { $ref: PROBLEM_REF } }
 };
-var STATUS_TEXT = {
+const STATUS_TEXT = {
   400: "Invalid input or context.",
   401: "Authentication is required.",
   403: "The caller may not do this.",
@@ -846,7 +364,7 @@ var STATUS_TEXT = {
   422: "Declared error of the operation.",
   500: "Internal error."
 };
-var SUCCESS_TEXT = {
+const SUCCESS_TEXT = {
   200: "Success.",
   201: "Created.",
   202: "Accepted.",
@@ -864,13 +382,13 @@ function responsesOf(operation, statuses, response, route, requestIdHeader) {
       names.set(403, []);
   }
   for (const Declared of operation.errors) {
-    const synthetic = new Exception2({
-      layer: "use-case" /* UseCase */,
+    const synthetic = new Exception({
+      layer: ExceptionLayers.UseCase,
       name: Declared.name,
       source: "openapi",
       message: Declared.name
     });
-    const status = statusOf2(synthetic, operation, statuses);
+    const status = statusOf(synthetic, operation, statuses);
     const list = names.get(status) ?? [];
     if (!list.includes(Declared.name))
       list.push(Declared.name);
@@ -948,12 +466,12 @@ function withoutKeys(schema, keys) {
 function requirementOf(requirement) {
   return { [requirement.scheme]: [...requirement.scopes ?? []] };
 }
-var openapi2 = sinkOf2({
+export const openapi = sinkOf({
   name: "openapi",
   validate,
   build: (operations, options, { output }) => {
-    const routes = operationRoutes2(operations, options);
-    const requestIdHeader = requestIdHeaderOf2(options);
+    const routes = operationRoutes(operations, options);
+    const requestIdHeader = requestIdHeaderOf(options);
     const security = options.security;
     const records = new Set;
     for (const operation of operations) {
@@ -963,7 +481,7 @@ var openapi2 = sinkOf2({
     const models = {};
     const classes = new Map;
     for (const record of records) {
-      const name = recordNameOf2(record);
+      const name = recordNameOf(record);
       if (!COMPONENT_NAME.test(name) || name === "Problem") {
         invalid(`The record class "${name}" cannot be a component name; give the class a name that is not "Problem".`);
       }
@@ -977,7 +495,7 @@ var openapi2 = sinkOf2({
       models[`${operation.id}#input`] = operation.input;
       models[`${operation.id}#response`] = operation.response;
     }
-    const { schemas } = toOpenAPI2(models);
+    const { schemas } = toOpenAPI(models);
     const paths = {};
     const operationIds = new Set;
     const components = {};
@@ -1051,5 +569,3 @@ var openapi2 = sinkOf2({
     };
   }
 });
-
-export { schemaLockOf2, diffSchemas2, schemaLockProblemsOf2, statusOf2, PROBLEM_MEDIA_TYPE2, problemOf2, outputValueOf2, ROUTE_OPTION_KEYS2, routeOptionsIssue2, requestIdHeaderOf2, operationRoutes2, openapi2 };