@afora/core 0.0.8 → 0.0.9

package/dist/index-xegv6a1p.js

@@ -0,0 +1,4291 @@
+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 };