@afora/core 0.0.7 → 0.0.9

package/dist/index-hg1z2s2v.js

@@ -0,0 +1,1055 @@
+import {
+  isProperty,
+  isBlueprint,
+  recordFieldOf,
+  Exception2,
+  isBlueprintVariant,
+  recordNameOf2,
+  isBlueprintList,
+  toOpenAPI2,
+  HEADER_NAME,
+  isRoutePath,
+  parametersOfPath,
+  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) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function onlyKeys(value, allowed, where) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key))
+      return `${where} has no option "${key}".`;
+  }
+  return;
+}
+var COMPONENT_NAME = /^[A-Za-z0-9._-]+$/;
+function isHeaderValue(value) {
+  if (typeof value !== "string")
+    return false;
+  for (let i = 0;i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 32 && code !== 9 || code === 127)
+      return false;
+  }
+  return true;
+}
+function isScopes(value) {
+  return value === undefined || Array.isArray(value) && value.every((scope) => typeof scope === "string" && scope !== "");
+}
+var SCHEME_KEYS = {
+  http: ["scheme", "bearerFormat"],
+  apiKey: ["name", "in"],
+  oauth2: ["flows"],
+  openIdConnect: ["openIdConnectUrl"],
+  mutualTLS: []
+};
+function schemeIssue(scheme, where) {
+  if (!isObject2(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;
+  if (!keys) {
+    return `Expected ${where}.type to be one of ${Object.keys(SCHEME_KEYS).join(", ")}.`;
+  }
+  const bad = onlyKeys(scheme, ["type", "description", ...keys], where);
+  if (bad)
+    return bad;
+  if (scheme.description !== undefined && typeof scheme.description !== "string") {
+    return `Expected ${where}.description to be a string.`;
+  }
+  switch (scheme.type) {
+    case "http":
+      if (typeof scheme.scheme !== "string" || !scheme.scheme) {
+        return `Expected ${where}.scheme to be a scheme such as "bearer".`;
+      }
+      if (scheme.bearerFormat !== undefined && typeof scheme.bearerFormat !== "string") {
+        return `Expected ${where}.bearerFormat to be a string.`;
+      }
+      return;
+    case "apiKey":
+      if (typeof scheme.name !== "string" || !scheme.name) {
+        return `Expected ${where}.name to be a non-empty string.`;
+      }
+      if (!["header", "query", "cookie"].includes(scheme.in)) {
+        return `Expected ${where}.in to be "header", "query" or "cookie".`;
+      }
+      return;
+    case "oauth2":
+      return isObject2(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:
+      return;
+  }
+}
+function requirementIssue(requirement, schemes, where) {
+  if (!isObject2(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)) {
+    return `${where}.scheme names the unknown security scheme "${requirement.scheme}".`;
+  }
+  return;
+}
+function securityIssue(security, where) {
+  if (!isObject2(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))
+    return `Expected ${where}.schemes to be an object.`;
+  for (const [name, scheme] of Object.entries(schemes)) {
+    if (!COMPONENT_NAME.test(name)) {
+      return `Expected the security scheme "${name}" to be named with letters, digits, ".", "_" or "-".`;
+    }
+    const schemeBad = schemeIssue(scheme, `${where}.schemes["${name}"]`);
+    if (schemeBad)
+      return schemeBad;
+  }
+  if (operations !== undefined) {
+    if (!isObject2(operations)) {
+      return `Expected ${where}.operations to be an object.`;
+    }
+    for (const [id, requirement] of Object.entries(operations)) {
+      if (requirement === false)
+        continue;
+      const requirementBad = requirementIssue(requirement, schemes, `${where}.operations["${id}"]`);
+      if (requirementBad)
+        return requirementBad;
+    }
+  }
+  if (security.default !== undefined) {
+    return requirementIssue(security.default, schemes, `${where}.default`);
+  }
+  return;
+}
+var ROUTE_OPTION_KEYS2 = [
+  "basePath",
+  "route",
+  "responses",
+  "requestId",
+  "security"
+];
+function routeOptionsIssue2(options, where) {
+  const { basePath, route, responses, requestId, security } = options;
+  if (basePath !== undefined && (typeof basePath !== "string" || basePath !== "" && !isRoutePath(basePath, false))) {
+    return `Expected ${where}.basePath to be "" or a path such as "/api".`;
+  }
+  if (route !== undefined) {
+    if (!isObject2(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")) {
+        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)) {
+          return `Expected ${where}.route["${id}"].path to start with "/", with parameters only as whole "{name}" segments and no query.`;
+        }
+        const names = parametersOfPath(entry.path);
+        if (new Set(names).size !== names.length) {
+          return `Expected ${where}.route["${id}"].path to name each parameter once.`;
+        }
+      }
+      if (entry.status !== undefined && !SUCCESS_STATUSES.includes(entry.status)) {
+        return `Expected ${where}.route["${id}"].status to be one of ${SUCCESS_STATUSES.join(", ")}.`;
+      }
+    }
+  }
+  if (responses !== undefined) {
+    if (!isObject2(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)) {
+        return `Expected ${at} to be { headers?: { name: value } }.`;
+      }
+      for (const [name, value] of Object.entries(entry.headers ?? {})) {
+        if (!HEADER_NAME.test(name)) {
+          return `Expected ${at}.headers to be named by header names, not "${name}".`;
+        }
+        if (name.toLowerCase() === "content-type") {
+          return `${at}.headers cannot set "content-type": the sink sets it.`;
+        }
+        if (!isHeaderValue(value)) {
+          return `Expected ${at}.headers["${name}"] to be text without line breaks.`;
+        }
+      }
+    }
+  }
+  if (requestId !== undefined && requestId !== true && (typeof requestId !== "string" || !HEADER_NAME.test(requestId))) {
+    return `Expected ${where}.requestId to be true or a header name.`;
+  }
+  if (security !== undefined) {
+    return securityIssue(security, `${where}.security`);
+  }
+  return;
+}
+function requestIdHeaderOf2(options) {
+  return options.requestId === true ? REQUEST_ID_HEADER : options.requestId ?? undefined;
+}
+function validate(options) {
+  const bad = onlyKeys(options, ["info", "servers", ...ROUTE_OPTION_KEYS2], "openapi");
+  if (bad)
+    return bad;
+  const { info, servers } = options;
+  if (!isObject2(info))
+    return "Expected openapi.info to be an object.";
+  const infoBad = onlyKeys(info, ["title", "version", "description"], "info");
+  if (infoBad)
+    return infoBad;
+  for (const key of ["title", "version"]) {
+    if (typeof info[key] !== "string" || !info[key]) {
+      return `Expected openapi.info.${key} to be a non-empty string.`;
+    }
+  }
+  if (info.description !== undefined && typeof info.description !== "string") {
+    return "Expected openapi.info.description to be a string.";
+  }
+  if (servers !== undefined) {
+    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")) {
+        return "Expected each openapi.servers entry to be { url, description? }.";
+      }
+    }
+  }
+  return routeOptionsIssue2(options, "openapi");
+}
+function invalid(reason, source = "openapi") {
+  throw new InvalidOutputStage2({ 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 operationRoutes2(operations, options, source = "openapi") {
+  const base = options.basePath ?? "";
+  const route = options.route ?? {};
+  const responses = options.responses ?? {};
+  const ids = new Set(operations.map(({ id }) => id));
+  for (const [where, entries] of [
+    ["route", route],
+    ["responses", responses],
+    ["security.operations", options.security?.operations ?? {}]
+  ]) {
+    for (const id of Object.keys(entries)) {
+      if (!ids.has(id)) {
+        invalid(`${source}.${where} names the unknown operation "${id}".`, source);
+      }
+    }
+  }
+  const routes = new Map;
+  const taken = new Map;
+  for (const operation of operations) {
+    const chosen = route[operation.id] ?? {};
+    const declared = operation.route;
+    const method = chosen.method ?? declared?.method ?? "post";
+    const path = base + (chosen.path ?? declared?.path ?? `/${kebab(operation.command)}/${kebab(operation.name)}`);
+    const parameters = parametersOfPath(path);
+    const query = declared?.query ?? [];
+    const requestHeaders = declared?.headers ?? {};
+    const cookies = declared?.cookie ?? {};
+    for (const name of parameters) {
+      if (!isScalarKey2(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)) {
+        invalid(`${source}.route["${operation.id}"].path has the parameter "{${name}}", which the route of ${operation.useCase} reads from another place.`, source);
+      }
+    }
+    const key = `${method} ${path.replace(/\{[^}]*\}/g, "{}")}`;
+    const other = taken.get(key);
+    if (other !== undefined) {
+      invalid(`Two operations are routed to ${method.toUpperCase()} ${path}: ${other} and ${operation.id}. Give one another route, on its use case or in ${source}.route["${operation.id}"].`, source);
+    }
+    taken.set(key, operation.id);
+    routes.set(operation.id, {
+      method,
+      path,
+      parameters,
+      status: chosen.status ?? declared?.status ?? 200,
+      headers: { ...responses[operation.id]?.headers ?? {} },
+      body: method !== "get" && method !== "delete",
+      query,
+      requestHeaders,
+      cookies,
+      setCookies: declared?.setCookie ?? {}
+    });
+  }
+  return routes;
+}
+function collectRecords(properties, found) {
+  const visit = (field) => {
+    if (isBlueprintList(field)) {
+      visit(field.item);
+      return;
+    }
+    if (isBlueprint(field)) {
+      collectRecords(field.properties, found);
+      return;
+    }
+    if (isBlueprintVariant(field)) {
+      for (const variant of Object.values(field.variants)) {
+        visit(variant);
+      }
+      return;
+    }
+    const record = recordFieldOf(field)?.record;
+    if (record && !found.has(record)) {
+      found.add(record);
+      collectRecords(record.blueprint.properties, found);
+    }
+  };
+  for (const field of Object.values(properties))
+    visit(field);
+}
+function problemSchema() {
+  return {
+    type: "object",
+    properties: {
+      type: { type: "string" },
+      title: { type: "string" },
+      status: { type: "integer" },
+      detail: { type: "string" },
+      layer: { type: "string" },
+      issues: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            path: {
+              type: "array",
+              items: { type: ["string", "integer"] }
+            },
+            code: { type: "string" },
+            message: { type: "string" }
+          },
+          required: ["path", "code", "message"]
+        }
+      },
+      trace: { type: "string" }
+    },
+    required: ["type", "title", "status", "detail"]
+  };
+}
+var PROBLEM_REF = "#/components/schemas/Problem";
+var problemContent = {
+  [PROBLEM_MEDIA_TYPE2]: { schema: { $ref: PROBLEM_REF } }
+};
+var STATUS_TEXT = {
+  400: "Invalid input or context.",
+  401: "Authentication is required.",
+  403: "The caller may not do this.",
+  404: "Not found.",
+  409: "Conflict.",
+  422: "Declared error of the operation.",
+  500: "Internal error."
+};
+var SUCCESS_TEXT = {
+  200: "Success.",
+  201: "Created.",
+  202: "Accepted.",
+  204: "No content."
+};
+function responsesOf(operation, statuses, response, route, requestIdHeader) {
+  const names = new Map([
+    [400, []],
+    [500, []]
+  ]);
+  const access = operation.access;
+  if (access && access.public !== true) {
+    names.set(401, []);
+    if ((access.scopes?.length ?? 0) > 0 || access.owner)
+      names.set(403, []);
+  }
+  for (const Declared of operation.errors) {
+    const synthetic = new Exception2({
+      layer: "use-case" /* UseCase */,
+      name: Declared.name,
+      source: "openapi",
+      message: Declared.name
+    });
+    const status = statusOf2(synthetic, operation, statuses);
+    const list = names.get(status) ?? [];
+    if (!list.includes(Declared.name))
+      list.push(Declared.name);
+    names.set(status, list);
+  }
+  const idHeaders = requestIdHeader ? {
+    [requestIdHeader]: {
+      description: "The id of the request: the one it sent in this header, else a new one.",
+      schema: { type: "string" }
+    }
+  } : {};
+  const successHeaders = { ...idHeaders };
+  const setCookies = Object.values(route.setCookies);
+  if (setCookies.length > 0) {
+    successHeaders["set-cookie"] = {
+      description: `Sets ${setCookies.map(({ name }) => `\`${name}\``).join(", ")}.`,
+      schema: { type: "string" }
+    };
+  }
+  for (const [name, value] of Object.entries(route.headers)) {
+    successHeaders[name] = { schema: { type: "string", const: value } };
+  }
+  const withHeaders = (headers) => Object.keys(headers).length > 0 ? { headers } : {};
+  const responses = {
+    [String(route.status)]: {
+      description: SUCCESS_TEXT[route.status],
+      ...withHeaders(successHeaders),
+      ...route.status === 204 ? {} : { content: { "application/json": { schema: response } } }
+    }
+  };
+  for (const status of [...names.keys()].sort((a, b) => a - b)) {
+    const declared = names.get(status) ?? [];
+    const text = STATUS_TEXT[status] ?? `Error ${status}.`;
+    responses[String(status)] = {
+      description: declared.length > 0 ? `${text} Declared: ${declared.join(", ")}.` : text,
+      ...withHeaders(idHeaders),
+      content: problemContent
+    };
+  }
+  return responses;
+}
+function parameterOf(name, property, where, required) {
+  const { description, ...rest } = property;
+  return {
+    name,
+    in: where,
+    required: where === "path" || required,
+    ...typeof description === "string" ? { description } : {},
+    schema: rest
+  };
+}
+function queryParametersOf(operation, schema) {
+  const required = new Set(schema.required ?? []);
+  return Object.entries(schema.properties ?? {}).map(([name, property]) => {
+    if (!isProperty(operation.input.properties[name]) || !isScalarSchema(property)) {
+      invalid(`${operation.id} uses a get/delete route, whose input becomes query parameters, but "${name}" is not a scalar; route it with method "post".`);
+    }
+    return parameterOf(name, property, "query", required.has(name));
+  });
+}
+function withoutKeys(schema, keys) {
+  if (keys.length === 0)
+    return schema;
+  const properties = { ...schema.properties ?? {} };
+  for (const key of keys)
+    delete properties[key];
+  const required = (schema.required ?? []).filter((key) => !keys.includes(key));
+  const { required: _, ...rest } = schema;
+  return {
+    ...rest,
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function requirementOf(requirement) {
+  return { [requirement.scheme]: [...requirement.scopes ?? []] };
+}
+var openapi2 = sinkOf2({
+  name: "openapi",
+  validate,
+  build: (operations, options, { output }) => {
+    const routes = operationRoutes2(operations, options);
+    const requestIdHeader = requestIdHeaderOf2(options);
+    const security = options.security;
+    const records = new Set;
+    for (const operation of operations) {
+      collectRecords(operation.input.properties, records);
+      collectRecords(operation.response.properties, records);
+    }
+    const models = {};
+    const classes = new Map;
+    for (const record of records) {
+      const name = recordNameOf2(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".`);
+      }
+      if (classes.has(name)) {
+        invalid(`Two record classes are named "${name}"; rename one.`);
+      }
+      classes.set(name, record);
+      models[name] = record;
+    }
+    for (const operation of operations) {
+      models[`${operation.id}#input`] = operation.input;
+      models[`${operation.id}#response`] = operation.response;
+    }
+    const { schemas } = toOpenAPI2(models);
+    const paths = {};
+    const operationIds = new Set;
+    const components = {};
+    for (const name of classes.keys())
+      components[name] = schemas[name];
+    components.Problem = problemSchema();
+    for (const operation of operations) {
+      const route = routes.get(operation.id);
+      const { method, path } = route;
+      const operationId = operation.id.replaceAll(".", "_");
+      if (operationIds.has(operationId)) {
+        invalid(`The operationId "${operationId}" is produced twice.`);
+      }
+      operationIds.add(operationId);
+      const slot = paths[path] ?? {};
+      paths[path] = slot;
+      const full = schemas[`${operation.id}#input`];
+      const required = new Set(full.required ?? []);
+      const hasBody = route.body;
+      const input = withoutKeys(full, [
+        ...route.parameters,
+        ...hasBody ? route.query : [],
+        ...Object.keys(route.requestHeaders),
+        ...Object.keys(route.cookies)
+      ]);
+      const response = withoutKeys(schemas[`${operation.id}#response`], Object.keys(route.setCookies));
+      const hasInput = Object.keys(input.properties ?? {}).length > 0;
+      const placed = (keys, where) => Object.entries(keys).map(([key, name]) => parameterOf(name, full.properties?.[key], where, required.has(key)));
+      const parameters = [
+        ...route.parameters.map((name) => parameterOf(name, full.properties?.[name], "path", true)),
+        ...hasBody ? route.query.map((name) => parameterOf(name, full.properties?.[name], "query", required.has(name))) : queryParametersOf(operation, input),
+        ...placed(route.requestHeaders, "header"),
+        ...placed(route.cookies, "cookie")
+      ];
+      const explicit = security?.operations?.[operation.id];
+      const access = operation.access;
+      const guarded = access !== undefined && access.public !== true;
+      if (guarded && explicit === false) {
+        invalid(`openapi.security.operations["${operation.id}"] is false, but ${operation.useCase} declares an access that the output enforces.`);
+      }
+      const schemeNames = Object.keys(security?.schemes ?? {});
+      const scheme = security?.default?.scheme ?? (schemeNames.length === 1 ? schemeNames[0] : undefined);
+      const requirement = explicit !== undefined ? explicit : guarded && scheme !== undefined ? { scheme, scopes: access.scopes ?? [] } : access?.public === true && security?.default ? false : undefined;
+      slot[method] = {
+        operationId,
+        summary: operation.id,
+        ...operation.description ? { description: operation.description } : {},
+        ...operation.tags.length > 0 ? { tags: [...operation.tags] } : {},
+        ...operation.deprecated ? { deprecated: true } : {},
+        ...!hasBody || parameters.length > 0 ? { parameters } : {},
+        ...hasBody && hasInput ? {
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: input } }
+          }
+        } : {},
+        responses: responsesOf(operation, output.statuses, response, route, requestIdHeader),
+        ...requirement === false ? { security: [] } : requirement ? { security: [requirementOf(requirement)] } : {}
+      };
+    }
+    return {
+      openapi: "3.1.0",
+      info: options.info,
+      ...options.servers ? { servers: options.servers } : {},
+      ...security?.default ? { security: [requirementOf(security.default)] } : {},
+      paths,
+      components: {
+        schemas: components,
+        ...security ? { securitySchemes: security.schemes } : {}
+      }
+    };
+  }
+});
+
+export { schemaLockOf2, diffSchemas2, schemaLockProblemsOf2, statusOf2, PROBLEM_MEDIA_TYPE2, problemOf2, outputValueOf2, ROUTE_OPTION_KEYS2, routeOptionsIssue2, requestIdHeaderOf2, operationRoutes2, openapi2 };