@afora/core 0.0.9 → 0.0.12

package/dist/index-xegv6a1p.js

@@ -1,4291 +0,0 @@
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/core/blueprint/exceptions.ts
-var exports_exceptions3 = {};
-__export(exports_exceptions3, {
-  InvalidBlueprintVariant: () => InvalidBlueprintVariant2,
-  ReservedBlueprintKey: () => ReservedBlueprintKey2,
-  UndeclaredBlueprintProperty: () => UndeclaredBlueprintProperty2
-});
-
-// src/core/property/exceptions.ts
-var exports_exceptions4 = {};
-__export(exports_exceptions4, {
-  InvalidPropertyValue: () => InvalidPropertyValue2,
-  PropertyRequired: () => PropertyRequired2
-});
-
-// src/core/environment/environment.ts
-var exports_environment = {};
-__export(exports_environment, {
-  InvalidEnvironment: () => InvalidEnvironment2,
-  environmentOf: () => environmentOf2,
-  isEnvironment: () => isEnvironment,
-  loadEnvironments: () => loadEnvironments
-});
-
-// src/core/application/exceptions.ts
-var exports_exceptions5 = {};
-__export(exports_exceptions5, {
-  ApplicationAlreadyStarted: () => ApplicationAlreadyStarted2,
-  ApplicationConflict: () => ApplicationConflict2,
-  ApplicationNotStarted: () => ApplicationNotStarted2,
-  DuplicateApplicationDeclaration: () => DuplicateApplicationDeclaration2,
-  InvalidApplicationDeclaration: () => InvalidApplicationDeclaration2,
-  InvalidApplicationEnvironment: () => InvalidApplicationEnvironment2,
-  InvalidSchemaMigration: () => InvalidSchemaMigration2,
-  ProviderNotBound: () => ProviderNotBound2,
-  SchemaLockMismatch: () => SchemaLockMismatch2,
-  UnregisteredApplicationReference: () => UnregisteredApplicationReference2,
-  UnregisteredRepositoryDependency: () => UnregisteredRepositoryDependency2,
-  UnregisteredUseCaseDependency: () => UnregisteredUseCaseDependency2
-});
-
-// src/core/logger/exceptions.ts
-var exports_exceptions6 = {};
-__export(exports_exceptions6, {
-  InvalidLogDeclaration: () => InvalidLogDeclaration2
-});
-
-// src/core/record/exceptions.ts
-var exports_exceptions7 = {};
-__export(exports_exceptions7, {
-  IncompatibleRecordPlugin: () => IncompatibleRecordPlugin2,
-  InvalidRecordDeclaration: () => InvalidRecordDeclaration2,
-  InvalidRecordPlugin: () => InvalidRecordPlugin2,
-  InvalidRecordValue: () => InvalidRecordValue2,
-  RecordPluginConflict: () => RecordPluginConflict2,
-  ReservedRecordKey: () => ReservedRecordKey2,
-  UndeclaredRecordProperty: () => UndeclaredRecordProperty2,
-  UnknownRecordPlugin: () => UnknownRecordPlugin2
-});
-
-// src/core/entity/exceptions.ts
-var exports_exceptions8 = {};
-__export(exports_exceptions8, {
-  DeletedEntity: () => DeletedEntity2,
-  ImmutableEntityKey: () => ImmutableEntityKey2,
-  InvalidEntityExpiry: () => InvalidEntityExpiry2,
-  InvalidEntitySchemaVersion: () => InvalidEntitySchemaVersion2,
-  ReservedEntityKey: () => ReservedEntityKey2
-});
-
-// src/core/repository/exceptions.ts
-var exports_exceptions9 = {};
-__export(exports_exceptions9, {
-  InvalidRepositoryCursor: () => InvalidRepositoryCursor2,
-  InvalidRepositoryData: () => InvalidRepositoryData2,
-  InvalidRepositoryDeclaration: () => InvalidRepositoryDeclaration2,
-  InvalidRepositoryEntity: () => InvalidRepositoryEntity2,
-  InvalidRepositoryIncrement: () => InvalidRepositoryIncrement2,
-  InvalidRepositoryQuery: () => InvalidRepositoryQuery2,
-  InvalidStoredSchemaVersion: () => InvalidStoredSchemaVersion2,
-  RepositoryConcurrencyConflict: () => RepositoryConcurrencyConflict2,
-  RepositoryEntityNotFound: () => RepositoryEntityNotFound2,
-  RepositoryUniqueViolation: () => RepositoryUniqueViolation2,
-  RepositoryUsedOutsideApplication: () => RepositoryUsedOutsideApplication2
-});
-
-// src/core/openapi/exceptions.ts
-var exports_exceptions10 = {};
-__export(exports_exceptions10, {
-  InvalidOpenAPIModel: () => InvalidOpenAPIModel2
-});
-
-// src/core/output/exceptions.ts
-var exports_exceptions11 = {};
-__export(exports_exceptions11, {
-  DuplicateOperation: () => DuplicateOperation2,
-  Forbidden: () => Forbidden2,
-  InvalidOutputStage: () => InvalidOutputStage2,
-  Unauthenticated: () => Unauthenticated2
-});
-
-// src/core/property/is-property.ts
-function isProperty(value) {
-  return typeof value === "function" && typeof value.type === "object";
-}
-
-// src/core/schema/schema.ts
-import Compile from "typebox/compile";
-import * as System from "typebox/system";
-var KEPT_KEYWORDS = new Set([
-  "type",
-  "required",
-  "$ref",
-  "$id",
-  "$anchor",
-  "$dynamicRef",
-  "$dynamicAnchor"
-]);
-var SCHEMA_KEYWORDS = new Set([
-  "additionalProperties",
-  "items",
-  "additionalItems",
-  "prefixItems",
-  "anyOf",
-  "oneOf",
-  "allOf",
-  "contains",
-  "propertyNames"
-]);
-var SCHEMA_MAP_KEYWORDS = new Set([
-  "properties",
-  "patternProperties",
-  "dependentSchemas",
-  "$defs",
-  "definitions"
-]);
-var JSON_TYPES = new Set([
-  "null",
-  "array",
-  "string",
-  "number",
-  "boolean",
-  "object"
-]);
-function typeOfValue(value) {
-  const type = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
-  return JSON_TYPES.has(type) ? type : undefined;
-}
-function shapeOf(schema) {
-  if (Array.isArray(schema))
-    return schema.map(shapeOf);
-  if (typeof schema !== "object" || schema === null)
-    return schema;
-  const shape = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (KEPT_KEYWORDS.has(key))
-      shape[key] = value;
-    else if (SCHEMA_KEYWORDS.has(key))
-      shape[key] = shapeOf(value);
-    else if (SCHEMA_MAP_KEYWORDS.has(key)) {
-      shape[key] = Object.fromEntries(Object.entries(value).map(([name, item]) => [
-        name,
-        shapeOf(item)
-      ]));
-    }
-  }
-  if (!("type" in shape)) {
-    const values = "const" in schema ? [schema.const] : schema.enum;
-    if (Array.isArray(values)) {
-      const types = values.map(typeOfValue);
-      if (types.every((type) => type !== undefined)) {
-        shape.type = [...new Set(types)];
-      }
-    }
-  }
-  return shape;
-}
-function describeError(error) {
-  return `${error.instancePath || "/"}: ${error.message}`;
-}
-var INERT_KEYWORDS = new Set([
-  "~kind",
-  "~optional",
-  "~readonly",
-  "~unsafe",
-  "title",
-  "description",
-  "default",
-  "examples",
-  "deprecated",
-  "readOnly",
-  "writeOnly",
-  "$comment"
-]);
-var isNumeric = (value) => typeof value === "number" || typeof value === "bigint";
-var LEAF_KEYWORDS = [
-  [
-    "type",
-    (value) => typeof value === "string" || Array.isArray(value) && value.every((item) => typeof item === "string"),
-    (type) => ({ type })
-  ],
-  ["minLength", (value) => typeof value === "number", (limit) => ({ limit })],
-  ["maxLength", (value) => typeof value === "number", (limit) => ({ limit })],
-  ["format", (value) => typeof value === "string", (format) => ({ format })],
-  ["pattern", (value) => typeof value === "string", (pattern) => ({ pattern })],
-  ["exclusiveMinimum", isNumeric, (limit) => ({ comparison: ">", limit })],
-  ["exclusiveMaximum", isNumeric, (limit) => ({ comparison: "<", limit })],
-  ["minimum", isNumeric, (limit) => ({ comparison: ">=", limit })],
-  ["maximum", isNumeric, (limit) => ({ comparison: "<=", limit })],
-  ["multipleOf", isNumeric, (multipleOf) => ({ multipleOf })],
-  ["const", () => true, (allowedValue) => ({ allowedValue })],
-  ["enum", Array.isArray, (allowedValues) => ({ allowedValues })]
-];
-var LEAF_KEYWORD_NAMES = new Set(LEAF_KEYWORDS.map(([keyword]) => keyword));
-function leafChecksOf(schema) {
-  if (typeof schema !== "object" || schema === null)
-    return;
-  for (const key of Reflect.ownKeys(schema)) {
-    if (!LEAF_KEYWORD_NAMES.has(key) && !INERT_KEYWORDS.has(key)) {
-      return;
-    }
-  }
-  const checks = [];
-  for (const [keyword, reads, params] of LEAF_KEYWORDS) {
-    if (!Object.hasOwn(schema, keyword))
-      continue;
-    const value = schema[keyword];
-    if (!reads(value))
-      return;
-    const validator = Compile({ [keyword]: value });
-    checks.push({
-      keyword,
-      params: params(value),
-      check: (candidate) => validator.Check(candidate)
-    });
-  }
-  return checks;
-}
-var { Locale, Settings } = System;
-var leafChecks = new WeakMap;
-function addError(sink, keyword, schemaPath, instancePath, params) {
-  if (sink.errors.length < sink.max) {
-    const error = { keyword, schemaPath, instancePath, params };
-    sink.errors.push({ ...error, message: sink.locale(error) });
-  }
-  return false;
-}
-var segmentOf = (key) => key.replaceAll("~", "~0").replaceAll("/", "~1");
-var hasKey = (value, key) => key === "__proto__" || key === "constructor" || key === "prototype" ? Object.hasOwn(value, key) : (key in value);
-var STRUCTURE_KEYWORDS = new Set([
-  "required",
-  "properties",
-  "additionalProperties",
-  "items",
-  "minItems",
-  "maxItems",
-  "anyOf"
-]);
-function explainerOf(schema) {
-  if (!isRecord(schema))
-    return;
-  for (const key of Reflect.ownKeys(schema)) {
-    if (!LEAF_KEYWORD_NAMES.has(key) && !INERT_KEYWORDS.has(key) && !STRUCTURE_KEYWORDS.has(key)) {
-      return;
-    }
-  }
-  let type;
-  const leaves = [];
-  for (const [keyword, reads, params] of LEAF_KEYWORDS) {
-    if (!Object.hasOwn(schema, keyword))
-      continue;
-    const value = schema[keyword];
-    if (!reads(value))
-      return;
-    const validator = Compile({ [keyword]: value });
-    const leaf = {
-      keyword,
-      params: params(value),
-      check: (candidate) => validator.Check(candidate)
-    };
-    if (keyword === "type")
-      type = leaf;
-    else
-      leaves.push(leaf);
-  }
-  let required;
-  if (Object.hasOwn(schema, "required")) {
-    const value = schema.required;
-    if (!Array.isArray(value))
-      return;
-    if (!value.every((key) => typeof key === "string"))
-      return;
-    required = value;
-  }
-  let properties;
-  if (Object.hasOwn(schema, "properties")) {
-    if (!isRecord(schema.properties))
-      return;
-    const list = [];
-    for (const [key, property] of Object.entries(schema.properties)) {
-      const explain = explainerOf(property);
-      if (!explain)
-        return;
-      list.push({
-        key,
-        segment: segmentOf(key),
-        required: required?.includes(key) ?? false,
-        explain
-      });
-    }
-    properties = list;
-  }
-  let declared;
-  if (Object.hasOwn(schema, "additionalProperties")) {
-    if (schema.additionalProperties !== false)
-      return;
-    declared = new Set(properties?.map(({ key }) => key));
-  }
-  let items;
-  if (Object.hasOwn(schema, "items")) {
-    items = explainerOf(schema.items);
-    if (!items)
-      return;
-  }
-  const limits = [];
-  for (const keyword of ["minItems", "maxItems"]) {
-    if (!Object.hasOwn(schema, keyword))
-      continue;
-    const limit = schema[keyword];
-    if (typeof limit !== "number")
-      return;
-    const validator = Compile({ [keyword]: limit });
-    limits.push({
-      keyword,
-      params: { limit },
-      check: (candidate) => validator.Check(candidate)
-    });
-  }
-  let anyOf;
-  if (Object.hasOwn(schema, "anyOf")) {
-    if (!Array.isArray(schema.anyOf))
-      return;
-    const list = [];
-    for (const option of schema.anyOf) {
-      const explain = explainerOf(option);
-      if (!explain)
-        return;
-      list.push(explain);
-    }
-    anyOf = list;
-  }
-  return (value, schemaPath, instancePath, sink) => {
-    if (sink.errors.length >= sink.max)
-      return false;
-    let accepted = true;
-    if (type && !type.check(value)) {
-      accepted = addError(sink, "type", schemaPath, instancePath, type.params);
-    }
-    if (isRecord(value)) {
-      if (required) {
-        const missing = required.filter((key) => !hasKey(value, key));
-        if (missing.length > 0) {
-          accepted = addError(sink, "required", schemaPath, instancePath, {
-            requiredProperties: missing
-          });
-        }
-      }
-      if (declared) {
-        const undeclared = [];
-        for (const key of Object.getOwnPropertyNames(value)) {
-          if (declared.has(key))
-            continue;
-          undeclared.push(key);
-          addError(sink, "boolean", `${schemaPath}/additionalProperties`, `${instancePath}/${segmentOf(key)}`, {});
-        }
-        if (undeclared.length > 0) {
-          accepted = addError(sink, "additionalProperties", schemaPath, instancePath, { additionalProperties: undeclared });
-        }
-      }
-      if (properties) {
-        for (const property of properties) {
-          const { key } = property;
-          if (!property.required && !sink.exact && value[key] === undefined) {
-            continue;
-          }
-          if (!hasKey(value, key))
-            continue;
-          const explained = property.explain(value[key], `${schemaPath}/properties/${property.segment}`, `${instancePath}/${property.segment}`, sink);
-          if (!explained)
-            accepted = false;
-        }
-      }
-    }
-    if (Array.isArray(value)) {
-      if (items) {
-        const explain = items;
-        value.forEach((item, index) => {
-          const explained = explain(item, `${schemaPath}/items`, `${instancePath}/${index}`, sink);
-          if (!explained)
-            accepted = false;
-        });
-      }
-      for (const limit of limits) {
-        if (limit.check(value))
-          continue;
-        accepted = addError(sink, limit.keyword, schemaPath, instancePath, limit.params);
-      }
-    }
-    for (const leaf of leaves) {
-      if (leaf.check(value))
-        continue;
-      accepted = addError(sink, leaf.keyword, schemaPath, instancePath, leaf.params);
-    }
-    if (anyOf) {
-      const failed = [];
-      let matched = false;
-      for (const [index, explain] of anyOf.entries()) {
-        const own = { ...sink, errors: [] };
-        const explained = explain(value, `${schemaPath}/anyOf/${index}`, instancePath, own);
-        if (explained)
-          matched = true;
-        else
-          failed.push(own.errors);
-      }
-      if (!matched) {
-        for (const errors of failed) {
-          for (const error of errors) {
-            if (sink.errors.length < sink.max)
-              sink.errors.push(error);
-          }
-        }
-        accepted = addError(sink, "anyOf", schemaPath, instancePath, {});
-      }
-    }
-    return accepted;
-  };
-}
-var explainers = new WeakMap;
-function sinkOf() {
-  const settings = Settings?.Get?.();
-  const locale = Locale?.Get?.();
-  if (typeof settings?.maxErrors !== "number" || typeof locale !== "function") {
-    return;
-  }
-  return {
-    errors: [],
-    max: settings.maxErrors,
-    locale,
-    exact: settings.exactOptionalPropertyTypes === true
-  };
-}
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function literalOf(variant, key) {
-  if (!isRecord(variant) || variant.type !== "object")
-    return;
-  const { properties, required } = variant;
-  if (!isRecord(properties) || !Array.isArray(required))
-    return;
-  if (!required.includes(key) || !Object.hasOwn(properties, key)) {
-    return;
-  }
-  const property = properties[key];
-  if (!isRecord(property) || !Object.hasOwn(property, "const"))
-    return;
-  const value = property.const;
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? { value } : undefined;
-}
-function discriminatedUnionOf(schema) {
-  if (!isRecord(schema) || !Array.isArray(schema.anyOf))
-    return;
-  for (const key of Reflect.ownKeys(schema)) {
-    if (key !== "anyOf" && !INERT_KEYWORDS.has(key))
-      return;
-  }
-  const options = schema.anyOf;
-  const [first] = options;
-  if (options.length < 2 || !isRecord(first) || !isRecord(first.properties)) {
-    return;
-  }
-  for (const key of Object.keys(first.properties)) {
-    const variants = new Map;
-    for (const [index, option] of options.entries()) {
-      const literal = literalOf(option, key);
-      if (!literal || variants.has(literal.value))
-        break;
-      let validator;
-      variants.set(literal.value, {
-        index,
-        explain: explainerOf(option),
-        Errors: (value) => {
-          validator ??= Compile(option);
-          return validator.Errors(value);
-        }
-      });
-    }
-    if (variants.size !== options.length)
-      continue;
-    return {
-      key,
-      segment: segmentOf(key),
-      allowedValues: [...variants.keys()],
-      variants
-    };
-  }
-  return;
-}
-var discriminatedUnions = new WeakMap;
-function errorsOfVariant(union, value) {
-  const variant = union.variants.get(value[union.key]);
-  if (variant) {
-    const at = `#/anyOf/${variant.index}`;
-    const sink = variant.explain && sinkOf();
-    if (variant.explain && sink) {
-      variant.explain(value, at, "", sink);
-      return sink.errors.length > 0 ? sink.errors : undefined;
-    }
-    const errors = variant.Errors(value);
-    if (errors.length === 0)
-      return;
-    return errors.map((error) => ({
-      ...error,
-      schemaPath: at + error.schemaPath.slice(1)
-    }));
-  }
-  const maxErrors = Settings?.Get?.().maxErrors;
-  const locale = Locale?.Get?.();
-  if (typeof maxErrors !== "number" || typeof locale !== "function") {
-    return;
-  }
-  if (maxErrors < 1)
-    return [];
-  const error = {
-    keyword: "enum",
-    schemaPath: "#/anyOf",
-    instancePath: `/${union.segment}`,
-    params: { allowedValues: union.allowedValues }
-  };
-  return [{ ...error, message: locale(error) }];
-}
-function errorsOfSchema(schema, value) {
-  let checks = leafChecks.get(schema);
-  if (checks === undefined) {
-    checks = leafChecksOf(schema.type.Type()) ?? null;
-    leafChecks.set(schema, checks);
-  }
-  const maxErrors = Settings?.Get?.().maxErrors;
-  const locale = Locale?.Get?.();
-  if (checks !== null && typeof maxErrors === "number" && typeof locale === "function") {
-    const errors = [];
-    for (const { keyword, params, check } of checks) {
-      if (errors.length >= maxErrors)
-        break;
-      if (check(value))
-        continue;
-      const error = { keyword, schemaPath: "#", instancePath: "", params };
-      errors.push({ ...error, message: locale(error) });
-    }
-    if (errors.length > 0)
-      return errors;
-  }
-  if (checks === null && isRecord(value)) {
-    let union = discriminatedUnions.get(schema);
-    if (union === undefined) {
-      union = discriminatedUnionOf(schema.type.Type()) ?? null;
-      discriminatedUnions.set(schema, union);
-    }
-    const errors = union && errorsOfVariant(union, value);
-    if (errors)
-      return errors;
-  }
-  if (checks === null) {
-    let explain = explainers.get(schema);
-    if (explain === undefined) {
-      explain = explainerOf(schema.type.Type()) ?? null;
-      explainers.set(schema, explain);
-    }
-    const sink = explain && sinkOf();
-    if (explain && sink) {
-      explain(value, "#", "", sink);
-      if (sink.errors.length > 0)
-        return sink.errors;
-    }
-  }
-  return schema.type.Errors(value);
-}
-
-class AbstractSchema {
-  _type;
-  validator;
-  shapeValidator;
-  constructor(_type) {
-    this._type = _type;
-  }
-  match(value) {
-    return this.type.Check(value);
-  }
-  matchShape(value) {
-    this.shapeValidator ??= Compile(shapeOf(this._type));
-    return this.shapeValidator.Check(value);
-  }
-  checks() {
-    const validator = this.type;
-    const shape = shapeOf(this._type);
-    if (shape.type === "string" && Object.keys(shape).length === 1) {
-      return {
-        match: (value) => validator.Check(value),
-        matchShape: (value) => typeof value === "string"
-      };
-    }
-    return {
-      match: (value) => validator.Check(value),
-      matchShape: (value) => this.matchShape(value)
-    };
-  }
-  errors(value) {
-    return this.type.Errors(value).map(describeError);
-  }
-  toString() {
-    return JSON.stringify(this._type);
-  }
-  get type() {
-    this.validator ??= Compile(this._type);
-    return this.validator;
-  }
-}
-function checksOfSchema(schema) {
-  return schema instanceof AbstractSchema ? schema.checks() : {
-    match: (value) => schema.match(value),
-    matchShape: (value) => schema.matchShape(value)
-  };
-}
-function schemaOf(name, schema) {
-
-  class Schema extends AbstractSchema {
-    constructor(type = schema) {
-      super(type);
-    }
-    static fromString(value) {
-      return new Schema(JSON.parse(value));
-    }
-  }
-  Object.defineProperty(Schema, "name", { value: name });
-  Object.defineProperty(Schema, Symbol.for("nodejs.util.inspect.custom"), {
-    value: () => `@afora::schema:${name}`
-  });
-  return Schema;
-}
-
-// src/core/symbols/demo.ts
-var Demo2 = Symbol("demo");
-
-// src/core/property/lineage.ts
-var lineages = new WeakMap;
-function recordPropertyLineage(Property, lineage) {
-  if (!lineages.has(Property))
-    lineages.set(Property, lineage);
-}
-function propertyLineageOf2(Property) {
-  return typeof Property === "function" ? lineages.get(Property) : undefined;
-}
-
-// src/core/property/refine.ts
-var METADATA_KEYS = [
-  "title",
-  "description",
-  "examples",
-  "deprecated",
-  "readOnly",
-  "writeOnly"
-];
-var LOWER_BOUNDS = {
-  min: ["minimum", "minLength"],
-  exclusiveMin: ["exclusiveMinimum"]
-};
-var UPPER_BOUNDS = {
-  max: ["maximum", "maxLength"],
-  exclusiveMax: ["exclusiveMaximum"]
-};
-function derivePropertyOf(Property, type) {
-  const Base = Property;
-
-  class Derived extends Base {
-    static type = type;
-    createDefinition() {
-      const definition = super.createDefinition();
-      Object.defineProperty(definition, "type", {
-        value: type,
-        configurable: true
-      });
-      return definition;
-    }
-  }
-  Object.defineProperty(Derived, "name", { value: Property.name });
-  return Derived;
-}
-function copyOf(schema) {
-  return Object.defineProperties({}, Object.getOwnPropertyDescriptors(schema));
-}
-function addAllOf(schema, constraint) {
-  schema.allOf = [...schema.allOf ?? [], constraint];
-}
-function refinedSchemaOf(base, options) {
-  const schema = copyOf(base);
-  const keyword = (keys) => keys.length === 1 || schema.type !== "string" ? keys[0] : keys[1];
-  for (const key of METADATA_KEYS) {
-    if (options[key] !== undefined)
-      schema[key] = options[key];
-  }
-  for (const [option, keys] of Object.entries(LOWER_BOUNDS)) {
-    const value = options[option];
-    if (value === undefined)
-      continue;
-    const name = keyword(keys);
-    const current = schema[name];
-    schema[name] = current === undefined ? value : Math.max(current, value);
-  }
-  for (const [option, keys] of Object.entries(UPPER_BOUNDS)) {
-    const value = options[option];
-    if (value === undefined)
-      continue;
-    const name = keyword(keys);
-    const current = schema[name];
-    schema[name] = current === undefined ? value : Math.min(current, value);
-  }
-  if (options.multipleOf !== undefined) {
-    if (schema.multipleOf === undefined)
-      schema.multipleOf = options.multipleOf;
-    else
-      addAllOf(schema, { multipleOf: options.multipleOf });
-  }
-  if (options.pattern !== undefined) {
-    const pattern = options.pattern instanceof RegExp ? options.pattern.source : options.pattern;
-    if (schema.pattern === undefined)
-      schema.pattern = pattern;
-    else
-      addAllOf(schema, { pattern });
-  }
-  return schema;
-}
-function refinePropertyOf(Property, options) {
-  const base = Property.type;
-  const settings = options;
-  const schema = refinedSchemaOf(base.schema.type.Type(), settings);
-  const SchemaConstructor = schemaOf(base.name, schema);
-  const examples = settings.examples;
-  const type = {
-    ...base,
-    [Demo2]: settings.default ?? examples?.[0] ?? base[Demo2],
-    schema: new SchemaConstructor,
-    ...settings.fill !== undefined && { fill: settings.fill },
-    ...typeof settings.renamedFrom === "string" && {
-      renamedFrom: settings.renamedFrom
-    }
-  };
-  const Refined = derivePropertyOf(Property, type);
-  recordPropertyLineage(Refined, {
-    kind: "refined",
-    base: Property,
-    options: Object.freeze({ ...settings })
-  });
-  return Refined;
-}
-
-// src/core/blueprint/callable.ts
-var targets = new WeakMap;
-function callableOf(Property) {
-  const callable = new Proxy(Property, {
-    apply: (target, _this, [options]) => refinePropertyOf(target, options ?? {})
-  });
-  targets.set(callable, Property);
-  return callable;
-}
-function fieldOf(field) {
-  return (isProperty(field) ? targets.get(field) : undefined) ?? field;
-}
-
-// src/core/symbols/kind.ts
-var Kind2 = Symbol("kind");
-
-// src/core/blueprint/is-blueprint.ts
-function isBlueprint(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "blueprint";
-}
-
-// src/core/blueprint/record-field.ts
-function isRecordClass(value) {
-  return typeof value === "function" && value[Kind2] === "record";
-}
-function isOptionalRecord(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "record";
-}
-function recordFieldOf(field) {
-  if (isRecordClass(field))
-    return { record: field, optional: false };
-  if (isOptionalRecord(field))
-    return field;
-  return;
-}
-
-// src/core/standard/standard-schema.ts
-var STANDARD_VENDOR = "afora";
-
-// src/core/standard/standard.ts
-function standardOf(parse) {
-  return Object.freeze({
-    version: 1,
-    vendor: STANDARD_VENDOR,
-    validate: parse
-  });
-}
-function withStandard(target, parse) {
-  return Object.defineProperty(target, "~standard", {
-    value: standardOf(parse),
-    enumerable: false
-  });
-}
-var cache = new WeakMap;
-function standardOfClass(Class) {
-  let standard = cache.get(Class);
-  if (!standard) {
-    standard = standardOf((value) => Class.safeParse(value));
-    cache.set(Class, standard);
-  }
-  return standard;
-}
-
-// src/core/exception/enums/exception-layers.ts
-var ExceptionLayers2;
-((ExceptionLayers) => {
-  ExceptionLayers["Schema"] = "schema";
-  ExceptionLayers["Property"] = "property";
-  ExceptionLayers["Blueprint"] = "blueprint";
-  ExceptionLayers["Record"] = "record";
-  ExceptionLayers["Entity"] = "entity";
-  ExceptionLayers["UseCase"] = "use-case";
-  ExceptionLayers["Repository"] = "repository";
-  ExceptionLayers["Environment"] = "environment";
-  ExceptionLayers["Event"] = "event";
-  ExceptionLayers["Command"] = "command";
-  ExceptionLayers["Application"] = "application";
-  ExceptionLayers["Output"] = "output";
-})(ExceptionLayers2 ||= {});
-
-// src/core/exception/exception.ts
-var UNEXPECTED_ERROR = "UnexpectedError";
-
-class Exception2 extends Error {
-  name;
-  layer;
-  source;
-  details;
-  cause;
-  constructor({
-    layer,
-    name,
-    source,
-    message,
-    details,
-    cause
-  }) {
-    super(message, cause === undefined ? undefined : { cause });
-    this.name = name;
-    this.layer = layer;
-    this.source = source;
-    this.details = details;
-    this.cause = cause;
-  }
-  static from(error, scope) {
-    if (error instanceof Exception2)
-      return error;
-    return new Exception2({
-      ...scope,
-      name: UNEXPECTED_ERROR,
-      message: error instanceof Error ? error.message : String(error),
-      cause: error
-    });
-  }
-  get frame() {
-    const { layer, name, source, message, details } = this;
-    return { layer, name, source, message, details };
-  }
-  get trace() {
-    return this.chain().map((exception) => exception.frame).reverse();
-  }
-  get origin() {
-    return this.chain().at(-1);
-  }
-  find(target) {
-    return this.chain().find((exception) => typeof target === "string" ? exception.name === target : exception instanceof target);
-  }
-  is(target) {
-    return this.find(target) !== undefined;
-  }
-  passedThrough(layer) {
-    return this.chain().some((exception) => exception.layer === layer);
-  }
-  propagate({
-    layer,
-    source,
-    name = this.name,
-    message = this.message,
-    details
-  }) {
-    const keepsClass = name === this.name && details === undefined && isDeclaredInstance(this);
-    const init = {
-      layer,
-      source,
-      name,
-      message,
-      details: keepsClass ? this.details : details,
-      cause: this
-    };
-    return keepsClass ? Reflect.construct(Exception2, [init], this.constructor) : new Exception2(init);
-  }
-  toJSON() {
-    return { ...this.frame, trace: this.trace };
-  }
-  toString() {
-    return this.chain().map((exception, index) => `${index === 0 ? "" : "  <- "}${exception.name} [${exception.layer} @ ${exception.source}]: ${exception.message}`).join(`
-`);
-  }
-  chain() {
-    const chain = [];
-    for (let current = this;current instanceof Exception2; current = current.cause) {
-      chain.push(current);
-    }
-    return chain;
-  }
-}
-var declarations = new WeakMap;
-function isDeclaredInstance(exception) {
-  for (let current = exception.constructor;typeof current === "function"; current = Object.getPrototypeOf(current)) {
-    if (declarations.has(current))
-      return true;
-  }
-  return false;
-}
-function isDeclaredException(value) {
-  return typeof value === "function" && declarations.has(value);
-}
-function declaredMessageOf(Declared) {
-  const { message } = declarations.get(Declared) ?? {};
-  return typeof message === "string" ? message : undefined;
-}
-function exceptionOf2({
-  layer,
-  name,
-  message
-}) {
-
-  class DeclaredException extends Exception2 {
-    static layer = layer;
-    constructor({
-      source,
-      details,
-      cause,
-      message: custom
-    }) {
-      super({
-        layer,
-        name,
-        source,
-        details,
-        cause,
-        message: custom ?? (typeof message === "function" ? message(details, source) : message)
-      });
-    }
-  }
-  Object.defineProperty(DeclaredException, "name", { value: name });
-  declarations.set(DeclaredException, { message });
-  return DeclaredException;
-}
-
-// src/core/blueprint/exceptions.ts
-var ReservedBlueprintKey2 = exceptionOf2({
-  layer: "blueprint" /* Blueprint */,
-  name: "ReservedBlueprintKey",
-  message: ({ key }) => `"${key}" is reserved and cannot be a plugin property.`
-});
-var InvalidBlueprintVariant2 = exceptionOf2({
-  layer: "blueprint" /* Blueprint */,
-  name: "InvalidBlueprintVariant",
-  message: ({
-    key,
-    reason
-  }) => `The variant field of key "${key}" cannot be declared: ${reason}.`
-});
-var UndeclaredBlueprintProperty2 = exceptionOf2({
-  layer: "blueprint" /* Blueprint */,
-  name: "UndeclaredBlueprintProperty",
-  message: ({ key }) => `Property "${key}" of the blueprint is not declared.`
-});
-
-// src/core/blueprint/variant.ts
-function variantOf2(key, variants) {
-  const fail = (reason) => {
-    throw new InvalidBlueprintVariant2({
-      source: "blueprint",
-      details: { key: String(key), reason }
-    });
-  };
-  if (typeof key !== "string" || key === "") {
-    fail("its key must be a string that is not empty");
-  }
-  const tags = Object.keys(variants);
-  if (tags.length === 0)
-    fail("it needs at least one variant");
-  const classes = new Set;
-  for (const tag of tags) {
-    const variant = variants[tag];
-    if (!isBlueprint(variant) && !isRecordClass(variant)) {
-      fail(`the variant "${tag}" is not a blueprint nor a record class`);
-    }
-    if (classes.has(variant)) {
-      fail(`the variant "${tag}" is a class another variant already is`);
-    }
-    if (isRecordClass(variant))
-      classes.add(variant);
-    if (Object.hasOwn(blueprintOfVariant(variant).properties, key)) {
-      fail(`the variant "${tag}" declares "${key}", which the field adds`);
-    }
-  }
-  return standardVariantOf({
-    [Kind2]: "variant",
-    key,
-    variants: Object.freeze({ ...variants }),
-    optional: false
-  });
-}
-function standardVariantOf(variant) {
-  return Object.freeze(withStandard(variant, (value) => parseField(variant, value, [], "variant")));
-}
-function blueprintOfVariant(variant) {
-  return isRecordClass(variant) ? variant.blueprint : variant;
-}
-function namedVariantOf(field, value) {
-  if (typeof value !== "object" || value === null)
-    return;
-  const tag = value[field.key];
-  const variants = field.variants;
-  return typeof tag === "string" && Object.hasOwn(variants, tag) ? variants[tag] : undefined;
-}
-function variantOfValue(field, value) {
-  const variant = namedVariantOf(field, value);
-  return variant && blueprintOfVariant(variant);
-}
-function variantNameOf(field, instance) {
-  if (typeof instance !== "object" || instance === null)
-    return;
-  const variants = field.variants;
-  for (const tag of Object.keys(variants)) {
-    const variant = variants[tag];
-    if (isRecordClass(variant) && instance instanceof variant)
-      return tag;
-  }
-  return;
-}
-function isBlueprintVariant(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "variant";
-}
-
-// src/core/symbols/state.ts
-var State2 = Symbol("state");
-
-// src/core/property/abstract-property.ts
-var parsingDefinitions = new WeakMap;
-function parsingDefinitionOf(Class) {
-  let definition = parsingDefinitions.get(Class);
-  if (!definition) {
-    definition = Object.create(Class.prototype).createDefinition();
-    parsingDefinitions.set(Class, definition);
-  }
-  return definition;
-}
-
-class AbstractProperty {
-  get [State2]() {
-    return this.definition[State2];
-  }
-  definition;
-  value;
-  constructor(value) {
-    this.definition = this.createDefinition();
-    this.value = this.definition.make(value === Demo2 ? this.definition.type[Demo2] : value);
-  }
-  static demo() {
-    return new this(Demo2);
-  }
-  static safeParse(value) {
-    return parsingDefinitionOf(this).parse(value);
-  }
-  static with(options) {
-    return refinePropertyOf(this, options);
-  }
-  static get "~standard"() {
-    return standardOfClass(this);
-  }
-}
-
-// src/core/parse/issue.ts
-var REJECTED = Symbol("rejected");
-
-class LazyIssue {
-  message;
-  path;
-  code;
-  source;
-  #origin;
-  constructor(message, path, code, source, origin) {
-    this.message = message;
-    this.path = path;
-    this.code = code;
-    this.source = source;
-    this.#origin = origin;
-  }
-  get cause() {
-    return this.#origin.exception();
-  }
-  at(path) {
-    return new LazyIssue(this.message, path, this.code, this.source, this.#origin);
-  }
-}
-function movedIssue(issue, path) {
-  if (issue instanceof LazyIssue)
-    return issue.at(path);
-  const moved = { ...issue, path };
-  const cause = Object.getOwnPropertyDescriptor(issue, "cause");
-  if (cause && !cause.enumerable)
-    Object.defineProperty(moved, "cause", cause);
-  return moved;
-}
-
-// src/core/property/exceptions.ts
-var PropertyRequired2 = exceptionOf2({
-  layer: "property" /* Property */,
-  name: "PropertyRequired",
-  message: (_, source) => `Property "${source}" is required.`
-});
-var InvalidPropertyValue2 = exceptionOf2({
-  layer: "property" /* Property */,
-  name: "InvalidPropertyValue",
-  message: ({ errors }, source) => `Invalid value for property "${source}": ${errors.join("; ")}`
-});
-
-// src/core/property/define-property.ts
-var MISMATCH = Symbol("mismatch");
-
-class Failure {
-  source;
-  raised;
-  errors;
-  cause;
-  constructor(source, raised, errors) {
-    this.source = source;
-    this.raised = raised;
-    this.errors = errors;
-    this.cause = raised;
-  }
-  exception() {
-    if (this.cause === undefined) {
-      const { source, errors } = this;
-      this.cause = errors ? new InvalidPropertyValue2({
-        source,
-        details: { errors: errors.map(describeError) }
-      }) : new PropertyRequired2({ source });
-    }
-    return this.cause;
-  }
-}
-var rejection;
-function reject(failure) {
-  rejection = failure;
-  return REJECTED;
-}
-function segmentsOf(pointer) {
-  return pointer.slice(1).split("/").map((segment) => {
-    const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
-    return /^(0|[1-9]\d*)$/.test(key) ? Number(key) : key;
-  });
-}
-function issueOf(failure, message, path, code) {
-  return new LazyIssue(message, path, code, failure.source, failure);
-}
-function takeRejectionIssues(path, issues) {
-  const failure = rejection;
-  rejection = undefined;
-  const { raised, errors, source } = failure;
-  if (raised) {
-    issues.push({
-      message: raised.message,
-      path,
-      code: "invalid_value",
-      source,
-      cause: raised
-    });
-  } else if (!errors) {
-    issues.push(issueOf(failure, "is required", path, "required"));
-  } else if (errors.length === 0) {
-    issues.push(issueOf(failure, "is invalid", path, "invalid_value"));
-  } else {
-    for (const { message, instancePath } of errors) {
-      issues.push(issueOf(failure, message, instancePath === "" ? path : [...path, ...segmentsOf(instancePath)], "invalid_value"));
-    }
-  }
-}
-
-class AbstractDefineProperty {
-  [State2] = 0 /* Declared */;
-  make(value) {
-    const handled = this.attempt(value);
-    if (handled !== REJECTED)
-      return handled;
-    const failure = rejection;
-    rejection = undefined;
-    throw failure.exception();
-  }
-  parse(value) {
-    const handled = this.attemptWithoutThrowing(value);
-    if (handled !== REJECTED)
-      return { value: handled };
-    const issues = [];
-    takeRejectionIssues([], issues);
-    return { issues };
-  }
-  preHandle(value) {
-    return value;
-  }
-  afterHandle(value) {
-    return value;
-  }
-  handle(value) {
-    return this.type.schema.match(value) ? value : MISMATCH;
-  }
-  attemptWithoutThrowing(value) {
-    try {
-      return this.attempt(value);
-    } catch (error) {
-      return this.raise(error instanceof Exception2 ? error : this.invalidValue(error));
-    }
-  }
-  attempt(value) {
-    const { name, optional, schema } = this.type;
-    this[State2] = 0 /* Declared */;
-    if (value === undefined) {
-      if (!optional)
-        return reject(new Failure(name, undefined, undefined));
-      this[State2] = 4 /* Done */;
-      return value;
-    }
-    const preHandles = this.preHandle !== PASS.preHandle;
-    const handles = this.handle !== PASS.handle;
-    if ((preHandles || handles) && !schema.matchShape(value)) {
-      return this.mismatch(value);
-    }
-    try {
-      if (preHandles) {
-        this[State2] = 1 /* PreHandling */;
-        value = this.runHandler(this.preHandle, value);
-      }
-      this[State2] = 2 /* Handling */;
-      if (handles) {
-        const handled = this.handle(value);
-        if (handled === MISMATCH)
-          return this.mismatch(value);
-        value = handled;
-      } else if (!schema.match(value)) {
-        if (!preHandles && !schema.matchShape(value)) {
-          this[State2] = 0 /* Declared */;
-        }
-        return this.mismatch(value);
-      }
-      if (this.afterHandle !== PASS.afterHandle) {
-        this[State2] = 3 /* AfterHandling */;
-        value = this.runHandler(this.afterHandle, value);
-      }
-    } catch (error) {
-      if (error instanceof Exception2)
-        return this.raise(error);
-      throw error;
-    }
-    this[State2] = 4 /* Done */;
-    return value;
-  }
-  runHandler(handler, value) {
-    try {
-      return handler.call(this, value);
-    } catch (error) {
-      if (error instanceof Exception2)
-        throw error;
-      throw this.invalidValue(error);
-    }
-  }
-  invalidValue(error) {
-    return new InvalidPropertyValue2({
-      source: this.type.name,
-      details: {
-        errors: [error instanceof Error ? error.message : String(error)]
-      },
-      cause: error
-    });
-  }
-  raise(exception) {
-    return reject(new Failure(this.type.name, exception, undefined));
-  }
-  mismatch(value) {
-    const { name, schema } = this.type;
-    return reject(new Failure(name, undefined, errorsOfSchema(schema, value)));
-  }
-}
-var PASS = AbstractDefineProperty.prototype;
-var declared = new WeakSet;
-function declarePipeline(prototype) {
-  declared.add(prototype);
-}
-function parserOf(definition) {
-  const pipeline = definition;
-  if (pipeline.parse !== AbstractDefineProperty.prototype.parse) {
-    return;
-  }
-  if (!declared.has(Object.getPrototypeOf(definition)) || pipeline.handle !== PASS.handle || Object.hasOwn(definition, "preHandle") || Object.hasOwn(definition, "afterHandle")) {
-    return (value) => pipeline.attemptWithoutThrowing(value);
-  }
-  const { name, optional, schema } = pipeline.type;
-  const { match, matchShape } = checksOfSchema(schema);
-  const preHandle = pipeline.preHandle === PASS.preHandle ? undefined : pipeline.preHandle;
-  const afterHandle = pipeline.afterHandle === PASS.afterHandle ? undefined : pipeline.afterHandle;
-  return (value) => {
-    if (value === undefined) {
-      return optional ? value : reject(new Failure(name, undefined, undefined));
-    }
-    try {
-      if (preHandle !== undefined) {
-        if (!matchShape(value))
-          return pipeline.mismatch(value);
-        value = preHandle.call(pipeline, value);
-      }
-      if (!match(value))
-        return pipeline.mismatch(value);
-      return afterHandle === undefined ? value : afterHandle.call(pipeline, value);
-    } catch (error) {
-      return pipeline.raise(error instanceof Exception2 ? error : pipeline.invalidValue(error));
-    }
-  };
-}
-
-// src/core/record/name.ts
-var RECORD_NAME = /^[A-Za-z_$][\w$]*$/;
-function isRecordName(name) {
-  return typeof name === "string" && RECORD_NAME.test(name);
-}
-function recordNameOf2(Class) {
-  const { recordName, name } = Class;
-  return typeof recordName === "string" ? recordName : String(name);
-}
-var declaredNames = new WeakMap;
-function declareRecordName(Class, name) {
-  declaredNames.set(Class, name);
-}
-function declaredRecordNameOf(Class) {
-  for (let current = Class;typeof current === "function"; current = Object.getPrototypeOf(current)) {
-    const own = Object.getOwnPropertyDescriptor(current, "recordName")?.value;
-    if (typeof own === "string")
-      return own;
-    const declared = declaredNames.get(current);
-    if (declared !== undefined)
-      return declared;
-  }
-  return;
-}
-
-// src/core/parse/parse.ts
-var entriesOf = new WeakMap;
-function fieldsOf(properties) {
-  let entries = entriesOf.get(properties);
-  if (!entries) {
-    entries = Object.entries(properties);
-    entriesOf.set(properties, entries);
-  }
-  return entries;
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-var PROPERTY = 0;
-var LIST = 1;
-var BLUEPRINT = 2;
-var RECORD = 3;
-var UNDECLARED_FIELD = 4;
-var VARIANT = 5;
-function stepOf(field) {
-  const record = recordFieldOf(field);
-  const kind = isBlueprintList(field) ? LIST : isBlueprint(field) ? BLUEPRINT : isBlueprintVariant(field) ? VARIANT : record ? RECORD : isProperty(field) ? PROPERTY : UNDECLARED_FIELD;
-  return {
-    kind,
-    property: kind === PROPERTY ? field : undefined,
-    parser: undefined,
-    list: kind === LIST ? field : undefined,
-    item: undefined,
-    blueprint: kind === BLUEPRINT ? field : undefined,
-    collection: undefined,
-    record: kind === RECORD ? record?.record : undefined,
-    optionalRecord: kind === RECORD && record?.optional === true,
-    variant: kind === VARIANT ? field : undefined,
-    variants: undefined
-  };
-}
-var UNDECLARED = {
-  kind: UNDECLARED_FIELD,
-  property: undefined,
-  parser: undefined,
-  list: undefined,
-  item: undefined,
-  blueprint: undefined,
-  collection: undefined,
-  record: undefined,
-  optionalRecord: false,
-  variant: undefined,
-  variants: undefined
-};
-var steps = new WeakMap;
-function keptStepOf(field) {
-  if (typeof field !== "object" && typeof field !== "function" || field === null) {
-    return UNDECLARED;
-  }
-  let step = steps.get(field);
-  if (!step) {
-    step = stepOf(field);
-    steps.set(field, step);
-  }
-  return step;
-}
-var collections = new WeakMap;
-function collectionOf(properties) {
-  let collection = collections.get(properties);
-  if (!collection) {
-    const fields = fieldsOf(properties);
-    collection = {
-      properties,
-      names: fields.map(([name]) => name),
-      steps: fields.map(([, field]) => keptStepOf(field))
-    };
-    collections.set(properties, collection);
-  }
-  return collection;
-}
-function runOf(base, source) {
-  return { source, base, keys: [], issues: undefined };
-}
-function pathOf(run, depth) {
-  const { base, keys } = run;
-  const path = base.length === 0 ? [] : [...base];
-  for (let index = 0;index < depth; index++) {
-    path.push(keys[index]);
-  }
-  return path;
-}
-function reject2(run, code, message, path) {
-  run.issues ??= [];
-  run.issues.push({ code, message, path, source: run.source });
-  return REJECTED;
-}
-function resultOf(run, handled) {
-  return handled === REJECTED ? { issues: run.issues ?? [] } : { value: handled };
-}
-var ROOT = Object.freeze([]);
-function collectionParserOf(properties, source) {
-  let collection;
-  return (value, vouched) => {
-    collection ??= collectionOf(properties);
-    const run = runOf(ROOT, source);
-    return resultOf(run, collectionAt(collection, value, run, 0, vouched));
-  };
-}
-function collectionAt(collection, value, run, depth, vouched, tag) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return reject2(run, "invalid_type", "must be an object", pathOf(run, depth));
-  }
-  const { properties, names, steps } = collection;
-  let rejected = false;
-  const keys = Object.keys(value);
-  for (let index = 0;index < keys.length; index++) {
-    const name = keys[index];
-    if (name === names[index] || name === tag || Object.hasOwn(properties, name)) {
-      continue;
-    }
-    rejected = true;
-    reject2(run, "undeclared_key", "is not declared", [
-      ...pathOf(run, depth),
-      name
-    ]);
-  }
-  const handled = tag === undefined ? {} : { [tag]: value[tag] };
-  for (let index = 0;index < names.length; index++) {
-    const name = names[index];
-    if (vouched?.includes(name)) {
-      handled[name] = value[name];
-      continue;
-    }
-    run.keys[depth] = name;
-    const item = fieldAt(steps[index], value[name], run, depth + 1);
-    if (item === REJECTED)
-      rejected = true;
-    else if (item !== undefined)
-      handled[name] = item;
-  }
-  return rejected ? REJECTED : Object.freeze(handled);
-}
-function parseField(field, value, path, source) {
-  const run = runOf(path, source);
-  return resultOf(run, fieldAt(keptStepOf(field), value, run, 0));
-}
-var DECLARED_SAFE_PARSE = AbstractProperty.safeParse;
-function fieldAt(step, value, run, depth) {
-  switch (step.kind) {
-    case PROPERTY:
-      return propertyAt(step, value, run, depth);
-    case LIST: {
-      const list = step.list;
-      if (value === undefined) {
-        return list.optional ? value : required(run, depth);
-      }
-      if (!Array.isArray(value)) {
-        return reject2(run, "invalid_type", "must be an array", pathOf(run, depth));
-      }
-      const { minItems, maxItems } = list;
-      let rejected = false;
-      if (minItems !== undefined && value.length < minItems || maxItems !== undefined && value.length > maxItems) {
-        rejected = true;
-        const path = pathOf(run, depth);
-        if (minItems !== undefined && value.length < minItems) {
-          reject2(run, "too_few_items", `must have at least ${minItems} items`, path);
-        }
-        if (maxItems !== undefined && value.length > maxItems) {
-          reject2(run, "too_many_items", `must have at most ${maxItems} items`, path);
-        }
-      }
-      step.item ??= keptStepOf(list.item);
-      const { item } = step;
-      const items = [];
-      for (let index = 0;index < value.length; index++) {
-        run.keys[depth] = index;
-        const handled = fieldAt(item, value[index], run, depth + 1);
-        if (handled === REJECTED)
-          rejected = true;
-        else
-          items.push(handled);
-      }
-      return rejected ? REJECTED : Object.freeze(items);
-    }
-    case BLUEPRINT: {
-      const blueprint = step.blueprint;
-      if (value === undefined) {
-        return blueprint.optional ? value : required(run, depth);
-      }
-      step.collection ??= collectionOf(blueprint.properties);
-      return collectionAt(step.collection, value, run, depth);
-    }
-    case VARIANT: {
-      const variant = step.variant;
-      if (value === undefined) {
-        return variant.optional ? value : required(run, depth);
-      }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return reject2(run, "invalid_type", "must be an object", pathOf(run, depth));
-      }
-      let { variants } = step;
-      if (variants === undefined) {
-        variants = new Map;
-        const declared = variant.variants;
-        for (const tag of Object.keys(declared)) {
-          const one = declared[tag];
-          variants.set(tag, isBlueprint(one) ? collectionOf(one.properties) : one);
-        }
-        step.variants = variants;
-      }
-      if (!isPlainObject(value)) {
-        for (const one of variants.values()) {
-          if (typeof one === "function" && value instanceof one)
-            return value;
-        }
-      }
-      const { key } = variant;
-      const tag = value[key];
-      const named = typeof tag === "string" ? variants.get(tag) : undefined;
-      if (named === undefined) {
-        return reject2(run, "invalid_value", "must be equal to one of the allowed values", [...pathOf(run, depth), key]);
-      }
-      if (typeof named !== "function") {
-        return collectionAt(named, value, run, depth, undefined, key);
-      }
-      const { [key]: _name, ...input } = value;
-      const result = named.safeParse(input);
-      if (!result.issues)
-        return result.value;
-      const path = pathOf(run, depth);
-      run.issues ??= [];
-      for (const issue of result.issues) {
-        run.issues.push(movedIssue(issue, [...path, ...issue.path]));
-      }
-      return REJECTED;
-    }
-    case RECORD: {
-      const Record = step.record;
-      if (value === undefined) {
-        return step.optionalRecord ? value : required(run, depth);
-      }
-      if (value instanceof Record)
-        return value;
-      if (!isPlainObject(value)) {
-        return reject2(run, "not_record", `must be an instance of record "${recordNameOf2(Record)}"`, pathOf(run, depth));
-      }
-      const result = Record.safeParse(value);
-      if (!result.issues)
-        return result.value;
-      const path = pathOf(run, depth);
-      run.issues ??= [];
-      for (const issue of result.issues) {
-        run.issues.push(movedIssue(issue, [...path, ...issue.path]));
-      }
-      return REJECTED;
-    }
-    default:
-      return reject2(run, "undeclared_key", "is not declared", pathOf(run, depth));
-  }
-}
-function required(run, depth) {
-  return reject2(run, "required", "is required", pathOf(run, depth));
-}
-function propertyAt(step, value, run, depth) {
-  const property = step.property;
-  if (property.safeParse === DECLARED_SAFE_PARSE) {
-    let { parser } = step;
-    if (parser === undefined) {
-      parser = parserOf(parsingDefinitionOf(property)) ?? null;
-      step.parser = parser;
-    }
-    if (parser !== null) {
-      const handled = parser(value);
-      if (handled !== REJECTED)
-        return handled;
-      run.issues ??= [];
-      takeRejectionIssues(pathOf(run, depth), run.issues);
-      return REJECTED;
-    }
-  }
-  const result = property.safeParse(value);
-  if (!result.issues)
-    return result.value;
-  const path = pathOf(run, depth);
-  run.issues ??= [];
-  if (result.issues.some((issue) => Object.isFrozen(issue))) {
-    for (const issue of result.issues) {
-      run.issues.push(movedIssue(issue, [...path, ...issue.path]));
-    }
-  } else {
-    for (const issue of result.issues) {
-      issue.path = [...path, ...issue.path];
-      run.issues.push(issue);
-    }
-  }
-  return REJECTED;
-}
-
-// src/core/blueprint/list.ts
-function listOf2(item, { minItems, maxItems } = {}) {
-  return standardListOf({
-    [Kind2]: "list",
-    item: fieldOf(item),
-    optional: false,
-    minItems,
-    maxItems
-  });
-}
-function standardListOf(list) {
-  return Object.freeze(withStandard(list, (value) => parseField(list, value, [], "list")));
-}
-function isBlueprintList(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "list";
-}
-
-// src/core/environment/environment.ts
-var InvalidEnvironment2 = exceptionOf2({
-  layer: "environment" /* Environment */,
-  name: "InvalidEnvironment",
-  message: ({ keys }) => `Invalid environment variables: ${keys.join(", ")}.`
-});
-var processEnv = () => globalThis.process?.env ?? {};
-function environmentOf2(blueprint, { source = processEnv } = {}) {
-  if (!isBlueprint(blueprint) || blueprint.optional) {
-    throw new TypeError("An environment requires a blueprint");
-  }
-  let value;
-  return Object.freeze({
-    [Kind2]: "environment",
-    blueprint,
-    load() {
-      if (value !== undefined)
-        return value;
-      value = parseEnvironment(blueprint, source());
-      return value;
-    }
-  });
-}
-function parseEnvironment(blueprint, variables) {
-  const declared = {};
-  for (const [key, field] of Object.entries(blueprint.properties)) {
-    const variable = variables[key];
-    if (variable !== undefined)
-      declared[key] = convert(field, variable);
-  }
-  const parsed = blueprint.safeParse(declared);
-  if (!parsed.issues)
-    return Object.freeze(parsed.value);
-  const issues = parsed.issues;
-  throw new InvalidEnvironment2({
-    source: "environment",
-    details: {
-      keys: [...new Set(issues.map((issue) => String(issue.path[0] ?? "")))]
-    },
-    cause: issues.find((issue) => issue.cause)?.cause
-  });
-}
-function convert(field, variable) {
-  if (!isProperty(field))
-    return variable;
-  const { schema } = field.type;
-  if (schema.matchShape(variable))
-    return variable;
-  const text = variable.trim();
-  if (text === "true" || text === "false") {
-    if (schema.matchShape(text === "true"))
-      return text === "true";
-  }
-  const number = text === "" ? Number.NaN : Number(text);
-  if (Number.isFinite(number) && schema.matchShape(number))
-    return number;
-  return variable;
-}
-function loadEnvironments(dependencies) {
-  if (dependencies === undefined)
-    return Object.freeze({});
-  const list = isEnvironment(dependencies) ? [dependencies] : dependencies;
-  return Object.freeze(Object.assign({}, ...list.map((environment) => environment.load())));
-}
-function isEnvironment(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "environment";
-}
-
-// src/core/application/exceptions.ts
-var InvalidApplicationDeclaration2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "InvalidApplicationDeclaration",
-  message: ({ reason }) => reason
-});
-var DuplicateApplicationDeclaration2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "DuplicateApplicationDeclaration",
-  message: ({
-    first,
-    second
-  }) => `The same object is registered as ${first} and as ${second}.`
-});
-var ApplicationConflict2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "ApplicationConflict",
-  message: ({
-    reason
-  }) => reason
-});
-var UnregisteredApplicationReference2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "UnregisteredApplicationReference",
-  message: ({
-    holder,
-    reference
-  }) => `${holder} holds ${reference}, which is not registered in the application.`
-});
-var UnregisteredRepositoryDependency2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "UnregisteredRepositoryDependency",
-  message: ({
-    repository,
-    dependency
-  }) => `Repository ${repository} depends on ${dependency}, which is not registered in the application.`
-});
-var UnregisteredUseCaseDependency2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "UnregisteredUseCaseDependency",
-  message: ({
-    useCase,
-    dependency
-  }) => `Use case ${useCase} depends on ${dependency}, which is not registered in the application.`
-});
-var ApplicationNotStarted2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "ApplicationNotStarted",
-  message: ({
-    application
-  }) => application === undefined ? "No application is started: call await app.start() first." : `The application "${application}" is not started: call await app.start() first.`
-});
-var ProviderNotBound2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "ProviderNotBound",
-  message: ({
-    provider
-  }) => `The provider "${provider}" is made by an application: register its storage in applicationOf({ providers }) and call the repository through the application.`
-});
-var ApplicationAlreadyStarted2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "ApplicationAlreadyStarted",
-  message: ({
-    current,
-    attempted
-  }) => `The application "${current}" is already started, so "${attempted}" cannot be: stop it, or call start({ replace: true }).`
-});
-var SchemaLockMismatch2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "SchemaLockMismatch",
-  message: ({ problems }) => `The application does not match its schema lock: ${problems.join(" ")}`
-});
-var InvalidSchemaMigration2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "InvalidSchemaMigration",
-  message: ({ reason }) => reason
-});
-var InvalidApplicationEnvironment2 = exceptionOf2({
-  layer: "environment" /* Environment */,
-  name: "InvalidApplicationEnvironment",
-  message: ({
-    environments
-  }) => `Invalid environment variables: ${Object.entries(environments).map(([name, keys]) => `${name} (${keys.join(", ")})`).join("; ")}.`
-});
-
-// src/core/application/registry.ts
-var SLOT = Symbol.for("afora.application");
-function slot() {
-  const global = globalThis;
-  global[SLOT] ??= { current: undefined };
-  return global[SLOT];
-}
-function useApplication2() {
-  const { current } = slot();
-  if (current === undefined) {
-    throw new ApplicationNotStarted2({ source: "useApplication", details: {} });
-  }
-  return current;
-}
-function resetApplication2() {
-  slot().current = undefined;
-}
-function startedApplication() {
-  return slot().current;
-}
-function setStartedApplication(application) {
-  slot().current = application;
-}
-
-// src/core/logger/exceptions.ts
-var InvalidLogDeclaration2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "InvalidLogDeclaration",
-  message: ({ reason }) => reason
-});
-
-// src/core/logger/logger.ts
-var LogLevels2 = Object.freeze([
-  "debug",
-  "info",
-  "warn",
-  "error"
-]);
-var names = new WeakMap;
-var invalid = (reason) => {
-  throw new InvalidLogDeclaration2({ source: "log", details: { reason } });
-};
-function logProviderOf2(settings) {
-  if (!settings || typeof settings.write !== "function") {
-    invalid("Expected a log provider with a write function.");
-  }
-  if (settings.flush !== undefined && typeof settings.flush !== "function") {
-    invalid("Expected flush to be a function.");
-  }
-  if (settings.name !== undefined && (typeof settings.name !== "string" || settings.name.trim() === "")) {
-    invalid("Expected the name of a log provider to be a non-empty string.");
-  }
-  const provider = Object.freeze({
-    write: settings.write,
-    ...settings.flush ? { flush: settings.flush } : {}
-  });
-  if (settings.name)
-    names.set(provider, settings.name);
-  return provider;
-}
-function logProviderNameOf(provider) {
-  return names.get(provider);
-}
-var fieldsText = (fields) => Object.keys(fields).length > 0 ? ` ${JSON.stringify(fields)}` : "";
-function consoleLogProvider2() {
-  return logProviderOf2({
-    name: "console",
-    write: ({ at, level, event, fields, application }) => {
-      const line = `${at} ${level.toUpperCase()} [${application}] ${event}${fieldsText(fields)}`;
-      (level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error)(line);
-    }
-  });
-}
-function jsonLogProvider2() {
-  return logProviderOf2({
-    name: "json",
-    write: (entry) => {
-      console.log(JSON.stringify({
-        at: entry.at,
-        level: entry.level,
-        application: entry.application,
-        event: entry.event,
-        ...entry.fields
-      }));
-    }
-  });
-}
-function memoryLogProvider2() {
-  const entries = [];
-  const provider = Object.freeze({
-    write: (entry) => {
-      entries.push(entry);
-    },
-    entries,
-    clear: () => {
-      entries.length = 0;
-    }
-  });
-  names.set(provider, "memory");
-  return provider;
-}
-function checkLogSettings(settings) {
-  if (typeof settings !== "object" || settings === null) {
-    return invalid("Expected `log` to be { level?, providers }.");
-  }
-  const { level = "info", providers } = settings;
-  if (!LogLevels2.includes(level)) {
-    invalid(`Expected the log level to be one of ${LogLevels2.join(", ")}.`);
-  }
-  if (!Array.isArray(providers) || providers.some((provider) => typeof provider !== "object" || provider === null || typeof provider.write !== "function")) {
-    invalid("Expected `log.providers` to be a list of log providers.");
-  }
-  return Object.freeze({ level, providers: Object.freeze([...providers]) });
-}
-var silentLogger = Object.freeze({
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {}
-});
-var rank = (level) => LogLevels2.indexOf(level);
-function applicationLogger(application) {
-  let current;
-  const write = (level) => (event, fields = {}) => {
-    if (!current || rank(level) < rank(current.level))
-      return;
-    const entry = Object.freeze({
-      at: new Date().toISOString(),
-      level,
-      event,
-      fields,
-      application
-    });
-    for (const provider of current.providers) {
-      try {
-        const written = provider.write(entry);
-        if (written && typeof written.catch === "function") {
-          written.catch(() => {});
-        }
-      } catch {}
-    }
-  };
-  const logger = Object.freeze({
-    debug: write("debug"),
-    info: write("info"),
-    warn: write("warn"),
-    error: write("error")
-  });
-  return {
-    logger,
-    get settings() {
-      return current;
-    },
-    set(settings) {
-      current = settings;
-    },
-    async flush() {
-      await Promise.all((current?.providers ?? []).map((provider) => Promise.resolve().then(() => provider.flush?.()).catch(() => {})));
-    }
-  };
-}
-var Logger2 = Object.freeze({
-  [Kind2]: "logger"
-});
-function isLoggerDeclaration(value) {
-  return value === Logger2;
-}
-function isLogger(value) {
-  return typeof value === "object" && value !== null && ["debug", "info", "warn", "error"].every((level) => typeof value[level] === "function");
-}
-var ApplicationLoggerKey = Symbol("afora.application.logger");
-function resolveLogger(scoped, owner) {
-  return scoped ?? owner?.[ApplicationLoggerKey] ?? startedApplication()?.[ApplicationLoggerKey];
-}
-function clock() {
-  return globalThis.performance?.now() ?? Date.now();
-}
-function elapsed(since) {
-  return Math.round(clock() - since);
-}
-var logged = new WeakSet;
-function logFailure(logger, event, fields, error) {
-  if (!logger)
-    return;
-  const exception = error instanceof Exception2 ? error : undefined;
-  const key = exception?.origin ?? error;
-  if (typeof key === "object" && key !== null) {
-    if (logged.has(key))
-      return;
-    logged.add(key);
-  }
-  const unexpected = !exception || exception.origin.name === UNEXPECTED_ERROR;
-  try {
-    logger[unexpected ? "error" : "warn"](event, {
-      ...fields,
-      exception: exception ? exception.toJSON() : { message: error instanceof Error ? error.message : String(error) }
-    });
-  } catch {}
-}
-function writeLog(logger, level, event, fields) {
-  if (!logger)
-    return;
-  try {
-    logger[level](event, fields);
-  } catch {}
-}
-
-// src/core/symbols/meta.ts
-var Meta2 = Symbol("meta");
-
-// src/core/record/exceptions.ts
-var InvalidRecordValue2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "InvalidRecordValue",
-  message: ({
-    key,
-    errors
-  }, source) => `Invalid value for ${key ? `"${key}" of ` : ""}record "${source}": ${errors.join("; ")}`
-});
-var InvalidRecordDeclaration2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "InvalidRecordDeclaration",
-  message: (reason, source) => `Invalid declaration of record "${source}": ${reason}`
-});
-var UndeclaredRecordProperty2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "UndeclaredRecordProperty",
-  message: ({ key }, source) => `Property "${key}" is not declared in record "${source}".`
-});
-var ReservedRecordKey2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "ReservedRecordKey",
-  message: ({ key }, source) => `"${key}" is a member of record "${source}" and cannot be a key of its blueprint.`
-});
-var InvalidRecordPlugin2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "InvalidRecordPlugin",
-  message: ({ reason }, source) => `Invalid record plugin "${source}": ${reason}.`
-});
-var RecordPluginConflict2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "RecordPluginConflict",
-  message: ({
-    plugin,
-    key,
-    owner
-  }, source) => `Plugin "${plugin}" of record "${source}" adds "${key}", which ${owner} already has.`
-});
-var UnknownRecordPlugin2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "UnknownRecordPlugin",
-  message: ({ name }) => `No record plugin named "${name}" in the catalog.`
-});
-var IncompatibleRecordPlugin2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "IncompatibleRecordPlugin",
-  message: ({ reason }, source) => `Record plugin "${source}" does not satisfy the reference: ${reason}.`
-});
-
-// src/core/record/marks.ts
-function isMarked(field, mark, { lists = false } = {}) {
-  if (lists && isBlueprintList(field))
-    return isMarked(field.item, mark, { lists });
-  return isProperty(field) && field.type[mark] === true;
-}
-
-// src/core/record/mask.ts
-var MASK2 = "********";
-function maskAll(value) {
-  if (value === undefined || value === null)
-    return value;
-  if (Array.isArray(value))
-    return Object.freeze(value.map(maskAll));
-  if (typeof value === "object" && isRecordClass(value.constructor)) {
-    return maskAll(value.toJSON());
-  }
-  if (typeof value === "object") {
-    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, maskAll(item)])));
-  }
-  return MASK2;
-}
-function maskField(field, value, sensitive) {
-  if (value === undefined)
-    return value;
-  if (isBlueprintVariant(field)) {
-    const name = variantNameOf(field, value);
-    if (name !== undefined) {
-      const json = Object.freeze({
-        [field.key]: name,
-        ...value.toJSON()
-      });
-      return sensitive ? maskAll(json) : json;
-    }
-  }
-  if (recordFieldOf(field)) {
-    const json = value.toJSON();
-    return sensitive ? maskAll(json) : json;
-  }
-  if (sensitive || isMarked(field, "sensitive"))
-    return maskAll(value);
-  if (isBlueprintList(field) && Array.isArray(value)) {
-    return Object.freeze(value.map((item) => maskField(field.item, item, false)));
-  }
-  if (isBlueprint(field) && typeof value === "object" && value !== null) {
-    return maskCollection(field.properties, value);
-  }
-  if (isBlueprintVariant(field)) {
-    const variant = variantOfValue(field, value);
-    return variant ? maskCollection(variant.properties, value) : value;
-  }
-  return value;
-}
-function maskCollection(properties, value, sensitive = []) {
-  return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    maskField(properties[key], item, sensitive.includes(key))
-  ])));
-}
-
-// src/core/record/abstract-record.ts
-var values = new WeakMap;
-var metadata = new WeakMap;
-var RESERVED_RECORD_KEYS2 = Object.freeze([
-  "onSet",
-  "onSetAll",
-  "set",
-  "toJSON",
-  "toString",
-  "toLocaleString",
-  "valueOf",
-  "hasOwnProperty",
-  "propertyIsEnumerable",
-  "isPrototypeOf",
-  "__defineGetter__",
-  "__defineSetter__",
-  "__lookupGetter__",
-  "__lookupSetter__",
-  "__proto__",
-  "constructor"
-]);
-function exposeRecordKeys(prototype, keys) {
-  for (const key of keys) {
-    Object.defineProperty(prototype, key, {
-      get() {
-        return values.get(this)?.[key];
-      },
-      enumerable: true,
-      configurable: true
-    });
-  }
-}
-var checked = new WeakSet;
-function checkMembers(record, properties) {
-  const Class = record.constructor;
-  if (checked.has(Class))
-    return;
-  const keys = Object.keys(properties);
-  for (let prototype = Object.getPrototypeOf(record);prototype !== null && !Object.hasOwn(prototype.constructor, "blueprint"); prototype = Object.getPrototypeOf(prototype)) {
-    const key = Object.getOwnPropertyNames(prototype).find((name) => keys.includes(name));
-    if (key !== undefined) {
-      throw new ReservedRecordKey2({
-        source: recordNameOf2(Class),
-        details: { key }
-      });
-    }
-  }
-  checked.add(Class);
-}
-var vouched;
-function vouchFor(keys) {
-  vouched = keys;
-}
-var constructions = new WeakMap;
-function constructionOf(record) {
-  const Class = record.constructor;
-  let construction = constructions.get(Class);
-  if (!construction) {
-    const { properties } = record[Meta2].blueprint;
-    checkMembers(record, properties);
-    const source = recordNameOf2(Class);
-    construction = { source, parse: collectionParserOf(properties, source) };
-    constructions.set(Class, construction);
-  }
-  return construction;
-}
-function withIssues(details, issues) {
-  return Object.defineProperty(details, "issues", {
-    value: Object.freeze([...issues]),
-    enumerable: false
-  });
-}
-function exceptionOfIssues(issues, source) {
-  const [first] = issues;
-  const key = first.path.join(".");
-  if (first.cause) {
-    return first.cause.propagate({
-      layer: "record" /* Record */,
-      source,
-      details: withIssues({ key }, issues)
-    });
-  }
-  if (first.code === "undeclared_key") {
-    return new UndeclaredRecordProperty2({
-      source,
-      details: withIssues({ key }, issues)
-    });
-  }
-  return new InvalidRecordValue2({
-    source,
-    details: withIssues({ key, errors: [first.message] }, issues)
-  });
-}
-function issuesOfError(error, source) {
-  const issues = error?.details?.issues;
-  if (error instanceof Exception2 && issues)
-    return issues;
-  const cause = Exception2.from(error, {
-    layer: "record" /* Record */,
-    source
-  });
-  return [
-    {
-      code: "invalid_value",
-      message: cause.message,
-      path: [],
-      source,
-      cause
-    }
-  ];
-}
-var request;
-function exceptionOfRejection(rejection) {
-  rejection.exception ??= exceptionOfIssues(rejection.issues, rejection.source);
-  return rejection.exception;
-}
-var REJECTION_HANDLER = {
-  get: (rejection, key) => Reflect.get(exceptionOfRejection(rejection), key),
-  set: (rejection, key, value) => Reflect.set(exceptionOfRejection(rejection), key, value),
-  has: (rejection, key) => Reflect.has(exceptionOfRejection(rejection), key),
-  getPrototypeOf: (rejection) => Reflect.getPrototypeOf(exceptionOfRejection(rejection)),
-  ownKeys: (rejection) => Reflect.ownKeys(exceptionOfRejection(rejection)),
-  getOwnPropertyDescriptor: (rejection, key) => {
-    const descriptor = Reflect.getOwnPropertyDescriptor(exceptionOfRejection(rejection), key);
-    return descriptor && { ...descriptor, configurable: true };
-  }
-};
-function parseRecord(Class, value) {
-  if (value instanceof Class)
-    return { value };
-  const outer = request;
-  const own = { Class };
-  request = own;
-  try {
-    return { value: new Class(value) };
-  } catch (error) {
-    if (own.issues !== undefined && own.rejection === error) {
-      return { issues: own.issues };
-    }
-    return { issues: issuesOfError(error, recordNameOf2(Class)) };
-  } finally {
-    request = outer;
-  }
-}
-function recordValue(record) {
-  return values.get(record);
-}
-function recordDataOf(record, options) {
-  const { properties } = record[Meta2].blueprint;
-  return dataOfCollection(properties, values.get(record), options);
-}
-function dataOfCollection(properties, value, options) {
-  return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    recordFieldDataOf(properties[key], item, options)
-  ])));
-}
-function recordFieldDataOf(field, value, options) {
-  if (value === undefined || value === null)
-    return value;
-  if (isBlueprintVariant(field) && value instanceof AbstractRecord) {
-    const name = variantNameOf(field, value);
-    if (name !== undefined) {
-      const reference = options?.reference?.(value);
-      return Object.freeze(reference === undefined ? { [field.key]: name, ...recordDataOf(value, options) } : { [field.key]: name, id: reference });
-    }
-  }
-  if (value instanceof AbstractRecord) {
-    return options?.reference?.(value) ?? recordDataOf(value, options);
-  }
-  if (isBlueprintList(field) && Array.isArray(value)) {
-    return Object.freeze(value.map((item) => recordFieldDataOf(field.item, item, options)));
-  }
-  if (isBlueprint(field) && typeof value === "object") {
-    return dataOfCollection(field.properties, value, options);
-  }
-  if (isBlueprintVariant(field)) {
-    const variant = variantOfValue(field, value);
-    return variant ? dataOfCollection(variant.properties, value, options) : value;
-  }
-  return value;
-}
-function storeRecordValue(record, key, value) {
-  const source = recordNameOf2(record.constructor);
-  const { properties } = record[Meta2].blueprint;
-  if (!Object.hasOwn(properties, key)) {
-    throw exceptionOfIssues([
-      {
-        code: "undeclared_key",
-        message: "is not declared",
-        path: [key],
-        source
-      }
-    ], source);
-  }
-  const current = values.get(record);
-  const previous = current[key];
-  const result = parseField(properties[key], value, [key], source);
-  if (result.issues)
-    throw exceptionOfIssues(result.issues, source);
-  const next = result.value;
-  const { [key]: _, ...rest } = current;
-  values.set(record, Object.freeze(next === undefined ? rest : { ...rest, [key]: next }));
-  return { next, previous };
-}
-var RecordPluginHooks = Symbol("recordPluginHooks");
-function runRecordEffects(record, key, next, previous) {
-  const pluginHooks = record.constructor[RecordPluginHooks];
-  if (pluginHooks !== undefined && pluginHooks.length > 0) {
-    const name = String(key);
-    for (const hook of pluginHooks) {
-      if (!hook.keys.includes(name))
-        continue;
-      hook.onSetAll?.call(record, { key, value: next, previous });
-      hook.onSet?.call(record)[name]?.call(record, next, previous);
-    }
-  }
-  const hooks = record;
-  hooks.onSetAll({ key, value: next, previous });
-  hooks.onSet()[key]?.(next, previous);
-  return record;
-}
-
-class AbstractRecord {
-  get [Meta2]() {
-    const Class = this.constructor;
-    let declaration = metadata.get(Class);
-    if (!declaration) {
-      const { blueprint, options } = Class;
-      declaration = Object.freeze({ blueprint, options });
-      metadata.set(Class, declaration);
-    }
-    return declaration;
-  }
-  constructor(value) {
-    let asked;
-    if (request !== undefined && request.Class === this.constructor) {
-      asked = request;
-      request = undefined;
-    }
-    const made = vouched;
-    vouched = undefined;
-    const { source, parse } = constructionOf(this);
-    const result = parse(value, made);
-    if (result.issues) {
-      if (asked === undefined)
-        throw exceptionOfIssues(result.issues, source);
-      asked.issues = result.issues;
-      asked.rejection = new Proxy({ issues: asked.issues, source }, REJECTION_HANDLER);
-      throw asked.rejection;
-    }
-    values.set(this, result.value);
-  }
-  static safeParse(value) {
-    return parseRecord(this, value);
-  }
-  static get "~standard"() {
-    return standardOfClass(this);
-  }
-  toJSON() {
-    return maskCollection(this[Meta2].blueprint.properties, recordValue(this), this[Meta2].options.sensitive);
-  }
-  set(key, value) {
-    const { next, previous } = storeRecordValue(this, String(key), value);
-    return runRecordEffects(this, key, next, previous);
-  }
-  onSetAll(_change) {}
-  onSet() {
-    return {};
-  }
-}
-
-// src/core/blueprint/blueprint.ts
-import { Type as Type3 } from "typebox";
-
-// src/core/property/property.ts
-import { Type } from "typebox";
-function propertyOf2({
-  name,
-  schema,
-  optional,
-  sensitive = false,
-  unique = false,
-  default: _default,
-  preHandle: onPreHandle,
-  afterHandle: onAfterHandle
-}) {
-  const valueSchema = optional ? Type.Optional(schema) : schema;
-  const SchemaConstructor = schemaOf(name, valueSchema);
-  const type = {
-    [Demo2]: _default,
-    name,
-    schema: new SchemaConstructor,
-    optional: optional ?? false,
-    sensitive,
-    unique
-  };
-
-  class DefineProperty extends AbstractDefineProperty {
-    get type() {
-      return type;
-    }
-  }
-  const steps = DefineProperty.prototype;
-  if (onPreHandle)
-    steps.preHandle = (value) => onPreHandle(value);
-  if (onAfterHandle)
-    steps.afterHandle = (value) => onAfterHandle(value);
-  declarePipeline(DefineProperty.prototype);
-
-  class Property extends AbstractProperty {
-    static type = type;
-    createDefinition() {
-      return new DefineProperty;
-    }
-  }
-  return Property;
-}
-
-// src/core/blueprint/optional.ts
-import { Type as Type2 } from "typebox";
-var cache2 = new WeakMap;
-function optionalOf2(given) {
-  const field = fieldOf(given);
-  const cached = cache2.get(field);
-  if (cached)
-    return cached;
-  if (isOptionalRecord(field))
-    return field;
-  if (isRecordClass(field)) {
-    const optional = Object.freeze(withStandard({
-      [Kind2]: "record",
-      record: field,
-      optional: true
-    }, (value) => value === undefined ? { value } : field.safeParse(value)));
-    cache2.set(field, optional);
-    return optional;
-  }
-  if (isBlueprint(field)) {
-    if (field.optional)
-      return field;
-    const optional = {
-      ...field,
-      optional: true,
-      safeParse: (value) => value === undefined ? { value } : field.safeParse(value)
-    };
-    Object.freeze(withStandard(optional, (value) => optional.safeParse(value)));
-    cache2.set(field, optional);
-    return optional;
-  }
-  if (isBlueprintList(field)) {
-    if (field.optional)
-      return field;
-    const optional = standardListOf({ ...field, optional: true });
-    cache2.set(field, optional);
-    return optional;
-  }
-  if (isBlueprintVariant(field)) {
-    if (field.optional)
-      return field;
-    const optional = standardVariantOf({ ...field, optional: true });
-    cache2.set(field, optional);
-    return optional;
-  }
-  const Property = field;
-  if (Property.type.optional)
-    return Property;
-  const base = Property.type;
-  const SchemaConstructor = schemaOf(base.name, Type2.Optional(base.schema.type.Type()));
-  const type = {
-    ...base,
-    schema: new SchemaConstructor,
-    optional: true
-  };
-  const Optional = derivePropertyOf(Property, type);
-  recordPropertyLineage(Optional, { kind: "optional", base: Property });
-  cache2.set(Property, Optional);
-  return Optional;
-}
-
-// src/core/blueprint/blueprint.ts
-function blueprintBuilderOf2(...base) {
-  return (sourcesOrDefine, maybeDefine) => {
-    const [sources, define] = typeof sourcesOrDefine === "function" ? [[], sourcesOrDefine] : [
-      sourcesOrDefine,
-      maybeDefine
-    ];
-    const all = [...base, ...sources];
-    return create(all.flatMap((source) => isBlueprint(source) ? source.plugins : [source]), { ...define(contextOf2(all)) });
-  };
-}
-function blueprintFromProperties(plugins, properties) {
-  return create(plugins, { ...properties });
-}
-function create(plugins, properties) {
-  const shape = {};
-  for (const [key, field] of Object.entries(properties)) {
-    properties[key] = fieldOf(field);
-    shape[key] = schemaOfField(key, properties[key]);
-  }
-  const SchemaConstructor = schemaOf("blueprint", Type3.Object(shape));
-  const safeParse = collectionParserOf(properties, "blueprint");
-  const blueprint = {
-    [Kind2]: "blueprint",
-    plugins: Object.freeze([...new Set(plugins)]),
-    properties: Object.freeze(properties),
-    schema: new SchemaConstructor,
-    optional: false,
-    safeParse,
-    join: (...others) => create([blueprint, ...others].flatMap((source) => source.plugins), Object.assign({}, ...[blueprint, ...others].map((source) => source.properties)))
-  };
-  return Object.freeze(withStandard(blueprint, safeParse));
-}
-var HELPERS = { listOf: listOf2, optionalOf: optionalOf2, propertyOf: propertyOf2, variantOf: variantOf2 };
-var RESERVED_KEYS = ["optional", "list", ...Object.keys(HELPERS)];
-function contextOf2(sources) {
-  for (const key of RESERVED_KEYS) {
-    const reserving = sources.find((source) => Object.hasOwn(source.properties, key));
-    if (reserving) {
-      throw new ReservedBlueprintKey2({
-        source: isBlueprint(reserving) ? "blueprint" : reserving.name,
-        details: { key }
-      });
-    }
-  }
-  const factories = Object.assign({}, ...sources.map((source) => isBlueprint(source) ? {} : source.factories ?? {}));
-  for (const key of RESERVED_KEYS) {
-    if (Object.hasOwn(factories, key)) {
-      const reserving = sources.find((source) => !isBlueprint(source) && Object.hasOwn(source.factories ?? {}, key));
-      throw new ReservedBlueprintKey2({
-        source: reserving.name,
-        details: { key }
-      });
-    }
-  }
-  const available = Object.assign({}, ...sources.map((source) => source.properties));
-  for (const key of Object.keys(factories))
-    delete available[key];
-  const mirror = (fields, map) => Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, map(field)]));
-  const list = mirror(available, (field) => listOf2(field));
-  const callable = (field) => isProperty(field) ? callableOf(field) : field;
-  return Object.freeze({
-    ...mirror(available, callable),
-    ...factories,
-    ...HELPERS,
-    optional: Object.freeze(mirror(available, (field) => callable(optionalOf2(field)))),
-    list: Object.freeze({
-      ...list,
-      optional: Object.freeze(mirror(list, optionalOf2))
-    })
-  });
-}
-function schemaOfField(key, field) {
-  if (isBlueprintList(field)) {
-    const { item, minItems, maxItems } = field;
-    const schema = Type3.Array(schemaOfField(key, item), {
-      ...minItems === undefined ? {} : { minItems },
-      ...maxItems === undefined ? {} : { maxItems }
-    });
-    return field.optional ? Type3.Optional(schema) : schema;
-  }
-  if (isBlueprint(field)) {
-    const schema = field.schema.type.Type();
-    return field.optional ? Type3.Optional(schema) : schema;
-  }
-  if (isBlueprintVariant(field)) {
-    const schema = Type3.Union(Object.entries(field.variants).map(([tag, variant]) => {
-      const object = blueprintOfVariant(variant).schema.type.Type();
-      return {
-        ...object,
-        properties: {
-          [field.key]: Type3.Literal(tag),
-          ...object.properties
-        },
-        required: [field.key, ...object.required ?? []]
-      };
-    }));
-    return field.optional ? Type3.Optional(schema) : schema;
-  }
-  const record = recordFieldOf(field);
-  if (record) {
-    const schema = record.record.blueprint.schema.type.Type();
-    return record.optional ? Type3.Optional(schema) : schema;
-  }
-  if (isProperty(field)) {
-    return field.type.schema.type.Type();
-  }
-  throw new UndeclaredBlueprintProperty2({
-    source: "blueprint",
-    details: { key }
-  });
-}
-
-// src/core/record/plugin.ts
-var RecordPlugins = Symbol("recordPlugins");
-var IdentifiedRecord = Symbol("identifiedRecord");
-var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-function isVersion(version) {
-  return typeof version === "string" && SEMVER.test(version);
-}
-function versionParts(version) {
-  const [, major, minor, patch] = SEMVER.exec(version);
-  return [Number(major), Number(minor), Number(patch)];
-}
-function satisfies(available, requested) {
-  const [major, minor, patch] = versionParts(available);
-  const [wantedMajor, wantedMinor, wantedPatch] = versionParts(requested);
-  if (major !== wantedMajor)
-    return false;
-  if (major === 0 && minor !== wantedMinor)
-    return false;
-  if (minor !== wantedMinor)
-    return minor > wantedMinor;
-  return patch >= wantedPatch;
-}
-var HOOKS = ["onSet", "onSetAll"];
-var internals = new WeakMap;
-function pluginsOf2(value) {
-  const Class = typeof value === "function" ? value : typeof value === "object" && value !== null ? value.constructor : undefined;
-  return Class?.[RecordPlugins] ?? [];
-}
-function isRecordPlugin(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "record-plugin";
-}
-function hasPlugin2(value, plugin) {
-  const plugins = pluginsOf2(value);
-  if (typeof plugin === "string") {
-    return plugins.some((applied) => applied.name === plugin);
-  }
-  if (plugins.includes(plugin))
-    return true;
-  return typeof value === "function" ? value === plugin.record || value.prototype instanceof plugin.record : value instanceof plugin.record;
-}
-function membersOf(Record, name) {
-  const descriptors = {};
-  const hooks = {};
-  for (let prototype = Record.prototype;prototype !== null && !Object.hasOwn(prototype.constructor, "blueprint"); prototype = Object.getPrototypeOf(prototype)) {
-    for (const member of Object.getOwnPropertyNames(prototype)) {
-      if (member === "constructor")
-        continue;
-      const descriptor = Object.getOwnPropertyDescriptor(prototype, member);
-      if (HOOKS.includes(member)) {
-        hooks[member] ??= descriptor.value;
-        continue;
-      }
-      if (RESERVED_RECORD_KEYS2.includes(member)) {
-        throw new InvalidRecordPlugin2({
-          source: name,
-          details: {
-            reason: `"${member}" is a member of every record and cannot be replaced`
-          }
-        });
-      }
-      descriptors[member] ??= descriptor;
-    }
-  }
-  return { descriptors: Object.freeze(descriptors), hooks };
-}
-function recordPluginOf2(name, Record, { version = "1.0.0", description } = {}) {
-  if (typeof name !== "string" || name.length === 0) {
-    throw new InvalidRecordPlugin2({
-      source: String(name),
-      details: { reason: "its name must be a non-empty string" }
-    });
-  }
-  if (!isRecordClass(Record)) {
-    throw new InvalidRecordPlugin2({
-      source: name,
-      details: { reason: "it must be made from a class of `recordOf`" }
-    });
-  }
-  if (Record[IdentifiedRecord]) {
-    throw new InvalidRecordPlugin2({
-      source: name,
-      details: {
-        reason: "it must be made from a record, not an entity: plugins have no identity"
-      }
-    });
-  }
-  if (!isVersion(version)) {
-    throw new InvalidRecordPlugin2({
-      source: name,
-      details: { reason: `"${version}" is not a semantic version` }
-    });
-  }
-  const requires = pluginsOf2(Record);
-  const inherited = new Set(requires.flatMap((required) => required.keys));
-  const declaration = Record;
-  const keys = Object.freeze(Object.keys(declaration.blueprint.properties).filter((key) => !inherited.has(key)));
-  const own = membersOf(Record, name);
-  const plugin = Object.freeze({
-    [Kind2]: "record-plugin",
-    name,
-    version,
-    ...description === undefined ? {} : { description },
-    record: Record,
-    keys,
-    members: Object.freeze(Object.keys(own.descriptors)),
-    options: declaration.options,
-    requires,
-    is: (value) => hasPlugin2(value, plugin),
-    toJSON: () => descriptorOf(plugin)
-  });
-  internals.set(plugin, own);
-  return plugin;
-}
-function descriptorOf(plugin) {
-  return Object.freeze({
-    kind: "record-plugin",
-    name: plugin.name,
-    version: plugin.version,
-    ...plugin.description === undefined ? {} : { description: plugin.description },
-    keys: plugin.keys,
-    sensitive: plugin.options.sensitive,
-    unique: plugin.options.unique,
-    change: plugin.options.change,
-    members: plugin.members,
-    requires: Object.freeze(plugin.requires.map(({ name, version }) => Object.freeze({ name, version })))
-  });
-}
-function applyPlugins(blueprint, plugins, name, reserved) {
-  const flat = [];
-  for (const plugin of plugins) {
-    if (!isRecordPlugin(plugin)) {
-      throw new InvalidRecordPlugin2({
-        source: name,
-        details: {
-          reason: "`options.plugins` takes plugins made by `recordPluginOf`"
-        }
-      });
-    }
-    for (const applied of [...plugin.requires, plugin]) {
-      if (flat.includes(applied))
-        continue;
-      if (flat.some((other) => other.name === applied.name)) {
-        throw new RecordPluginConflict2({
-          source: name,
-          details: {
-            plugin: applied.name,
-            key: applied.name,
-            owner: "another plugin"
-          }
-        });
-      }
-      flat.push(applied);
-    }
-  }
-  const owners = new Map(Object.keys(blueprint.properties).map((key) => [key, `record "${name}"`]));
-  for (const member of reserved)
-    owners.set(member, `record "${name}"`);
-  const claim = (plugin, key) => {
-    const owner = owners.get(key);
-    if (owner !== undefined) {
-      throw new RecordPluginConflict2({
-        source: name,
-        details: { plugin: plugin.name, key, owner }
-      });
-    }
-    owners.set(key, `plugin "${plugin.name}"`);
-  };
-  const descriptors = {};
-  const hooks = [];
-  for (const plugin of flat) {
-    for (const key of plugin.keys)
-      claim(plugin, key);
-    const own = internals.get(plugin);
-    for (const member of plugin.members) {
-      claim(plugin, member);
-      descriptors[member] = own.descriptors[member];
-    }
-    if (own.hooks.onSet || own.hooks.onSetAll) {
-      hooks.push(Object.freeze({
-        plugin,
-        keys: Object.freeze(Object.keys(plugin.record.blueprint.properties)),
-        ...own.hooks
-      }));
-    }
-  }
-  return {
-    blueprint: flat.length === 0 ? blueprint : blueprint.join(...flat.map((plugin) => plugin.record.blueprint)),
-    plugins: Object.freeze(flat),
-    sensitive: flat.flatMap((plugin) => plugin.options.sensitive),
-    unique: flat.flatMap((plugin) => plugin.options.unique),
-    change: flat.flatMap((plugin) => plugin.options.change),
-    descriptors,
-    hooks: Object.freeze(hooks)
-  };
-}
-
-// src/core/record/record.ts
-function recordBuilderOf2(...catalogs) {
-  const context = pluginContextOf(catalogs);
-  return (blueprint, options = {}) => declareRecord(AbstractRecord, blueprint, options, "record", [], context);
-}
-function pluginContextOf(catalogs) {
-  return Object.freeze(Object.assign({}, ...catalogs.map((catalog) => catalog.plugins)));
-}
-var recordOf3 = recordBuilderOf2();
-function declareRecord(Base, declared, { plugins = [], name: declaredName, ...declaredOptions }, fallback, reserved = [], context = {}) {
-  if (declaredName !== undefined && !isRecordName(declaredName)) {
-    throw new InvalidRecordDeclaration2({
-      source: fallback,
-      details: `"name" must be an identifier, got ${JSON.stringify(declaredName)}.`
-    });
-  }
-  const name = declaredName ?? fallback;
-  const applied = applyPlugins(declared, typeof plugins === "function" ? plugins(context) : plugins, name, reserved);
-  const blueprint = applied.blueprint;
-  const sensitive = [
-    ...declaredOptions.sensitive ?? [],
-    ...applied.sensitive
-  ];
-  const unique = [...declaredOptions.unique ?? [], ...applied.unique];
-  const declaredChange = declaredOptions.change ?? [];
-  const keys = Object.keys(blueprint.properties);
-  const change = keys.filter((key) => declaredChange.includes(key) || applied.change.includes(key));
-  for (const key of [...sensitive, ...unique, ...declaredChange]) {
-    if (!keys.includes(key)) {
-      throw new UndeclaredRecordProperty2({
-        source: name,
-        details: { key }
-      });
-    }
-  }
-  const methods = change.length > 0 ? [CHANGE_MEMBER] : [];
-  for (const member of Object.keys(applied.descriptors)) {
-    if (methods.includes(member)) {
-      const plugin = applied.plugins.find((plugin) => plugin.members.includes(member));
-      throw new RecordPluginConflict2({
-        source: name,
-        details: {
-          plugin: plugin.name,
-          key: member,
-          owner: `record "${name}" (the \`change\` namespace)`
-        }
-      });
-    }
-  }
-  for (const key of keys) {
-    if (RESERVED_RECORD_KEYS2.includes(key) || reserved.includes(key) || methods.includes(key)) {
-      throw new ReservedRecordKey2({ source: name, details: { key } });
-    }
-  }
-  const options = Object.freeze({
-    sensitive: Object.freeze(keys.filter((key) => sensitive.includes(key) || isMarked(blueprint.properties[key], "sensitive", { lists: true }))),
-    unique: Object.freeze(keys.filter((key) => unique.includes(key) || isMarked(blueprint.properties[key], "unique"))),
-    change: Object.freeze([...change])
-  });
-
-  class DeclaredRecord extends Base {
-    static [Kind2] = "record";
-    static blueprint = blueprint;
-    static options = options;
-    static plugins = applied.plugins;
-    static [RecordPlugins] = applied.plugins;
-    static [RecordPluginHooks] = applied.hooks;
-  }
-  if (declaredName !== undefined) {
-    declareRecordName(DeclaredRecord, declaredName);
-  }
-  Object.defineProperty(DeclaredRecord, "recordName", {
-    get() {
-      return declaredName ?? this.name;
-    },
-    configurable: true
-  });
-  exposeRecordKeys(DeclaredRecord.prototype, keys);
-  for (const [member, descriptor] of Object.entries(applied.descriptors)) {
-    Object.defineProperty(DeclaredRecord.prototype, member, descriptor);
-  }
-  if (change.length > 0) {
-    Object.defineProperty(DeclaredRecord.prototype, CHANGE_MEMBER, {
-      get() {
-        let namespace = changeNamespaces.get(this);
-        if (namespace === undefined) {
-          namespace = Object.freeze(Object.fromEntries(change.map((key) => [
-            key,
-            (value) => this.set(key, value)
-          ])));
-          changeNamespaces.set(this, namespace);
-        }
-        return namespace;
-      },
-      configurable: true
-    });
-  }
-  Object.defineProperty(DeclaredRecord, "name", { value: name });
-  return DeclaredRecord;
-}
-var CHANGE_MEMBER = "change";
-var changeNamespaces = new WeakMap;
-
-// src/core/entity/exceptions.ts
-var ReservedEntityKey2 = exceptionOf2({
-  layer: "entity" /* Entity */,
-  name: "ReservedEntityKey",
-  message: ({ key }, source) => `"${key}" is a key or a member of every entity and cannot be a key of the blueprint of "${source}".`
-});
-var ImmutableEntityKey2 = exceptionOf2({
-  layer: "entity" /* Entity */,
-  name: "ImmutableEntityKey",
-  message: ({ key }, source) => `"${key}" of entity "${source}" cannot be changed.`
-});
-var DeletedEntity2 = exceptionOf2({
-  layer: "entity" /* Entity */,
-  name: "DeletedEntity",
-  message: ({ id }, source) => `Entity "${source}" of id "${id}" was destroyed and cannot change.`
-});
-var InvalidEntityExpiry2 = exceptionOf2({
-  layer: "entity" /* Entity */,
-  name: "InvalidEntityExpiry",
-  message: ({ reason }, source) => `Invalid expires of entity "${source}": ${reason}`
-});
-var InvalidEntitySchemaVersion2 = exceptionOf2({
-  layer: "entity" /* Entity */,
-  name: "InvalidEntitySchemaVersion",
-  message: ({ reason }, source) => `Invalid schema evolution options of entity "${source}": ${reason}`
-});
-
-// src/core/entity/trust.ts
-var MakesValid = Symbol("makesValid");
-function vouching(settings, makers) {
-  return Object.defineProperty({ ...settings }, MakesValid, { value: makers });
-}
-function validMakersOf(settings) {
-  return settings[MakesValid];
-}
-
-// src/core/entity/version.ts
-import { Type as Type4 } from "typebox";
-class EntityVersion2 extends propertyOf2({
-  name: "version",
-  schema: Type4.Integer({ minimum: 1 }),
-  default: 1
-}) {
-}
-var VersionIdentity = blueprintBuilderOf2()(() => ({
-  version: EntityVersion2
-}));
-
-// src/core/entity/entity.ts
-function entityBuilderOf2(settings) {
-  const { identity, generateId, now, expiresAt, plugins: catalogs } = settings;
-  const clock = Object.freeze({
-    generateId,
-    now,
-    makesValid: validMakersOf(settings)
-  });
-  const context = pluginContextOf(catalogs ?? []);
-  return (blueprint, options = {}) => {
-    const lifetime = lifetimeOf(blueprint, options);
-    const expiring = lifetime !== undefined;
-    const versioned = options.versioned === true;
-    const added = [
-      ...versioned ? [ENTITY_VERSION_KEY] : [],
-      ...expiring ? [EXPIRES_AT] : []
-    ];
-    if (expiring && expiresAt === undefined) {
-      throw new InvalidEntityExpiry2({
-        source: options.name ?? "entity",
-        details: {
-          reason: "the entity builder has no expiresAt field, which expires: { after } needs."
-        }
-      });
-    }
-    const schemaVersioned = options.schemaVersion !== undefined;
-    checkSchemaOptions(options);
-    if (schemaVersioned)
-      added.push(SCHEMA_VERSION_KEY2);
-    for (const key of Object.keys(blueprint.properties)) {
-      if (RESERVED_ENTITY_KEYS2.includes(key) || added.includes(key)) {
-        throw new ReservedEntityKey2({ source: "entity", details: { key } });
-      }
-    }
-    for (const key of options.change ?? []) {
-      if (ENTITY_IDENTITY_KEYS2.includes(key) || added.includes(key)) {
-        throw new ImmutableEntityKey2({ source: "entity", details: { key } });
-      }
-    }
-    const DeclaredEntity = declareRecord(AbstractEntity, identity.join(...versioned ? [VersionIdentity] : [], ...expiring ? [
-      blueprintFromProperties([], {
-        [EXPIRES_AT]: expiresAt
-      })
-    ] : [], blueprint), {
-      ...withoutStorage(options),
-      unique: ["id", ...options.unique ?? []]
-    }, "entity", ENTITY_MEMBERS, context);
-    Object.defineProperty(DeclaredEntity, IdentifiedRecord, { value: true });
-    Object.defineProperty(DeclaredEntity, EntityClock, { value: clock });
-    Object.defineProperty(DeclaredEntity, EntityClassBrand, { value: true });
-    Object.defineProperty(DeclaredEntity, EntityUniqueKeys2, {
-      value: DeclaredEntity.options.unique
-    });
-    Object.defineProperty(DeclaredEntity, EntityLifetime, { value: lifetime });
-    Object.defineProperty(DeclaredEntity, EntitySettings2, {
-      value: Object.freeze({
-        versioned,
-        expires: options.expires,
-        schemaVersioned,
-        schemaVersion: options.schemaVersion ?? 1,
-        upgrade: Object.freeze({ ...options.upgrade }),
-        previousNames: Object.freeze([...options.previousNames ?? []])
-      })
-    });
-    Object.defineProperty(DeclaredEntity, EntityEventSettings, {
-      value: Object.freeze({
-        onCreate: options.onCreate,
-        onUpdate: options.onUpdate,
-        onDelete: options.onDelete
-      })
-    });
-    return DeclaredEntity;
-  };
-}
-function isEntityClass2(value) {
-  return isRecordClass(value) && value.prototype instanceof AbstractEntity;
-}
-function isEntity2(value) {
-  return value instanceof AbstractEntity;
-}
-function checkSchemaOptions(options) {
-  const source = options.name ?? "entity";
-  const fail = (reason) => {
-    throw new InvalidEntitySchemaVersion2({ source, details: { reason } });
-  };
-  const { schemaVersion = 1, upgrade, previousNames } = options;
-  if (!Number.isSafeInteger(schemaVersion) || schemaVersion < 1) {
-    fail("expected schemaVersion to be a positive integer.");
-  }
-  if (upgrade !== undefined) {
-    if (typeof upgrade !== "object" || upgrade === null) {
-      fail("expected upgrade to be an object of steps by version.");
-    }
-    for (const [key, step] of Object.entries(upgrade)) {
-      const version = Number(key);
-      if (!Number.isSafeInteger(version) || version < 2 || version > schemaVersion) {
-        fail(`the upgrade step "${key}" must reach a version from 2 to the schemaVersion (${schemaVersion}).`);
-      }
-      if (typeof step !== "function") {
-        fail(`the upgrade step ${key} is not a function.`);
-      }
-    }
-  }
-  if (previousNames !== undefined) {
-    if (!Array.isArray(previousNames)) {
-      fail("expected previousNames to be a list of names.");
-    }
-    for (const previous of previousNames) {
-      if (!isRecordName(previous) || previous === options.name) {
-        fail(`"${String(previous)}" cannot be a previous name: expected an identifier other than the name of the entity.`);
-      }
-    }
-  }
-}
-function withoutStorage(options) {
-  const {
-    versioned: _versioned,
-    expires: _expires,
-    schemaVersion: _schemaVersion,
-    upgrade: _upgrade,
-    previousNames: _previousNames,
-    ...rest
-  } = options;
-  return rest;
-}
-var DURATION_UNITS = {
-  days: 86400000,
-  hours: 3600000,
-  minutes: 60000,
-  seconds: 1000
-};
-function isDateField(field) {
-  if (!isProperty(field))
-    return false;
-  const schema = field.type.schema.type.Type();
-  return schema.type === "string" && (schema.format === "date-time" || schema.format === "date");
-}
-function lifetimeOf(blueprint, options) {
-  const { expires } = options;
-  if (expires === undefined)
-    return;
-  const fail = (reason) => {
-    throw new InvalidEntityExpiry2({
-      source: options.name ?? "entity",
-      details: { reason }
-    });
-  };
-  const plain = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-  if (!plain(expires) || Object.keys(expires).length !== 1)
-    return fail("expected { after: duration } or { at: key }.");
-  if ("at" in expires) {
-    const { at } = expires;
-    if (typeof at !== "string" || !Object.hasOwn(blueprint.properties, at))
-      return fail(`"${String(at)}" is not a key of the blueprint.`);
-    if (!isDateField(blueprint.properties[at]))
-      return fail(`"${at}" does not hold a date.`);
-    return;
-  }
-  if (!("after" in expires)) {
-    return fail("expected { after: duration } or { at: key }.");
-  }
-  const { after } = expires;
-  if (!plain(after) || Object.keys(after).length === 0)
-    return fail("after must be a non-empty duration, e.g. { days: 400 }.");
-  let total = 0;
-  for (const [unit, amount] of Object.entries(after)) {
-    if (!Object.hasOwn(DURATION_UNITS, unit))
-      return fail(`"${unit}" is not a unit of a duration (days, hours, minutes, seconds).`);
-    if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0)
-      return fail(`${unit} must be a positive finite number.`);
-    total += amount * DURATION_UNITS[unit];
-  }
-  return total;
-}
-
-// src/core/entity/event.ts
-var EntityClassBrand = Symbol("entityClass");
-var EventBrand = Symbol("event");
-var EntityEventSettings = Symbol("entityEvents");
-var definitions = new WeakMap;
-var queues = new WeakMap;
-var withHandler = new WeakSet;
-function eventOf2(name, entityClass, handler) {
-  if (!isEntityClass2(entityClass)) {
-    throw new TypeError("An event requires an entity class");
-  }
-  if (handler !== undefined && typeof handler !== "function") {
-    throw new TypeError(`The handler of event ${name} must be a function`);
-  }
-  const event = Object.freeze({
-    name,
-    [EventBrand]: true
-  });
-  if (handler)
-    withHandler.add(event);
-  definitions.set(event, (entity) => {
-    if (!(entity instanceof entityClass)) {
-      throw new TypeError(`Incompatible entity for event ${name}`);
-    }
-    return Object.freeze({
-      name,
-      entity,
-      async handle(context) {
-        if (!handler)
-          return;
-        await handler(entity, {
-          logger: context?.logger ?? resolveLogger(undefined, undefined) ?? silentLogger
-        });
-      }
-    });
-  });
-  return event;
-}
-function eventHasHandler(event) {
-  return withHandler.has(event);
-}
-function lifecycleEventsOf(entityClass) {
-  const settings = entityClass[EntityEventSettings];
-  const found = {};
-  for (const cycle of ["onCreate", "onUpdate", "onDelete"]) {
-    const reference = settings?.[cycle];
-    if (reference === undefined)
-      continue;
-    const events = typeof reference === "function" ? reference() : reference;
-    const list = Array.isArray(events) ? events : [events];
-    if (list.length > 0)
-      found[cycle] = list;
-  }
-  return found;
-}
-function enqueueEvent(entity, event) {
-  const bind = definitions.get(event);
-  if (!bind)
-    throw new TypeError("Expected an eventOf definition");
-  const occurrence = bind(entity);
-  const queue = queues.get(entity) ?? [];
-  queue.push(occurrence);
-  queues.set(entity, queue);
-}
-function pullEntityEvents(entity) {
-  const queue = queues.get(entity) ?? [];
-  queues.delete(entity);
-  return queue;
-}
-function enqueueLifecycle(entity, cycle) {
-  const settings = entity.constructor[EntityEventSettings];
-  const reference = settings?.[cycle];
-  if (reference === undefined)
-    return;
-  const events = typeof reference === "function" ? reference() : reference;
-  for (const event of Array.isArray(events) ? events : [events]) {
-    enqueueEvent(entity, event);
-  }
-}
-
-// src/core/entity/abstract-entity.ts
-var ENTITY_IDENTITY_KEYS2 = Object.freeze(["id", "createdAt", "updatedAt", "deletedAt"]);
-var ENTITY_MEMBERS = Object.freeze([
-  "destroy",
-  "isDeleted",
-  "equals",
-  "onDestroy",
-  "emit",
-  "pullEvents"
-]);
-var RESERVED_ENTITY_KEYS2 = Object.freeze([
-  ...ENTITY_IDENTITY_KEYS2,
-  ...ENTITY_MEMBERS
-]);
-var EntityClock = Symbol("entityClock");
-var EntityUniqueKeys2 = Symbol("entityUniqueKeys");
-var EntitySettings2 = Symbol("entitySettings");
-var EntityLifetime = Symbol("entityLifetime");
-var EXPIRES_AT = "expiresAt";
-var ENTITY_VERSION_KEY = "version";
-var SCHEMA_VERSION_KEY2 = "$v";
-function isVersionedEntityClass(entityClass) {
-  if (typeof entityClass !== "function")
-    return false;
-  return entityClass[EntitySettings2]?.versioned === true;
-}
-function identityKeysOf(entityClass) {
-  const keys = [...ENTITY_IDENTITY_KEYS2];
-  if (isVersionedEntityClass(entityClass))
-    keys.push(ENTITY_VERSION_KEY);
-  if (typeof entityClass === "function" && entityClass[EntityLifetime] !== undefined) {
-    keys.push(EXPIRES_AT);
-  }
-  return keys;
-}
-function isIdentityKey(Entity, key) {
-  return identityKeysOf(Entity).includes(key);
-}
-function storeEntityVersion(entity, version) {
-  storeRecordValue(entity, ENTITY_VERSION_KEY, version);
-}
-var ID_MADE = Object.freeze(["id"]);
-var CREATED_AT_MADE = Object.freeze(["createdAt"]);
-var BOTH_MADE = Object.freeze(["id", "createdAt"]);
-function identityOf(entity) {
-  return entity;
-}
-function clockOf(entity) {
-  return entity.constructor[EntityClock];
-}
-function assertAlive(entity) {
-  if (entity.isDeleted) {
-    throw new DeletedEntity2({
-      source: recordNameOf2(entity.constructor),
-      details: { id: identityOf(entity).id }
-    });
-  }
-}
-function withIdentity(value, clock, lifetime, versioned) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return value;
-  }
-  const { id, createdAt, expiresAt, version } = value;
-  const expiring = lifetime !== undefined && expiresAt === undefined;
-  const unversioned = versioned && version === undefined;
-  if (id !== undefined && createdAt !== undefined && !expiring && !unversioned)
-    return value;
-  const created = createdAt === undefined ? clock.now() : createdAt;
-  const identity = {
-    id: undefined,
-    createdAt: undefined,
-    ...value
-  };
-  identity.id = id === undefined ? clock.generateId() : id;
-  identity.createdAt = created;
-  const { makesValid } = clock;
-  if (makesValid !== undefined) {
-    const idMade = id === undefined && makesValid.id();
-    const createdAtMade = createdAt === undefined && makesValid.createdAt();
-    if (idMade && createdAtMade)
-      vouchFor(BOTH_MADE);
-    else if (idMade)
-      vouchFor(ID_MADE);
-    else if (createdAtMade)
-      vouchFor(CREATED_AT_MADE);
-  }
-  if (unversioned)
-    identity[ENTITY_VERSION_KEY] = 1;
-  if (expiring) {
-    const start = typeof created === "string" ? Date.parse(created) : NaN;
-    if (!Number.isNaN(start)) {
-      identity[EXPIRES_AT] = new Date(start + lifetime).toISOString();
-    }
-  }
-  return identity;
-}
-
-class AbstractEntity extends AbstractRecord {
-  constructor(value) {
-    super(withIdentity(value, new.target[EntityClock], new.target[EntityLifetime], isVersionedEntityClass(new.target)));
-    const input = value;
-    if (input.id === undefined && input.createdAt === undefined) {
-      enqueueLifecycle(this, "onCreate");
-    }
-  }
-  emit(event) {
-    enqueueEvent(this, event);
-  }
-  pullEvents() {
-    return pullEntityEvents(this);
-  }
-  get isDeleted() {
-    return identityOf(this).deletedAt !== undefined;
-  }
-  equals(other) {
-    return other instanceof AbstractEntity && other[Meta2].blueprint === this[Meta2].blueprint && identityOf(other).id === identityOf(this).id;
-  }
-  destroy() {
-    assertAlive(this);
-    storeRecordValue(this, "deletedAt", clockOf(this).now());
-    enqueueLifecycle(this, "onDelete");
-    this.onDestroy();
-    return this;
-  }
-  set(key, value) {
-    const name = String(key);
-    if (isIdentityKey(this.constructor, name)) {
-      throw new ImmutableEntityKey2({
-        source: recordNameOf2(this.constructor),
-        details: { key: name }
-      });
-    }
-    assertAlive(this);
-    const { next, previous } = storeRecordValue(this, name, value);
-    storeRecordValue(this, "updatedAt", clockOf(this).now());
-    enqueueLifecycle(this, "onUpdate");
-    return runRecordEffects(this, key, next, previous);
-  }
-  onDestroy() {}
-}
-
-// src/core/repository/exceptions.ts
-var InvalidRepositoryQuery2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryQuery",
-  message: ({ reason }) => reason
-});
-var InvalidRepositoryCursor2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryCursor",
-  message: ({
-    reason
-  }) => reason
-});
-var InvalidRepositoryDeclaration2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryDeclaration",
-  message: ({ reason }) => reason
-});
-var InvalidRepositoryEntity2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryEntity",
-  message: (_details, source) => `"${source}" expected an entity of its own class.`
-});
-var InvalidStoredSchemaVersion2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "InvalidStoredSchemaVersion",
-  message: ({
-    id,
-    stored,
-    current,
-    reason
-  }, source) => reason ?? `"${source}" read the row "${id}" stored at schema version ${JSON.stringify(stored)}, and its entity is at version ${current}.`
-});
-var InvalidRepositoryData2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryData",
-  message: (_details, source) => `"${source}" read a value that its entity rejects.`
-});
-var RepositoryUniqueViolation2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "RepositoryUniqueViolation",
-  message: ({ key }, source) => `"${source}" already holds an entity with this "${key}".`
-});
-var RepositoryUsedOutsideApplication2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "RepositoryUsedOutsideApplication",
-  message: ({
-    application,
-    repository
-  }, source) => `"${source}" is bound to the application "${application}", and its declaration no longer reads or writes: use app.repositories.${repository}, run its use cases with app.run, or give the repository of the application to execute.`
-});
-var RepositoryEntityNotFound2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "RepositoryEntityNotFound",
-  message: ({ id }, source) => `"${source}" holds no entity of id "${id}".`
-});
-var RepositoryConcurrencyConflict2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "RepositoryConcurrencyConflict",
-  message: ({
-    id,
-    expected
-  }, source) => `"${source}" holds another version of "${id}" than ${expected}: it changed since it was read.`
-});
-var InvalidRepositoryIncrement2 = exceptionOf2({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryIncrement",
-  message: ({
-    reason
-  }) => reason
-});
-
-// src/core/json.ts
-function frozenJson(value, subject, fail, seen = new Set) {
-  if (value === null || typeof value === "string" || typeof value === "boolean")
-    return value;
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value !== "object" || value === null || seen.has(value))
-    return fail(`${subject} must be finite, acyclic JSON values.`);
-  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
-    return fail(`${subject} must contain only plain objects and arrays.`);
-  if (Object.getOwnPropertySymbols(value).length > 0)
-    return fail(`${subject} cannot contain symbol keys.`);
-  seen.add(value);
-  const result = Array.isArray(value) ? value.map((item) => frozenJson(item, subject, fail, seen)) : Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    frozenJson(item, subject, fail, seen)
-  ]));
-  seen.delete(value);
-  return Object.freeze(result);
-}
-
-// src/core/repository/state.ts
-var states = new WeakMap;
-function findState(repository) {
-  if (typeof repository !== "object" || repository === null)
-    return;
-  for (let Class = repository.constructor;typeof Class === "function"; Class = Object.getPrototypeOf(Class)) {
-    const state = states.get(Class);
-    if (state)
-      return state;
-  }
-  return;
-}
-function stateOf(repository) {
-  const state = findState(repository);
-  if (!state)
-    throw new TypeError("Expected a repository made by repositoryOf");
-  return state;
-}
-function expiryKeyOf(entity) {
-  const expires = entity[EntitySettings2]?.expires;
-  if (expires === undefined)
-    return;
-  return "at" in expires ? expires.at : EXPIRES_AT;
-}
-function schemaOf2(entity) {
-  const settings = entity[EntitySettings2];
-  if (!settings?.schemaVersioned)
-    return;
-  return Object.freeze({
-    version: settings.schemaVersion,
-    key: SCHEMA_VERSION_KEY2,
-    previousNames: settings.previousNames
-  });
-}
-function contextOf(state) {
-  if (state.context)
-    return state.context;
-  const key = expiryKeyOf(state.entity);
-  const schema = schemaOf2(state.entity);
-  state.context = Object.freeze({
-    entity: state.entity,
-    name: state.name,
-    unique: state.entity[EntityUniqueKeys2],
-    indexes: state.indexes,
-    ...key === undefined ? {} : { expiry: Object.freeze({ key }) },
-    ...schema === undefined ? {} : { schema },
-    env: loadEnvironments(state.environment)
-  });
-  return state.context;
-}
-function inspectRepository(repository) {
-  const state = findState(repository);
-  if (!state)
-    return;
-  const { environment } = state;
-  return {
-    entity: state.entity,
-    actions: state.actions,
-    deletion: state.deletion,
-    indexes: state.indexes,
-    scans: state.scans,
-    explicitProvider: state.explicitProvider,
-    provider: state.explicitProvider ? state.provider : undefined,
-    environments: environment === undefined ? [] : Array.isArray(environment) ? environment : [environment],
-    relations: [...state.relations.values()].map(declarationOf),
-    state: declarationOf(state)
-  };
-}
-var origins = new WeakMap;
-function declarationOf(state) {
-  return origins.get(state) ?? state;
-}
-var declared2 = new WeakMap;
-function declareRepository(state, repository) {
-  declared2.set(state, repository);
-}
-function relatedRepositoryOf(repository, Entity) {
-  const related = findState(repository)?.relations.get(Entity);
-  return related ? declared2.get(declarationOf(related)) : undefined;
-}
-function bindState(state, provider, instances, logger, bound = new Map) {
-  const done = bound.get(state);
-  if (done)
-    return done;
-  const copy = {
-    ...state,
-    logger,
-    provider: state.explicitProvider ? instances?.get(state.provider) ?? state.provider : provider ?? state.provider,
-    context: undefined,
-    relations: new Map([...state.relations].map(([target, related]) => [
-      target,
-      bindState(related, provider, instances, logger, bound)
-    ]))
-  };
-  origins.set(copy, declarationOf(state));
-  bound.set(state, copy);
-  return copy;
-}
-var owners = new WeakMap;
-function assertUnbound(state) {
-  const owner = owners.get(state);
-  if (owner) {
-    throw new RepositoryUsedOutsideApplication2({
-      source: state.name,
-      details: owner
-    });
-  }
-}
-function bindRepository(repository, provider, instances, binding) {
-  const state = stateOf(repository);
-  const Declared = repository.constructor;
-
-  class Bound extends Declared {
-  }
-  Object.defineProperty(Bound, "name", { value: Declared.name });
-  states.set(Bound, bindState(state, provider, instances, binding?.logger));
-  if (binding) {
-    owners.set(declarationOf(state), {
-      application: binding.application,
-      repository: binding.key
-    });
-  }
-  return Object.freeze(new Bound);
-}
-function providerOfRepository(repository) {
-  return findState(repository)?.provider;
-}
-
-// src/core/openapi/exceptions.ts
-var InvalidOpenAPIModel2 = exceptionOf2({
-  layer: "output" /* Output */,
-  name: "InvalidOpenAPIModel",
-  message: ({ name }) => `"${name}" is not a property, blueprint, list, record or entity.`
-});
-
-// src/core/openapi/openapi.ts
-var NO_MARKS = { writeOnly: [], readOnly: [] };
-function isField(value) {
-  return isProperty(value) || isBlueprint(value) || isBlueprintList(value) || isBlueprintVariant(value) || recordFieldOf(value) !== undefined;
-}
-function isOptional(field) {
-  if (isProperty(field))
-    return field.type.optional === true;
-  if (isBlueprint(field) || isBlueprintList(field) || isBlueprintVariant(field)) {
-    return field.optional;
-  }
-  return recordFieldOf(field)?.optional ?? false;
-}
-function plainOf(value, nested = false) {
-  if (Array.isArray(value))
-    return value.map((item) => plainOf(item, true));
-  if (typeof value !== "object" || value === null)
-    return value;
-  const id = value.$id;
-  if (nested && typeof id === "string")
-    return { $ref: id };
-  const plain = {};
-  for (const [key, item] of Object.entries(value)) {
-    if (!key.startsWith("~"))
-      plain[key] = plainOf(item, true);
-  }
-  return plain;
-}
-function objectOf(properties, scope, marks) {
-  const shape = {};
-  const required = [];
-  for (const [key, field] of Object.entries(properties)) {
-    const schema = schemaOf3(field, scope);
-    if (marks.readOnly.includes(key))
-      schema.readOnly = true;
-    if (marks.writeOnly.includes(key))
-      schema.writeOnly = true;
-    shape[key] = schema;
-    if (!isOptional(field))
-      required.push(key);
-  }
-  return {
-    type: "object",
-    properties: shape,
-    ...required.length > 0 ? { required } : {},
-    additionalProperties: false
-  };
-}
-function recordSchemaOf(record, scope) {
-  const { sensitive = [] } = record.options ?? {};
-  return objectOf(record.blueprint.properties, scope, {
-    writeOnly: sensitive,
-    readOnly: isEntityClass2(record) ? identityKeysOf(record) : []
-  });
-}
-function schemaOf3(field, scope) {
-  if (isBlueprintList(field)) {
-    const { item, minItems, maxItems } = field;
-    return {
-      type: "array",
-      items: schemaOf3(item, scope),
-      ...minItems === undefined ? {} : { minItems },
-      ...maxItems === undefined ? {} : { maxItems }
-    };
-  }
-  if (isBlueprint(field))
-    return objectOf(field.properties, scope, NO_MARKS);
-  if (isBlueprintVariant(field)) {
-    const variants = field.variants;
-    return {
-      oneOf: Object.entries(variants).map(([tag, variant]) => {
-        const object = isRecordClass(variant) ? recordSchemaOf(variant, scope) : objectOf(variant.properties, scope, NO_MARKS);
-        return {
-          ...object,
-          properties: { [field.key]: { const: tag }, ...object.properties },
-          required: [field.key, ...object.required ?? []]
-        };
-      }),
-      discriminator: { propertyName: field.key }
-    };
-  }
-  const record = recordFieldOf(field);
-  if (record) {
-    const name = scope.names.get(record.record);
-    return name === undefined ? recordSchemaOf(record.record, scope) : { $ref: `${scope.prefix}${name}` };
-  }
-  if (!isProperty(field)) {
-    throw new InvalidOpenAPIModel2({
-      source: "openapi",
-      details: { name: String(field) }
-    });
-  }
-  const schema = plainOf(field.type.schema.type.Type());
-  if (field.type.sensitive)
-    schema.writeOnly = true;
-  return schema;
-}
-function toOpenAPI2(modelOrModels, { refPrefix = "#/components/schemas/" } = {}) {
-  if (isField(modelOrModels)) {
-    return schemaOf3(modelOrModels, { names: new Map, prefix: refPrefix });
-  }
-  if (typeof modelOrModels !== "object" || modelOrModels === null) {
-    throw new InvalidOpenAPIModel2({
-      source: "openapi",
-      details: { name: String(modelOrModels) }
-    });
-  }
-  const names = new Map;
-  for (const [name, model] of Object.entries(modelOrModels)) {
-    if (!isField(model)) {
-      throw new InvalidOpenAPIModel2({ source: "openapi", details: { name } });
-    }
-    const record = recordFieldOf(model);
-    if (record && !names.has(record.record))
-      names.set(record.record, name);
-  }
-  const scope = { names, prefix: refPrefix };
-  const schemas = {};
-  for (const [name, model] of Object.entries(modelOrModels)) {
-    const record = recordFieldOf(model);
-    schemas[name] = record && names.get(record.record) === name ? recordSchemaOf(record.record, scope) : schemaOf3(model, scope);
-  }
-  return { schemas };
-}
-
-// src/core/use-case/route.ts
-var ROUTE_METHODS = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete"
-];
-var ROUTE_SUCCESS_STATUSES = [
-  200,
-  201,
-  202,
-  204
-];
-var PARAMETER = /^\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
-var HEADER_NAME = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
-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));
-}
-function parametersOfPath(path) {
-  const names = [];
-  for (const segment of path.split("/")) {
-    const name = PARAMETER.exec(segment)?.[1];
-    if (name)
-      names.push(name);
-  }
-  return names;
-}
-function isScalarSchema(schema) {
-  const types = [schema.type ?? []].flat();
-  return !types.some((type) => type === "object" || type === "array");
-}
-function isScalarKey(blueprint, name) {
-  if (!Object.hasOwn(blueprint.properties, name))
-    return false;
-  const field = blueprint.properties[name];
-  return isProperty(field) && isScalarSchema(toOpenAPI2(field));
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var ROUTE_KEYS = [
-  "method",
-  "path",
-  "status",
-  "query",
-  "headers",
-  "cookie",
-  "setCookie"
-];
-var 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;
-}
-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 })])))
-    }
-  });
-}
-
-// src/core/output/exceptions.ts
-var InvalidOutputStage2 = exceptionOf2({
-  layer: "output" /* Output */,
-  name: "InvalidOutputStage",
-  message: ({ reason }) => reason
-});
-var DuplicateOperation2 = exceptionOf2({
-  layer: "output" /* Output */,
-  name: "DuplicateOperation",
-  message: ({ id }) => `The operation "${id}" is declared twice.`
-});
-var Unauthenticated2 = exceptionOf2({
-  layer: "output" /* Output */,
-  name: "Unauthenticated",
-  message: "Authentication is required."
-});
-var Forbidden2 = exceptionOf2({
-  layer: "output" /* Output */,
-  name: "Forbidden",
-  message: (_details) => "The caller may not do this."
-});
-
-// src/core/output/stage.ts
-var descriptions = new WeakMap;
-var factories = new WeakMap;
-var opaque = Object.freeze({ kind: "opaque" });
-function invalid2(source, reason) {
-  throw new InvalidOutputStage2({ source, details: { reason } });
-}
-function optionsOf(name, given, validate) {
-  const options = frozenJson(given ?? {}, "Stage options", (reason) => invalid2(name, reason));
-  if (options === null || typeof options !== "object" || Array.isArray(options)) {
-    invalid2(name, "Stage options must be an object.");
-  }
-  const reason = validate?.(options);
-  if (reason !== undefined)
-    invalid2(name, reason);
-  return options;
-}
-function checkName(source, name) {
-  if (typeof name !== "string" || !name.trim()) {
-    invalid2(source, "Expected the stage name to be a non-empty string.");
-  }
-}
-function transformOf2(settings) {
-  checkName("transformOf", settings?.name);
-  if (typeof settings.apply !== "function") {
-    invalid2(settings.name, "Expected apply to be a function.");
-  }
-  const { name, apply, validate } = settings;
-  const factory = (given) => {
-    const options = optionsOf(name, given, validate);
-    const stage = Object.freeze({
-      kind: "transform",
-      name,
-      options,
-      apply: (operation, context) => apply(operation, options, context)
-    });
-    descriptions.set(stage, Object.freeze({
-      kind: "transform",
-      name,
-      options
-    }));
-    return stage;
-  };
-  factories.set(factory, { kind: "transform", name });
-  return factory;
-}
-function sinkOf2(settings) {
-  checkName("sinkOf", settings?.name);
-  if (typeof settings.build !== "function") {
-    invalid2(settings.name, "Expected build to be a function.");
-  }
-  const { name, build, validate } = settings;
-  const factory = (given, hooks) => {
-    const options = optionsOf(name, given, validate);
-    if (hooks !== undefined && (typeof hooks !== "object" || hooks === null || Array.isArray(hooks))) {
-      invalid2(name, "Stage hooks must be an object.");
-    }
-    const stage = Object.freeze({
-      kind: "sink",
-      name,
-      options,
-      build: (operations, context) => build(operations, options, context, hooks)
-    });
-    descriptions.set(stage, Object.freeze({
-      kind: "sink",
-      name,
-      options
-    }));
-    return stage;
-  };
-  factories.set(factory, { kind: "sink", name });
-  return factory;
-}
-function stageDescriptionOf2(stage) {
-  return descriptions.get(stage) ?? opaque;
-}
-function stageKindOf2(factory) {
-  return factories.get(factory)?.kind;
-}
-function isStage(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const { kind, apply, build } = value;
-  return kind === "transform" && typeof apply === "function" || kind === "sink" && typeof build === "function";
-}
-function stageCatalogOf2(...stages) {
-  const byName = {};
-  for (const factory of stages) {
-    const known = factories.get(factory);
-    if (!known) {
-      invalid2("catalog", "A catalog takes factories made by `transformOf` or `sinkOf`.");
-    }
-    if (Object.hasOwn(byName, known.name)) {
-      invalid2(known.name, "The catalog has another stage with its name.");
-    }
-    byName[known.name] = factory;
-  }
-  return Object.freeze({
-    [Kind2]: "stage-catalog",
-    stages: Object.freeze(byName),
-    list: Object.freeze([...stages]),
-    resolve(name, options) {
-      const factory = Object.hasOwn(byName, name) ? byName[name] : undefined;
-      if (!factory)
-        invalid2("catalog", `Unknown stage "${name}".`);
-      return factory(options);
-    }
-  });
-}
-
-// src/core/auth/jwt.ts
-var InvalidJwtOptions2 = exceptionOf2({
-  layer: "output" /* Output */,
-  name: "InvalidJwtOptions",
-  message: ({ reason }) => reason
-});
-var HASHES = {
-  HS256: "SHA-256",
-  HS384: "SHA-384",
-  HS512: "SHA-512"
-};
-var MIN_SECRET = 32;
-var DEFAULT_EXPIRES_IN = 900;
-var REGISTERED = new Set([
-  "sub",
-  "scope",
-  "iat",
-  "exp",
-  "nbf",
-  "iss",
-  "aud",
-  "use"
-]);
-var encoder = new TextEncoder;
-var decoder = new TextDecoder;
-function base64url(bytes) {
-  let binary = "";
-  for (const byte of bytes)
-    binary += String.fromCharCode(byte);
-  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-}
-function bytesOf(text) {
-  if (!/^[A-Za-z0-9_-]*$/.test(text))
-    return;
-  try {
-    const binary = atob(text.replaceAll("-", "+").replaceAll("_", "/"));
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0;i < binary.length; i++)
-      bytes[i] = binary.charCodeAt(i);
-    return bytes;
-  } catch {
-    return;
-  }
-}
-function jsonOf(part) {
-  const bytes = bytesOf(part);
-  if (!bytes)
-    return;
-  try {
-    const value = JSON.parse(decoder.decode(bytes));
-    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
-  } catch {
-    return;
-  }
-}
-function jwtOptionsIssue(options, where, extra = [], described = false) {
-  if (typeof options !== "object" || options === null || Array.isArray(options)) {
-    return `Expected ${where} to be { secret, issuer?, audience?, expiresIn?, algorithm? }.`;
-  }
-  const given = options;
-  const known = [
-    "secret",
-    "issuer",
-    "audience",
-    "expiresIn",
-    "algorithm",
-    ...extra
-  ];
-  for (const key of Object.keys(given)) {
-    if (!known.includes(key))
-      return `${where} has no option "${key}".`;
-  }
-  const { secret, issuer, audience, expiresIn, algorithm } = given;
-  const named = typeof secret === "object" && secret !== null && !Array.isArray(secret) ? secret : undefined;
-  if (named ? Object.keys(named).join() !== "env" || typeof named.env !== "string" || named.env === "" : typeof secret !== "string") {
-    return `Expected ${where}.secret to be the secret or { "env": "NAME" }.`;
-  }
-  if (described && !named) {
-    return `Expected ${where}.secret to be { "env": "NAME" }: these options are described, so the secret is named, not written.`;
-  }
-  if (typeof secret === "string" && secret.length < MIN_SECRET) {
-    return `Expected ${where}.secret to have at least ${MIN_SECRET} characters.`;
-  }
-  for (const [key, value] of [
-    ["issuer", issuer],
-    ["audience", audience]
-  ]) {
-    if (value !== undefined && (typeof value !== "string" || value === "")) {
-      return `Expected ${where}.${key} to be a non-empty string.`;
-    }
-  }
-  if (expiresIn !== undefined && (!Number.isInteger(expiresIn) || expiresIn <= 0)) {
-    return `Expected ${where}.expiresIn to be a whole number of seconds above 0.`;
-  }
-  if (algorithm !== undefined && !Object.hasOwn(HASHES, algorithm)) {
-    return `Expected ${where}.algorithm to be one of ${Object.keys(HASHES).join(", ")}.`;
-  }
-  return;
-}
-function jwtOf2(options) {
-  const issue = jwtOptionsIssue(options, "jwtOf");
-  if (issue) {
-    throw new InvalidJwtOptions2({
-      source: "jwtOf",
-      details: { reason: issue }
-    });
-  }
-  const algorithm = options.algorithm ?? "HS256";
-  const lifetime = options.expiresIn ?? DEFAULT_EXPIRES_IN;
-  const header = base64url(encoder.encode(JSON.stringify({ alg: algorithm, typ: "JWT" })));
-  let imported;
-  const keyOf = () => {
-    if (imported)
-      return imported;
-    let secret;
-    if (typeof options.secret === "string")
-      secret = options.secret;
-    else {
-      const name = options.secret.env;
-      secret = globalThis.process?.env?.[name];
-      if (typeof secret !== "string" || secret.length < MIN_SECRET) {
-        throw new InvalidJwtOptions2({
-          source: "jwtOf",
-          details: {
-            reason: `The environment variable ${name} must hold a secret of at least ${MIN_SECRET} characters.`
-          }
-        });
-      }
-    }
-    imported = crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: HASHES[algorithm] }, false, ["sign", "verify"]);
-    return imported;
-  };
-  const refused = () => {
-    throw new Unauthenticated2({ source: "jwt" });
-  };
-  const jwt = {
-    async sign(subject, token = {}) {
-      const now = Math.floor(Date.now() / 1000);
-      const payload = {
-        ...subject.claims ?? {},
-        sub: subject.subject,
-        scope: (subject.scopes ?? []).join(" "),
-        iat: now,
-        exp: now + (token.expiresIn ?? lifetime),
-        ...options.issuer === undefined ? {} : { iss: options.issuer },
-        ...options.audience === undefined ? {} : { aud: options.audience },
-        ...token.use === undefined ? {} : { use: token.use }
-      };
-      const signing = `${header}.${base64url(encoder.encode(JSON.stringify(payload)))}`;
-      const signature = await crypto.subtle.sign("HMAC", await keyOf(), encoder.encode(signing));
-      return `${signing}.${base64url(new Uint8Array(signature))}`;
-    },
-    async verify(token, expected = {}) {
-      if (typeof token !== "string")
-        return refused();
-      const parts = token.split(".");
-      if (parts.length !== 3)
-        return refused();
-      const [head, body, sign] = parts;
-      if (jsonOf(head)?.alg !== algorithm)
-        return refused();
-      const signature = bytesOf(sign);
-      if (!signature)
-        return refused();
-      const valid = await crypto.subtle.verify("HMAC", await keyOf(), signature, encoder.encode(`${head}.${body}`));
-      const payload = valid ? jsonOf(body) : undefined;
-      if (!payload)
-        return refused();
-      const now = Math.floor(Date.now() / 1000);
-      const { sub, scope, exp, nbf, iss, aud, use } = payload;
-      if (typeof sub !== "string" || sub === "" || typeof exp !== "number" || exp <= now || nbf !== undefined && (typeof nbf !== "number" || nbf > now) || options.issuer !== undefined && iss !== options.issuer || options.audience !== undefined && aud !== options.audience && !(Array.isArray(aud) && aud.includes(options.audience)) || use !== expected.use) {
-        return refused();
-      }
-      const claims = {};
-      for (const [key, value] of Object.entries(payload)) {
-        if (!REGISTERED.has(key))
-          claims[key] = value;
-      }
-      return {
-        subject: sub,
-        scopes: typeof scope === "string" && scope !== "" ? scope.split(" ") : [],
-        ...Object.keys(claims).length > 0 ? { claims } : {}
-      };
-    },
-    authenticator(reading = {}) {
-      const header = (reading.header ?? "authorization").toLowerCase();
-      const { cookie } = reading;
-      return async (request) => {
-        const sent = request.header(header);
-        const token = sent !== undefined ? sent.replace(/^Bearer +/i, "").trim() : cookie !== undefined ? request.cookie(cookie) : undefined;
-        if (token === undefined || token === "")
-          return null;
-        return jwt.verify(token);
-      };
-    }
-  };
-  return Object.freeze(jwt);
-}
-
-export { __export, isProperty, schemaOf, Demo2, recordPropertyLineage, propertyLineageOf2, fieldOf, Kind2, isBlueprint, isRecordClass, recordFieldOf, ExceptionLayers2, Exception2, isDeclaredException, declaredMessageOf, exceptionOf2, ReservedBlueprintKey2, InvalidBlueprintVariant2, UndeclaredBlueprintProperty2, exports_exceptions3, variantOf2, blueprintOfVariant, namedVariantOf, variantOfValue, isBlueprintVariant, State2, PropertyRequired2, InvalidPropertyValue2, exports_exceptions4, recordNameOf2, declaredRecordNameOf, fieldsOf, isPlainObject, listOf2, isBlueprintList, InvalidEnvironment2, environmentOf2, loadEnvironments, isEnvironment, exports_environment, InvalidApplicationDeclaration2, DuplicateApplicationDeclaration2, ApplicationConflict2, UnregisteredApplicationReference2, UnregisteredRepositoryDependency2, UnregisteredUseCaseDependency2, ApplicationNotStarted2, ProviderNotBound2, ApplicationAlreadyStarted2, SchemaLockMismatch2, InvalidSchemaMigration2, InvalidApplicationEnvironment2, exports_exceptions5, useApplication2, resetApplication2, startedApplication, setStartedApplication, InvalidLogDeclaration2, exports_exceptions6, LogLevels2, logProviderOf2, logProviderNameOf, consoleLogProvider2, jsonLogProvider2, memoryLogProvider2, checkLogSettings, silentLogger, applicationLogger, Logger2, isLoggerDeclaration, isLogger, ApplicationLoggerKey, resolveLogger, clock, elapsed, logFailure, writeLog, Meta2, InvalidRecordValue2, InvalidRecordDeclaration2, UndeclaredRecordProperty2, ReservedRecordKey2, InvalidRecordPlugin2, RecordPluginConflict2, UnknownRecordPlugin2, IncompatibleRecordPlugin2, exports_exceptions7, MASK2, RESERVED_RECORD_KEYS2, recordDataOf, recordFieldDataOf, AbstractRecord, propertyOf2, optionalOf2, blueprintBuilderOf2, blueprintFromProperties, isVersion, satisfies, pluginsOf2, isRecordPlugin, hasPlugin2, recordPluginOf2, recordBuilderOf2, recordOf3, declareRecord, ReservedEntityKey2, ImmutableEntityKey2, DeletedEntity2, InvalidEntityExpiry2, InvalidEntitySchemaVersion2, exports_exceptions8, vouching, EntityVersion2, entityBuilderOf2, isEntityClass2, isEntity2, eventOf2, eventHasHandler, lifecycleEventsOf, enqueueLifecycle, ENTITY_IDENTITY_KEYS2, RESERVED_ENTITY_KEYS2, EntityClock, EntityUniqueKeys2, EntitySettings2, SCHEMA_VERSION_KEY2, isVersionedEntityClass, identityKeysOf, storeEntityVersion, InvalidRepositoryQuery2, InvalidRepositoryCursor2, InvalidRepositoryDeclaration2, InvalidRepositoryEntity2, InvalidStoredSchemaVersion2, InvalidRepositoryData2, RepositoryUniqueViolation2, RepositoryUsedOutsideApplication2, RepositoryEntityNotFound2, RepositoryConcurrencyConflict2, InvalidRepositoryIncrement2, exports_exceptions9, frozenJson, states, findState, stateOf, contextOf, inspectRepository, declareRepository, relatedRepositoryOf, assertUnbound, bindRepository, providerOfRepository, InvalidOpenAPIModel2, exports_exceptions10, plainOf, toOpenAPI2, HEADER_NAME, isRoutePath, parametersOfPath, isScalarSchema, isScalarKey, routeDeclarationOf, InvalidOutputStage2, DuplicateOperation2, Unauthenticated2, Forbidden2, exports_exceptions11, transformOf2, sinkOf2, stageDescriptionOf2, stageKindOf2, isStage, stageCatalogOf2, InvalidJwtOptions2, jwtOptionsIssue, jwtOf2 };