@afora/core 0.0.9 → 0.0.11

package/dist/core/tracing/tracing.js

@@ -0,0 +1,101 @@
+import { startedApplication } from "../application/registry.js";
+import { Exception, UNEXPECTED_ERROR } from "../exception/exception.js";
+import { InvalidTraceDeclaration } from "./exceptions.js";
+export function checkTracer(value) {
+  if (typeof value !== "object" || value === null || typeof value.startSpan !== "function" || value.withSpan !== undefined && typeof value.withSpan !== "function") {
+    throw new InvalidTraceDeclaration({
+      source: "trace",
+      details: {
+        reason: "Expected `trace` to be a tracer: { startSpan(name, attributes, parent), withSpan? }."
+      }
+    });
+  }
+  return value;
+}
+export const ApplicationTracerKey = Symbol("afora.application.tracer");
+export function resolveTracer(scoped, owner) {
+  return scoped ?? owner?.[ApplicationTracerKey] ?? startedApplication()?.[ApplicationTracerKey];
+}
+export function startSpan(tracer, name, attributes, parent) {
+  try {
+    return tracer.startSpan(name, attributes, parent);
+  } catch {
+    return;
+  }
+}
+export function runInSpan(tracer, span, run) {
+  if (tracer.withSpan === undefined)
+    return run();
+  let ran = "no";
+  let result;
+  let thrown;
+  const once = () => {
+    try {
+      result = run();
+      ran = "returned";
+      return result;
+    } catch (error) {
+      ran = "threw";
+      thrown = error;
+      throw error;
+    }
+  };
+  try {
+    return tracer.withSpan(span, once);
+  } catch {
+    if (ran === "threw")
+      throw thrown;
+    return ran === "returned" ? result : run();
+  }
+}
+const OK = Object.freeze({ "afora.outcome": "ok" });
+export function endSpan(span) {
+  if (span === undefined)
+    return;
+  try {
+    span.end("ok", OK);
+  } catch {}
+}
+export function failSpan(span, error, layer) {
+  if (span === undefined)
+    return;
+  const origin = error instanceof Exception ? error.origin : undefined;
+  const name = origin?.name ?? UNEXPECTED_ERROR;
+  try {
+    span.end("error", {
+      "afora.outcome": "error",
+      "afora.exception.layer": origin?.layer ?? layer,
+      "afora.exception.name": name,
+      "afora.exception.unexpected": name === UNEXPECTED_ERROR
+    });
+  } catch {}
+}
+export function memoryTracer() {
+  const spans = [];
+  const recorded = new WeakMap;
+  return Object.freeze({
+    spans,
+    clear: () => {
+      spans.length = 0;
+    },
+    startSpan(name, attributes, parent) {
+      const span = {
+        name,
+        attributes: { ...attributes },
+        parent: parent === undefined ? undefined : recorded.get(parent),
+        status: undefined
+      };
+      spans.push(span);
+      const handle = {
+        end(status, ended) {
+          if (span.status !== undefined)
+            return;
+          span.status = status;
+          span.attributes = { ...span.attributes, ...ended };
+        }
+      };
+      recorded.set(handle, span);
+      return handle;
+    }
+  });
+}

package/dist/core/use-case/access.js

@@ -0,0 +1,56 @@
+import { isScalarKey } from "./route.js";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const ACCESS_KEYS = ["public", "scopes", "owner", "context"];
+const PRINCIPAL_VALUE = /^(subject|scopes|claims\.[^.]+)$/;
+export function isPublicAccess(access) {
+  return access.public === true;
+}
+export function accessDeclarationOf(access, blueprint) {
+  if (!isObject(access)) {
+    return "Expected access to be { public: true } or { scopes?, owner?, context? }.";
+  }
+  for (const key of Object.keys(access)) {
+    if (!ACCESS_KEYS.includes(key))
+      return `access has no option "${key}".`;
+  }
+  const { scopes, owner, context } = access;
+  if (access.public !== undefined && typeof access.public !== "boolean") {
+    return "Expected access.public to be a boolean.";
+  }
+  if (access.public === true) {
+    if (Object.keys(access).length > 1) {
+      return "access.public leaves no room for scopes, owner or context: anyone may call.";
+    }
+    return Object.freeze({ public: true });
+  }
+  if (scopes !== undefined) {
+    if (!Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string" || scope === "") || new Set(scopes).size !== scopes.length) {
+      return "Expected access.scopes to be distinct, non-empty strings.";
+    }
+  }
+  if (owner !== undefined) {
+    if (!isObject(owner) || Object.keys(owner).some((key) => key !== "input" && key !== "claim") || typeof owner.input !== "string" || owner.claim !== undefined && (typeof owner.claim !== "string" || owner.claim === "")) {
+      return "Expected access.owner to be { input, claim? }.";
+    }
+    if (!isScalarKey(blueprint, owner.input)) {
+      return `access.owner compares "${owner.input}", which is not a scalar key of the input.`;
+    }
+  }
+  if (context !== undefined) {
+    if (!isObject(context)) {
+      return "Expected access.context to map context keys to values of the caller.";
+    }
+    for (const [key, value] of Object.entries(context)) {
+      if (typeof value !== "string" || !PRINCIPAL_VALUE.test(value)) {
+        return `Expected access.context["${key}"] to be "subject", "scopes" or "claims.<name>".`;
+      }
+    }
+  }
+  return Object.freeze({
+    ...scopes === undefined ? {} : { scopes: Object.freeze([...scopes]) },
+    ...owner === undefined ? {} : { owner: Object.freeze({ ...owner }) },
+    ...context === undefined ? {} : { context: Object.freeze({ ...context }) }
+  });
+}

package/dist/core/use-case/decorators.js

@@ -0,0 +1,65 @@
+import { Kind } from "../symbols/kind.js";
+import { accessDeclarationOf } from "./access.js";
+import { routeDeclarationOf } from "./route.js";
+import { InvalidUseCaseDeclaration } from "./use-case.js";
+function sameData(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  const left = Object.keys(a);
+  return left.length === Object.keys(b).length && left.every((key) => Object.hasOwn(b, key) && sameData(a[key], b[key]));
+}
+function decoratedUseCase(value, decorator) {
+  if (typeof value !== "function" || value[Kind] !== "use-case") {
+    throw new InvalidUseCaseDeclaration({
+      source: decorator,
+      details: {
+        reason: `${decorator} decorates a class that extends useCaseOf(...).`
+      }
+    });
+  }
+  return value;
+}
+export function Route(method, pathOrOptions, options) {
+  const settings = typeof pathOrOptions === "string" ? { ...options, method, path: pathOrOptions } : { ...pathOrOptions, method };
+  return (value) => {
+    const UseCase = decoratedUseCase(value, "@Route");
+    const invalid = (reason) => {
+      throw new InvalidUseCaseDeclaration({
+        source: UseCase.useCaseName,
+        details: { reason }
+      });
+    };
+    const declared = routeDeclarationOf(settings, UseCase.blueprint, UseCase.response);
+    if (typeof declared === "string")
+      return invalid(declared);
+    if (UseCase.route !== undefined) {
+      if (sameData(UseCase.route, declared))
+        return;
+      invalid("The use case already has another route: declare it once, with the route setting or with @Route.");
+    }
+    Object.defineProperty(UseCase, "route", { value: declared });
+  };
+}
+export function Access(access) {
+  return (value) => {
+    const UseCase = decoratedUseCase(value, "@Access");
+    const invalid = (reason) => {
+      throw new InvalidUseCaseDeclaration({
+        source: UseCase.useCaseName,
+        details: { reason }
+      });
+    };
+    const declared = accessDeclarationOf(access, UseCase.blueprint);
+    if (typeof declared === "string")
+      return invalid(declared);
+    if (UseCase.access !== undefined) {
+      if (sameData(UseCase.access, declared))
+        return;
+      invalid("The use case already declares another access: declare it once, with the access setting or with @Access.");
+    }
+    Object.defineProperty(UseCase, "access", { value: declared });
+  };
+}

package/dist/core/use-case/exceptions.d.ts

@@ -1,12 +1,16 @@
+import type { Issue } from "../parse/types/parse.interface.js";
 /**
  * A step of a use case is invalid: at declaration (`useCaseOf({ steps })`),
  * or while the steps run (a `change` or `invoke` on something that is not a
- * record or has no such member). `details.index` is the position of the step.
+ * record or has no such member, or `args` that a `run`'s `params` reject).
+ * `details.index` is the position of the step.
  */
 export declare const InvalidUseCaseStep: import("../../index.js").DeclaredExceptionClass<{
     readonly index: number;
     readonly reason: string;
     readonly code?: string;
+    /** The issues of the `args` a `run` gave its `params` (`code: "invalid_args"`). */
+    readonly issues?: readonly Issue[];
 }>;
 /**
  * `useCasePluginOf` or `useCaseCatalogOf` was given what cannot be a plugin

package/dist/core/use-case/exceptions.js

@@ -0,0 +1,48 @@
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import { exceptionOf } from "../exception/exception.js";
+export const InvalidUseCaseStep = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "InvalidUseCaseStep",
+  message: ({
+    index,
+    reason
+  }) => `Invalid step ${index}: ${reason}`
+});
+export const InvalidUseCasePlugin = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "InvalidUseCasePlugin",
+  message: ({ reason }, source) => `Invalid use case plugin "${source}": ${reason}.`
+});
+export const UnknownUseCasePlugin = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UnknownUseCasePlugin",
+  message: ({ name }) => `No use case plugin "${name}" in the catalog.`
+});
+export const IncompatibleUseCasePlugin = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "IncompatibleUseCasePlugin",
+  message: ({ reason }, source) => `Incompatible use case plugin "${source}": ${reason}.`
+});
+export const UseCaseUnavailable = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseUnavailable",
+  message: ({
+    repository,
+    reason
+  }, source) => `The use case "${source}" is not available for "${repository}": ${reason}.`
+});
+export const UseCaseEntityNotFound = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseEntityNotFound",
+  message: "The entity was not found."
+});
+export const UseCaseEntityConflict = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseEntityConflict",
+  message: "The entity already exists."
+});
+export const UseCaseInvalidCredentials = exceptionOf({
+  layer: ExceptionLayers.UseCase,
+  name: "UseCaseInvalidCredentials",
+  message: "Invalid credentials."
+});

package/dist/core/use-case/plugin-catalog.js

@@ -0,0 +1,68 @@
+import { isVersion, satisfies } from "../record/plugin.js";
+import { Kind } from "../symbols/kind.js";
+import {
+  IncompatibleUseCasePlugin,
+  InvalidUseCasePlugin,
+  UnknownUseCasePlugin
+} from "./exceptions.js";
+import { isUseCasePlugin } from "./plugin.js";
+export function isUseCaseCatalog(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "use-case-catalog";
+}
+export function useCaseCatalogOf(...plugins) {
+  const byName = {};
+  const context = {};
+  for (const plugin of plugins) {
+    if (!isUseCasePlugin(plugin)) {
+      throw new InvalidUseCasePlugin({
+        source: "catalog",
+        details: {
+          reason: "a catalog takes plugins made by `useCasePluginOf`"
+        }
+      });
+    }
+    if (Object.hasOwn(byName, plugin.name)) {
+      throw new InvalidUseCasePlugin({
+        source: plugin.name,
+        details: { reason: "the catalog has another plugin with its name" }
+      });
+    }
+    byName[plugin.name] = plugin;
+    context[plugin.name] = plugin.make;
+  }
+  const find = (name) => {
+    const plugin = Object.hasOwn(byName, name) ? byName[name] : undefined;
+    if (!plugin) {
+      throw new UnknownUseCasePlugin({ source: "catalog", details: { name } });
+    }
+    return plugin;
+  };
+  return Object.freeze({
+    [Kind]: "use-case-catalog",
+    plugins: Object.freeze(byName),
+    list: Object.freeze([...plugins]),
+    context: Object.freeze(context),
+    resolve(reference) {
+      const at = typeof reference === "string" ? reference.lastIndexOf("@") : -1;
+      if (at <= 0)
+        return find(String(reference));
+      const plugin = find(reference.slice(0, at));
+      const version = reference.slice(at + 1);
+      if (!isVersion(version)) {
+        throw new IncompatibleUseCasePlugin({
+          source: plugin.name,
+          details: { reason: `"${version}" is not a semantic version` }
+        });
+      }
+      if (!satisfies(plugin.version, version)) {
+        throw new IncompatibleUseCasePlugin({
+          source: plugin.name,
+          details: {
+            reason: `version ${plugin.version} does not satisfy ${version}`
+          }
+        });
+      }
+      return plugin;
+    }
+  });
+}

package/dist/core/use-case/plugin.js

@@ -0,0 +1,133 @@
+import { hasPlugin, isVersion } from "../record/plugin.js";
+import { isRepository } from "../repository/repository.js";
+import { inspectRepository } from "../repository/state.js";
+import { Kind } from "../symbols/kind.js";
+import { InvalidUseCasePlugin, UseCaseUnavailable } from "./exceptions.js";
+import { isPlain } from "./steps/references.js";
+import { useCaseTargetOf } from "./target.js";
+import { useCaseOf } from "./use-case.js";
+const UseCaseOrigin = Symbol("useCaseOrigin");
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const identities = new WeakMap;
+let nextIdentity = 0;
+function keyOf(value) {
+  if (typeof value === "function" || typeof value === "object" && value) {
+    if (Array.isArray(value))
+      return `[${value.map(keyOf).join(",")}]`;
+    if (isPlain(value)) {
+      return `{${Object.keys(value).sort().filter((key) => value[key] !== undefined).map((key) => `${JSON.stringify(key)}:${keyOf(value[key])}`).join(",")}}`;
+    }
+    let identity = identities.get(value);
+    if (identity === undefined) {
+      identity = nextIdentity++;
+      identities.set(value, identity);
+    }
+    return `#${identity}`;
+  }
+  return value === undefined ? "undefined" : JSON.stringify(value);
+}
+export function isUseCasePlugin(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "use-case-plugin";
+}
+export function useCaseOriginOf(UseCase) {
+  return typeof UseCase === "function" ? UseCase[UseCaseOrigin] : undefined;
+}
+export function useCasePluginOf(name, settings) {
+  const source = typeof name === "string" ? name : "useCasePluginOf";
+  const invalid = (reason) => {
+    throw new InvalidUseCasePlugin({ source, details: { reason } });
+  };
+  if (typeof name !== "string" || !NAME.test(name)) {
+    invalid("its name must be an identifier");
+  }
+  if (!isPlain(settings) || typeof settings.compile !== "function") {
+    invalid("it needs a compile function");
+  }
+  const { version = "1.0.0", description, compile } = settings;
+  if (!isVersion(version)) {
+    invalid(`"${String(version)}" is not a semantic version`);
+  }
+  if (description !== undefined && typeof description !== "string") {
+    invalid("its description must be a string");
+  }
+  const names = (list, what) => {
+    if (list === undefined)
+      return Object.freeze([]);
+    if (!Array.isArray(list) || list.some((item) => typeof item !== "string" || item === "")) {
+      invalid(`requires.${what} must be a list of names`);
+    }
+    return Object.freeze([...new Set(list)]);
+  };
+  if (settings.requires !== undefined && !isPlain(settings.requires)) {
+    invalid("requires must be an object of actions and plugins");
+  }
+  const requires = Object.freeze({
+    actions: names(settings.requires?.actions, "actions"),
+    plugins: names(settings.requires?.plugins, "plugins")
+  });
+  const made = new WeakMap;
+  const make = (repository, given) => {
+    if (!isRepository(repository)) {
+      return invalid("it makes a use case for a repository of repositoryOf");
+    }
+    if (given !== undefined && !isPlain(given)) {
+      return invalid("its options must be a plain object");
+    }
+    const options = Object.freeze({ ...given });
+    const info = inspectRepository(repository);
+    let classes = made.get(info.state);
+    if (!classes) {
+      classes = new Map;
+      made.set(info.state, classes);
+    }
+    const key = keyOf(options);
+    const known = classes.get(key);
+    if (known)
+      return known;
+    const target = useCaseTargetOf(repository, name);
+    const missing = {
+      actions: requires.actions.filter((action) => !info.actions.includes(action)),
+      plugins: requires.plugins.filter((plugin) => !hasPlugin(info.entity, plugin))
+    };
+    if (missing.actions.length > 0 || missing.plugins.length > 0) {
+      const quoted = (list) => list.map((item) => `"${item}"`).join(", ");
+      throw new UseCaseUnavailable({
+        source: name,
+        details: {
+          repository: target.repositoryName,
+          reason: [
+            missing.actions.length > 0 ? `the repository lacks the action ${quoted(missing.actions)}` : undefined,
+            missing.plugins.length > 0 ? `the entity lacks the plugin ${quoted(missing.plugins)}` : undefined
+          ].filter(Boolean).join(" and "),
+          missing
+        }
+      });
+    }
+    const UseCase = useCaseOf(compile(target, options));
+    Object.defineProperty(UseCase, UseCaseOrigin, {
+      value: Object.freeze({
+        plugin,
+        repository,
+        options
+      })
+    });
+    classes.set(key, UseCase);
+    return UseCase;
+  };
+  const plugin = Object.freeze({
+    [Kind]: "use-case-plugin",
+    name,
+    version,
+    ...description === undefined ? {} : { description },
+    requires,
+    make,
+    toJSON: () => ({
+      kind: "use-case-plugin",
+      name,
+      version,
+      ...description === undefined ? {} : { description },
+      requires
+    })
+  });
+  return plugin;
+}

package/dist/core/use-case/route.js

@@ -0,0 +1,200 @@
+import { toOpenAPI } from "../openapi/openapi.js";
+import { isProperty } from "../property/is-property.js";
+const ROUTE_METHODS = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete"
+];
+const ROUTE_SUCCESS_STATUSES = [
+  200,
+  201,
+  202,
+  204
+];
+const PARAMETER = /^\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+export const HEADER_NAME = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
+export function isRoutePath(value, parameters = true) {
+  if (typeof value !== "string" || !value.startsWith("/"))
+    return false;
+  return value.split("/").every((segment) => parameters && PARAMETER.test(segment) || !/[{}?#\s:*]/.test(segment));
+}
+export function parametersOfPath(path) {
+  const names = [];
+  for (const segment of path.split("/")) {
+    const name = PARAMETER.exec(segment)?.[1];
+    if (name)
+      names.push(name);
+  }
+  return names;
+}
+export function isScalarSchema(schema) {
+  const types = [schema.type ?? []].flat();
+  return !types.some((type) => type === "object" || type === "array");
+}
+export function isScalarKey(blueprint, name) {
+  if (!Object.hasOwn(blueprint.properties, name))
+    return false;
+  const field = blueprint.properties[name];
+  return isProperty(field) && isScalarSchema(toOpenAPI(field));
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const ROUTE_KEYS = [
+  "method",
+  "path",
+  "status",
+  "query",
+  "headers",
+  "cookie",
+  "setCookie"
+];
+const COOKIE_KEYS = [
+  "name",
+  "httpOnly",
+  "secure",
+  "sameSite",
+  "path",
+  "domain",
+  "maxAge"
+];
+function cookieIssue(cookie, where) {
+  if (!isObject(cookie) || typeof cookie.name !== "string") {
+    return `Expected ${where} to be { name, httpOnly?, secure?, sameSite?, path?, domain?, maxAge? }.`;
+  }
+  for (const key of Object.keys(cookie)) {
+    if (!COOKIE_KEYS.includes(key))
+      return `${where} has no option "${key}".`;
+  }
+  if (!HEADER_NAME.test(cookie.name)) {
+    return `Expected ${where}.name to be the name of a cookie.`;
+  }
+  for (const key of ["httpOnly", "secure"]) {
+    if (cookie[key] !== undefined && typeof cookie[key] !== "boolean") {
+      return `Expected ${where}.${key} to be a boolean.`;
+    }
+  }
+  if (cookie.sameSite !== undefined && !["strict", "lax", "none"].includes(cookie.sameSite)) {
+    return `Expected ${where}.sameSite to be "strict", "lax" or "none".`;
+  }
+  if (cookie.sameSite === "none" && cookie.secure === false) {
+    return `${where}.sameSite "none" needs a secure cookie.`;
+  }
+  for (const key of ["path", "domain"]) {
+    const value = cookie[key];
+    if (value !== undefined && (typeof value !== "string" || value === "" || /[;\s]/.test(value))) {
+      return `Expected ${where}.${key} to be text without ";" or spaces.`;
+    }
+  }
+  if (cookie.maxAge !== undefined && (!Number.isInteger(cookie.maxAge) || cookie.maxAge < 0)) {
+    return `Expected ${where}.maxAge to be a whole number of seconds, 0 or more.`;
+  }
+  return;
+}
+export function routeDeclarationOf(route, blueprint, response) {
+  if (!isObject(route)) {
+    return "Expected route to be { method, path?, status?, query?, headers?, cookie?, setCookie? }.";
+  }
+  for (const key of Object.keys(route)) {
+    if (!ROUTE_KEYS.includes(key))
+      return `route has no option "${key}".`;
+  }
+  const method = typeof route.method === "string" ? route.method.toLowerCase() : undefined;
+  if (!ROUTE_METHODS.includes(method)) {
+    return `Expected route.method to be one of ${ROUTE_METHODS.join(", ")}.`;
+  }
+  const { path, status, query, headers, cookie, setCookie } = route;
+  const places = new Map;
+  const place = (key, where) => {
+    const taken = places.get(key);
+    if (taken !== undefined) {
+      return `route reads the input key "${key}" from two places: ${taken} and ${where}.`;
+    }
+    if (!isScalarKey(blueprint, key)) {
+      return `route reads "${key}" from ${where}, but it is not a scalar key of the input.`;
+    }
+    places.set(key, where);
+    return;
+  };
+  if (path !== undefined) {
+    if (!isRoutePath(path)) {
+      return 'Expected route.path to start with "/", with parameters only as whole "{name}" segments and no query.';
+    }
+    for (const name of parametersOfPath(path)) {
+      const bad = place(name, "the path");
+      if (bad)
+        return bad;
+    }
+  }
+  if (status !== undefined && !ROUTE_SUCCESS_STATUSES.includes(status)) {
+    return `Expected route.status to be one of ${ROUTE_SUCCESS_STATUSES.join(", ")}.`;
+  }
+  if (query !== undefined) {
+    if (!Array.isArray(query) || query.some((key) => typeof key !== "string")) {
+      return "Expected route.query to be a list of input keys.";
+    }
+    for (const key of query) {
+      const bad = place(key, "the query");
+      if (bad)
+        return bad;
+    }
+  }
+  for (const [option, value, where] of [
+    ["headers", headers, "a header"],
+    ["cookie", cookie, "a cookie"]
+  ]) {
+    if (value === undefined)
+      continue;
+    if (!isObject(value)) {
+      return `Expected route.${option} to map input keys to names.`;
+    }
+    const names = new Set;
+    for (const [key, name] of Object.entries(value)) {
+      if (typeof name !== "string" || !HEADER_NAME.test(name)) {
+        return `Expected route.${option}["${key}"] to be the name of ${where}.`;
+      }
+      const bad = place(key, where);
+      if (bad)
+        return bad;
+      const folded = option === "headers" ? name.toLowerCase() : name;
+      if (names.has(folded)) {
+        return `route.${option} reads "${name}" into two input keys.`;
+      }
+      names.add(folded);
+    }
+  }
+  if (setCookie !== undefined) {
+    if (!isObject(setCookie)) {
+      return "Expected route.setCookie to map response keys to cookies.";
+    }
+    const names = new Set;
+    for (const [key, settings] of Object.entries(setCookie)) {
+      if (!isScalarKey(response, key)) {
+        return `route.setCookie sends "${key}", which is not a scalar key of the response.`;
+      }
+      const bad = cookieIssue(settings, `route.setCookie["${key}"]`);
+      if (bad)
+        return bad;
+      const { name } = settings;
+      if (names.has(name)) {
+        return `route.setCookie sets the cookie "${name}" from two response keys.`;
+      }
+      names.add(name);
+    }
+  }
+  return Object.freeze({
+    method,
+    ...path === undefined ? {} : { path },
+    ...status === undefined ? {} : { status },
+    ...query === undefined ? {} : { query: Object.freeze([...query]) },
+    ...headers === undefined ? {} : {
+      headers: Object.freeze(Object.fromEntries(Object.entries(headers).map(([key, name]) => [key, name.toLowerCase()])))
+    },
+    ...cookie === undefined ? {} : { cookie: Object.freeze({ ...cookie }) },
+    ...setCookie === undefined ? {} : {
+      setCookie: Object.freeze(Object.fromEntries(Object.entries(setCookie).map(([key, settings]) => [key, Object.freeze({ ...settings })])))
+    }
+  });
+}